hexsha stringlengths 40 40 | size int64 5 2.72M | ext stringclasses 5
values | lang stringclasses 1
value | max_stars_repo_path stringlengths 3 976 | max_stars_repo_name stringlengths 5 113 | max_stars_repo_head_hexsha stringlengths 40 78 | 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:01:43 2022-03-31 23:59:48 ⌀ | max_stars_repo_stars_event_max_datetime stringdate 2015-01-01 00:06:24 2022-03-31 23:59:53 ⌀ | max_issues_repo_path stringlengths 3 976 | max_issues_repo_name stringlengths 5 116 | max_issues_repo_head_hexsha stringlengths 40 78 | 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 976 | max_forks_repo_name stringlengths 5 116 | max_forks_repo_head_hexsha stringlengths 40 78 | 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:19 2022-03-31 23:59:49 ⌀ | max_forks_repo_forks_event_max_datetime stringdate 2015-01-03 12:00:57 2022-03-31 23:59:49 ⌀ | content stringlengths 5 2.72M | avg_line_length float64 1.38 573k | max_line_length int64 2 1.01M | alphanum_fraction float64 0 1 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
ae8ce66b58dc4d6b7cf45e56a51032e04ea973eb | 1,665 | c | C | firmware/coreboot/3rdparty/chromeec/test/interrupt.c | fabiojna02/OpenCellular | 45b6a202d6b2e2485c89955b9a6da920c4d56ddb | [
"CC-BY-4.0",
"BSD-3-Clause"
] | 8 | 2018-11-15T12:15:45.000Z | 2021-07-01T10:26:13.000Z | test/interrupt.c | mmind/servo-chromiumos-ec | bb7b80033561023cd69cef86b00d2faa12fbc7d8 | [
"BSD-3-Clause"
] | 13 | 2018-10-12T21:29:09.000Z | 2018-10-25T20:06:51.000Z | test/interrupt.c | mmind/servo-chromiumos-ec | bb7b80033561023cd69cef86b00d2faa12fbc7d8 | [
"BSD-3-Clause"
] | 11 | 2017-02-17T15:29:22.000Z | 2017-06-25T06:05:57.000Z | /* Copyright (c) 2013 The Chromium OS Authors. All rights reserved.
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*
* Test interrupt support of EC emulator.
*/
#include <stdio.h>
#include "common.h"
#include "console.h"
#include "task.h"
#include "test_util.h"
#include "timer.h"
#include "util.h"
static int main_count;
static int has_error;
static int interrupt_count;
/* period between 50us and 3.2ms */
#define PERIOD_US(num) (((num % 64) + 1) * 50)
void my_isr(void)
{
int i = main_count;
udelay(3 * PERIOD_US(prng_no_seed()));
if (i != main_count || !in_interrupt_context())
has_error = 1;
interrupt_count++;
}
void interrupt_generator(void)
{
while (1) {
udelay(3 * PERIOD_US(prng_no_seed()));
task_trigger_test_interrupt(my_isr);
}
}
static int interrupt_test(void)
{
timestamp_t deadline = get_time();
deadline.val += SECOND / 2;
while (!timestamp_expired(deadline, NULL))
++main_count;
ccprintf("Interrupt count: %d\n", interrupt_count);
ccprintf("Main thread tick: %d\n", main_count);
TEST_ASSERT(!has_error);
TEST_ASSERT(!in_interrupt_context());
return EC_SUCCESS;
}
static int interrupt_disable_test(void)
{
timestamp_t deadline = get_time();
int start_int_cnt, end_int_cnt;
deadline.val += SECOND / 2;
interrupt_disable();
start_int_cnt = interrupt_count;
while (!timestamp_expired(deadline, NULL))
;
end_int_cnt = interrupt_count;
interrupt_enable();
TEST_ASSERT(start_int_cnt == end_int_cnt);
return EC_SUCCESS;
}
void run_test(void)
{
test_reset();
RUN_TEST(interrupt_test);
RUN_TEST(interrupt_disable_test);
test_print_result();
}
| 20.060241 | 73 | 0.723724 |
ae8d324ecc532cbdc3abcd165920d4d21f08676f | 7,743 | h | C | benchmarks/server_delegation/ffwd/ffwd.h | quanshousio/CompilerInterrupts | 67e72514a90c76c7106e4202001003b9ef359a5e | [
"MIT"
] | null | null | null | benchmarks/server_delegation/ffwd/ffwd.h | quanshousio/CompilerInterrupts | 67e72514a90c76c7106e4202001003b9ef359a5e | [
"MIT"
] | null | null | null | benchmarks/server_delegation/ffwd/ffwd.h | quanshousio/CompilerInterrupts | 67e72514a90c76c7106e4202001003b9ef359a5e | [
"MIT"
] | null | null | null | #ifndef _FFWD_H_
#define _FFWD_H_
#include <numa.h>
#include <pthread.h>
#include <stdarg.h>
#include <immintrin.h>
#include <x86intrin.h>
#include <locale.h>
#include "fiber_manager.h"
#include "fiber_barrier.h"
#ifdef DEBUG_YIELD
extern __thread int test;
#endif
extern __thread struct server_args* this_server;
extern __thread fiber_t* main_server_fiber;
extern volatile int num_of_req_lines_to_check;
extern volatile int num_of_hwth_to_check;
#ifdef PTHREAD
extern __thread int my_id;
int clients_count;
#endif
typedef struct locks{
int is_locked;
int waiters_count;
spsc_fifo_t *lock;
}serverlocks;
struct ffwd_context {
int id;
void *(* initfunc)(void*);
void *initvalue;
};
struct thread_attr{
uint64_t mask[REQS_LINES_PER_THREAD];
int is_locked[REQS_LINES_PER_THREAD * MAX_SERVERS];
int coreid_in_chip;
int chip_num;
int is_server;
struct request* request[MAX_SERVERS * REQS_LINES_PER_THREAD];
uint64_t server_last_request_time[MAX_SERVERS];
volatile struct server_response_group* server_response_group[MAX_SERVERS * REQS_LINES_PER_THREAD];
fiber_t* resp_waiting_fibers[REQS_LINES_PER_THREAD * MAX_SERVERS];
uint64_t local_client_flag[REQS_LINES_PER_THREAD * MAX_SERVERS];
struct server_response* core_resp[REQS_LINES_PER_THREAD * MAX_SERVERS];
}__attribute__((packed, aligned(128)));
extern struct thread_attr *thread_attrs[TOTAL_NUM_OF_THREADS+1];
// here should also check if there is a child fiber, if so no need to fork
#define FFWD_LOCK(the_lock) \
if ((the_lock.is_locked)){ \
fiber_t* child_fiber = server_fiber_fork(); \
if (child_fiber != 0) { \
/* parent should add the fiber to request_fibers and set the request_fibers' state to waiting*/ \
fiber_t* current_fiber = ((fiber_manager_t*)(this_server->manager))->current_fiber; \
current_fiber->request_state = FIBER_CHILD_WAITING; \
current_fiber->lock_ptr = (uint64_t)&the_lock; \
mpsc_fifo_node_t* const fiber_node = current_fiber->mpsc_fifo_node; \
current_fiber->mpsc_fifo_node = NULL; \
fiber_node->data = current_fiber; \
spsc_fifo_push((the_lock.lock), (spsc_node_t*)fiber_node); \
the_lock.waiters_count++; \
this_server->request_fibers[this_server->req_fiber_index] = current_fiber; \
main_server_fiber = child_fiber; \
/* parent stays here and the child will continue running server loop*/ \
switch_no_maintenance(); \
/* if it gets here, it means the lock was available*/ \
the_lock.is_locked = 1; \
((fiber_manager_t*)(this_server->manager))->current_fiber->lock_ptr = 0; \
} \
the_lock.waiters_count--; \
} \
the_lock.is_locked = 1;
#define FFWD_UNLOCK(the_lock) \
/*unlock and wake the next one waiting on the lock*/ \
if (the_lock.waiters_count > 0 ){ \
spsc_node_t* waiting_node = spsc_fifo_trypop((the_lock.lock));\
if (waiting_node){ \
fiber_t* next_to_wakeup = (fiber_t*)waiting_node->data; \
next_to_wakeup->mpsc_fifo_node = waiting_node; \
next_to_wakeup->request_state = FIBER_REQUEST_RESUMABLE; \
} \
} \
the_lock.is_locked = 0;
inline void push_and_wait_for_server_req_lock(fiber_manager_t* manager, fiber_t* fiber_to_push, int server_no){
fiber_scheduler_t* scheduler = manager->scheduler;
mpsc_fifo_node_t* const node = fiber_to_push->mpsc_fifo_node;
assert(node);
fiber_to_push->mpsc_fifo_node = 0;
node->data = fiber_to_push;
spsc_fifo_push(&(((fiber_scheduler_dist_t*)scheduler)->req_lock_queue[server_no]), (spsc_node_t*)node);
}
#define SERVER_FFWD_EXEC(server_num, function, ret, ...) \
/*if there is no request fiber created for this client, fork a request fiber, else use the existing one */ \
if(((fiber_manager_t*)(this_server->manager))->current_fiber == main_server_fiber){ \
fiber_t* child_fiber = server_fiber_fork(); \
/* parent's return value is a pointer to the child fiber, child's retrn value is null*/ \
if (child_fiber != 0) { \
fiber_t* current_fiber = ((fiber_manager_t*)(this_server->manager))->current_fiber; \
struct request* req = ¤t_fiber->my_request; \
req->fptr = function; \
prepare_request_argvs(req, __VA_ARGS__); \
current_fiber->request_state = FIBER_CHILD_WAITING; \
current_fiber->id_in_chip = this_server->current_id_in_chip; \
push_and_wait_for_server_req_lock(((fiber_manager_t*)(this_server->manager)), current_fiber, server_num); \
this_server->request_fibers[this_server->req_fiber_index] = current_fiber; \
this_server->any_server_fiber_waiting++; \
main_server_fiber = child_fiber; \
switch_no_maintenance(); \
} \
} \
else{ \
fiber_t* current_fiber = ((fiber_manager_t*)(this_server->manager))->current_fiber; \
struct request* req = ¤t_fiber->my_request; \
req->fptr = function; \
prepare_request_argvs(req, __VA_ARGS__); \
current_fiber->request_state = FIBER_CHILD_WAITING; \
current_fiber->id_in_chip = this_server->current_id_in_chip; \
push_and_wait_for_server_req_lock(((fiber_manager_t*)(this_server->manager)), current_fiber, server_num); \
this_server->request_fibers[this_server->req_fiber_index] = current_fiber; \
this_server->any_server_fiber_waiting++; \
this_server->still_need_to_wait = 1; \
switch_no_maintenance(); \
} \
ret = ((fiber_manager_t*)(this_server->manager))->current_fiber->response_retval; \
this_server->any_server_fiber_waiting--; \
/*change return address to be label 3*/ \
/*find the first rbp after call and change it*/
#define GET_ARGS(num_args, ...) __VA_ARGS__
#ifdef PTHREAD
#define FFWD_EXEC(server_num, function, ret, ...) \
{ \
struct thread_attr * my_thread = thread_attrs[my_id]; \
my_thread->request[server_num]->fptr = function; \
prepare_request_argvs(my_thread->request[server_num], __VA_ARGS__); \
my_thread->request[server_num]->flag ^= 1; \
uint64_t local_flag = my_thread->request[server_num]->flag;\
int mycoreid = my_thread->coreid_in_chip;\
int shift_base = (mycoreid * REQS_LINES_PER_THREAD)%64;\
while((( (my_thread->core_resp[server_num]->flag >> (shift_base + (server_num%REQS_LINES_PER_THREAD))) ^ (my_thread->request[server_num]->flag)) & ((uint64_t)1 ) )){ \
__asm__ __volatile__ ("rep:nop;" ::: "memory");\
}\
ret = my_thread->core_resp[server_num]->return_value;\
}
#else
// call FFWD_EXEC for both nested and non nested delegation
#define FFWD_EXEC(server_num, function, ret, ...) \
{ \
fiber_manager_t* manager = fiber_manager_get(); \
/* if a server is calling FFWD_EXEC and it is a nested call (server_num != manager->server_id), then call SERVER_FFWD_EXEC otherwise just call the function */ \
if (manager->is_server && server_num == manager->server_id){ \
if (server_num == manager->server_id){\
function(GET_ARGS(__VA_ARGS__)); \
}\
else{ \
SERVER_FFWD_EXEC(server_num, function, ret, __VA_ARGS__) \
} \
} \
else{ \
struct request* ffwd_req; \
fiber_t* const myself = manager->current_fiber; \
ffwd_req = &myself->my_request; \
ffwd_req->fptr = function; \
prepare_request_argvs(ffwd_req, __VA_ARGS__); \
fiber_push_and_wait_for_req_lock(server_num); \
ret = myself->response_retval;\
} \
}
#endif
extern inline void prepare_request_argvs(struct request* myrequest, int arg_count, ...);
void ffwd_init();
void launch_servers(int);
int launch_server_flat_delegation();
void ffwd_shutdown();
struct ffwd_context* ffwd_get_context();
fiber_t* ffwd_poll_resp(fiber_manager_t* manager, fiber_scheduler_t* sched);
fiber_t* ffwd_thread_create(void *(* func) (void *), void* value);
fiber_t* ffwd_thread_create_and_pin(void *(* func) (void *), void* value, int core_id);
void switch_no_maintenance();
void poll_server_resp(struct server_args* this_server, fiber_manager_t* manager, int shift_base);
#endif
| 38.909548 | 170 | 0.741444 |
ae8eed6523e664576b30ee19712f44e2e6ebcd45 | 2,558 | h | C | Kernel/API/POSIX/netinet/in.h | r00ster91/serenity | f8387dea2689d564aff612bfd4ec5086393fac35 | [
"BSD-2-Clause"
] | 7 | 2020-04-26T00:41:04.000Z | 2021-11-26T08:25:10.000Z | Kernel/API/POSIX/netinet/in.h | r00ster91/serenity | f8387dea2689d564aff612bfd4ec5086393fac35 | [
"BSD-2-Clause"
] | 1 | 2022-02-07T13:33:03.000Z | 2022-02-07T13:33:03.000Z | Kernel/API/POSIX/netinet/in.h | r00ster91/serenity | f8387dea2689d564aff612bfd4ec5086393fac35 | [
"BSD-2-Clause"
] | 1 | 2022-02-20T17:55:47.000Z | 2022-02-20T17:55:47.000Z | /*
* Copyright (c) 2018-2021, Andreas Kling <kling@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <Kernel/API/POSIX/sys/socket.h>
#include <Kernel/API/POSIX/sys/types.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef uint32_t in_addr_t;
#define INADDR_ANY ((in_addr_t)0)
#define INADDR_NONE ((in_addr_t)-1)
#define INADDR_LOOPBACK 0x7f000001
#define INADDR_BROADCAST 0xffffffff
#define IN_LOOPBACKNET 127
#define IP_TOS 1
#define IP_TTL 2
#define IP_MULTICAST_LOOP 3
#define IP_ADD_MEMBERSHIP 4
#define IP_DROP_MEMBERSHIP 5
#define IP_MULTICAST_IF 6
#define IP_MULTICAST_TTL 7
#define IP_BLOCK_SOURCE 8
#define IP_UNBLOCK_SOURCE 9
#define IP_OPTIONS 10
#define IPTOS_LOWDELAY 16
#define IPTOS_THROUGHPUT 8
#define IPTOS_RELIABILITY 4
/* Make sure these don't overlap with any other IPv4 and IPv6 options */
#define MCAST_JOIN_SOURCE_GROUP 100
#define MCAST_LEAVE_SOURCE_GROUP 101
#define IPPORT_RESERVED 1024
#define IPPORT_USERRESERVED 5000
typedef uint16_t in_port_t;
struct in_addr {
uint32_t s_addr;
};
struct sockaddr_in {
sa_family_t sin_family;
in_port_t sin_port;
struct in_addr sin_addr;
char sin_zero[8];
};
struct ip_mreq {
struct in_addr imr_multiaddr;
struct in_addr imr_interface;
};
struct group_source_req {
uint32_t gsr_interface;
struct sockaddr_storage gsr_group;
struct sockaddr_storage gsr_source;
};
struct ip_mreq_source {
struct in_addr imr_multiaddr;
struct in_addr imr_sourceaddr;
struct in_addr imr_interface;
};
#define IPV6_UNICAST_HOPS 1
#define IPV6_MULTICAST_HOPS 2
#define IPV6_MULTICAST_LOOP 3
#define IPV6_MULTICAST_IF 4
#define IPV6_ADD_MEMBERSHIP 5
#define IPV6_DROP_MEMBERSHIP 6
#define IP_ADD_SOURCE_MEMBERSHIP 7
#define IP_DROP_SOURCE_MEMBERSHIP 8
#define IPV6_V6ONLY 9
#define IPV6_JOIN_GROUP 5
#define IPV6_LEAVE_GROUP 6
struct in6_addr {
uint8_t s6_addr[16];
};
#define IN6ADDR_ANY_INIT \
{ \
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 \
}
extern struct in6_addr in6addr_any;
struct sockaddr_in6 {
sa_family_t sin6_family; // AF_INET6.
in_port_t sin6_port; // Port number.
uint32_t sin6_flowinfo; // IPv6 traffic class and flow information.
struct in6_addr sin6_addr; // IPv6 address.
uint32_t sin6_scope_id; // Set of interfaces for a scop
};
struct ipv6_mreq {
struct in6_addr ipv6mr_multiaddr;
uint32_t ipv6mr_interface;
};
#ifdef __cplusplus
}
#endif
| 22.051724 | 74 | 0.734167 |
ae917c421d36380737bc70d45a1c7f48ca4a34b4 | 551 | h | C | my_computer/10/src/unit_tests/mock_reader.h | kippesp/Nand2Tetris | b43d60f9267286eae5570244aaa76c34bda28c0e | [
"MIT"
] | null | null | null | my_computer/10/src/unit_tests/mock_reader.h | kippesp/Nand2Tetris | b43d60f9267286eae5570244aaa76c34bda28c0e | [
"MIT"
] | null | null | null | my_computer/10/src/unit_tests/mock_reader.h | kippesp/Nand2Tetris | b43d60f9267286eae5570244aaa76c34bda28c0e | [
"MIT"
] | null | null | null | #pragma once
#include "tokenizer/reader.h"
namespace test {
class MockReader : public Reader {
public:
using Reader::char_type;
char buffer[512] = {0};
MockReader() = default;
virtual ~MockReader() = default;
virtual char_type peek() override { return buffer[index]; }
virtual char_type read() override { return buffer[index++]; }
virtual void savepos() override { saved_index = index; }
virtual void restorepos() override { index = saved_index; }
private:
size_t index{0};
size_t saved_index{0};
};
} // namespace test
| 19 | 63 | 0.69147 |
ae91acf28620a61471b7aac2e4d9f1ba5f061d9c | 2,768 | h | C | Library/include/mavros_msgs/WaypointPush.h | Dieptranivsr/Ros_Diep | d790e75e6f5da916701b11a2fdf3e03b6a47086b | [
"MIT"
] | 10 | 2021-03-15T03:58:06.000Z | 2021-12-30T15:33:38.000Z | devel/.private/mavros_msgs/include/mavros_msgs/WaypointPush.h | arijitnoobstar/UAVProjectileCatcher | 3c1bed80df167192cb4b971b58c891187628142e | [
"Apache-2.0"
] | 1 | 2021-09-09T15:29:31.000Z | 2021-09-09T15:29:31.000Z | melodic/include/mavros_msgs/WaypointPush.h | Dieptranivsr/Ros_Diep | d790e75e6f5da916701b11a2fdf3e03b6a47086b | [
"MIT"
] | 4 | 2021-03-06T09:35:58.000Z | 2021-05-24T14:34:11.000Z | // Generated by gencpp from file mavros_msgs/WaypointPush.msg
// DO NOT EDIT!
#ifndef MAVROS_MSGS_MESSAGE_WAYPOINTPUSH_H
#define MAVROS_MSGS_MESSAGE_WAYPOINTPUSH_H
#include <ros/service_traits.h>
#include <mavros_msgs/WaypointPushRequest.h>
#include <mavros_msgs/WaypointPushResponse.h>
namespace mavros_msgs
{
struct WaypointPush
{
typedef WaypointPushRequest Request;
typedef WaypointPushResponse Response;
Request request;
Response response;
typedef Request RequestType;
typedef Response ResponseType;
}; // struct WaypointPush
} // namespace mavros_msgs
namespace ros
{
namespace service_traits
{
template<>
struct MD5Sum< ::mavros_msgs::WaypointPush > {
static const char* value()
{
return "5b2bca74e830798e1579b58cafd50527";
}
static const char* value(const ::mavros_msgs::WaypointPush&) { return value(); }
};
template<>
struct DataType< ::mavros_msgs::WaypointPush > {
static const char* value()
{
return "mavros_msgs/WaypointPush";
}
static const char* value(const ::mavros_msgs::WaypointPush&) { return value(); }
};
// service_traits::MD5Sum< ::mavros_msgs::WaypointPushRequest> should match
// service_traits::MD5Sum< ::mavros_msgs::WaypointPush >
template<>
struct MD5Sum< ::mavros_msgs::WaypointPushRequest>
{
static const char* value()
{
return MD5Sum< ::mavros_msgs::WaypointPush >::value();
}
static const char* value(const ::mavros_msgs::WaypointPushRequest&)
{
return value();
}
};
// service_traits::DataType< ::mavros_msgs::WaypointPushRequest> should match
// service_traits::DataType< ::mavros_msgs::WaypointPush >
template<>
struct DataType< ::mavros_msgs::WaypointPushRequest>
{
static const char* value()
{
return DataType< ::mavros_msgs::WaypointPush >::value();
}
static const char* value(const ::mavros_msgs::WaypointPushRequest&)
{
return value();
}
};
// service_traits::MD5Sum< ::mavros_msgs::WaypointPushResponse> should match
// service_traits::MD5Sum< ::mavros_msgs::WaypointPush >
template<>
struct MD5Sum< ::mavros_msgs::WaypointPushResponse>
{
static const char* value()
{
return MD5Sum< ::mavros_msgs::WaypointPush >::value();
}
static const char* value(const ::mavros_msgs::WaypointPushResponse&)
{
return value();
}
};
// service_traits::DataType< ::mavros_msgs::WaypointPushResponse> should match
// service_traits::DataType< ::mavros_msgs::WaypointPush >
template<>
struct DataType< ::mavros_msgs::WaypointPushResponse>
{
static const char* value()
{
return DataType< ::mavros_msgs::WaypointPush >::value();
}
static const char* value(const ::mavros_msgs::WaypointPushResponse&)
{
return value();
}
};
} // namespace service_traits
} // namespace ros
#endif // MAVROS_MSGS_MESSAGE_WAYPOINTPUSH_H
| 22.322581 | 82 | 0.734104 |
ae932a17f387518f2f76f5059c06c9031281778c | 3,377 | h | C | inc/osvr/PluginKit/LocomotionInterfaceC.h | ethanpeng/OSVR-Core | 59405fc1b1a25aea051dfbba0be5171fa19b8b30 | [
"Apache-2.0"
] | 369 | 2015-03-08T03:12:41.000Z | 2022-02-08T22:15:39.000Z | inc/osvr/PluginKit/LocomotionInterfaceC.h | ethanpeng/OSVR-Core | 59405fc1b1a25aea051dfbba0be5171fa19b8b30 | [
"Apache-2.0"
] | 486 | 2015-03-09T13:29:00.000Z | 2020-10-16T00:41:26.000Z | inc/osvr/PluginKit/LocomotionInterfaceC.h | ethanpeng/OSVR-Core | 59405fc1b1a25aea051dfbba0be5171fa19b8b30 | [
"Apache-2.0"
] | 166 | 2015-03-08T12:03:56.000Z | 2021-12-03T13:56:21.000Z | /** @file
@brief Header
@date 2015
@author
Sensics, Inc.
<http://sensics.com/osvr>
*/
// Copyright 2015 Sensics, 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.
#ifndef INCLUDED_LocomotionInterfaceC_h_GUID_2458F99D_C36A_4F92_93A4_ABFD224F74AB
#define INCLUDED_LocomotionInterfaceC_h_GUID_2458F99D_C36A_4F92_93A4_ABFD224F74AB
/* Internal Includes */
#include <osvr/PluginKit/DeviceInterfaceC.h>
#include <osvr/Util/ChannelCountC.h>
#include <osvr/Util/ClientReportTypesC.h>
/* Library/third-party includes */
/* none */
/* Standard includes */
/* none */
OSVR_EXTERN_C_BEGIN
/** @defgroup PluginKitCLocomotion Locomotion interface (base C API)
@brief Sending locomotion reports from a device in your plugin.
@ingroup PluginKit
@{
*/
/** @brief Opaque type used in conjunction with a device token to send data on
Locomotion Interface
*/
typedef struct OSVR_LocomotionDeviceInterfaceObject
*OSVR_LocomotionDeviceInterface;
/** @brief Specify that your device will implement the Locomotion interface.
@param opts The device init options object.
@param [out] iface An interface object you should retain with the same
lifetime as the device token in order to send messages conforming to an
Locomotion interface.
@param numSensors The number of sensors you will be reporting Locomotion
data :
You can report for 1 sensor per device.
*/
OSVR_PLUGINKIT_EXPORT
OSVR_ReturnCode osvrDeviceLocomotionConfigure(
OSVR_INOUT_PTR OSVR_DeviceInitOptions opts,
OSVR_OUT_PTR OSVR_LocomotionDeviceInterface *iface)
OSVR_FUNC_NONNULL((1, 2));
/** @brief Report velocity data for a specific sensor.
@param dev Device token
@param iface Locomotion Interface
@param naviVelocity navigation velocity
@param sensor Sensor number
@param timestamp Timestamp correlating to navigation velocity
*/
OSVR_PLUGINKIT_EXPORT
OSVR_ReturnCode osvrDeviceLocomotionReportNaviVelocity(
OSVR_IN_PTR OSVR_LocomotionDeviceInterface iface,
OSVR_IN OSVR_NaviVelocityState naviVelocity,
OSVR_IN OSVR_ChannelCount sensor,
OSVR_IN_PTR OSVR_TimeValue const *timestamp) OSVR_FUNC_NONNULL((1, 4));
/** @brief Report position data for a specific sensor.
@param dev Device token
@param iface Locomotion Interface
@param naviPosition navigation position
@param sensor Sensor number
@param timestamp Timestamp correlating to navigation position
*/
OSVR_PLUGINKIT_EXPORT
OSVR_ReturnCode osvrDeviceLocomotionReportNaviPosition(
OSVR_IN_PTR OSVR_LocomotionDeviceInterface iface,
OSVR_IN OSVR_NaviPositionState naviPosition,
OSVR_IN OSVR_ChannelCount sensor,
OSVR_IN_PTR OSVR_TimeValue const *timestamp) OSVR_FUNC_NONNULL((1, 4));
/**@} */ /* end of group */
OSVR_EXTERN_C_END
#endif // INCLUDED_LocomotionInterfaceC_h_GUID_2458F99D_C36A_4F92_93A4_ABFD224F74AB
| 32.786408 | 83 | 0.776133 |
ae952258ac090ed6202c6c1ecd39aced573fa851 | 281 | h | C | VChat/Register/RegisterViaPhoneViewController.h | Re-cover/VChat | ce0afd2c852dcc1809b6e023f58a316e02d5d628 | [
"MIT"
] | null | null | null | VChat/Register/RegisterViaPhoneViewController.h | Re-cover/VChat | ce0afd2c852dcc1809b6e023f58a316e02d5d628 | [
"MIT"
] | null | null | null | VChat/Register/RegisterViaPhoneViewController.h | Re-cover/VChat | ce0afd2c852dcc1809b6e023f58a316e02d5d628 | [
"MIT"
] | null | null | null | //
// RegisterViaPhoneViewController.h
// VChat
//
// Created by Recover on 16/5/1.
// Copyright © 2016年 Recover. All rights reserved.
//
#import <UIKit/UIKit.h>
#import "AccountService.h"
@interface RegisterViaPhoneViewController : UIViewController<VerifySMSDelegate>
@end
| 18.733333 | 79 | 0.743772 |
ae9554f89e1be782c4cb7ed0362ccf1064c63860 | 173,814 | h | C | uboot/arch/blackfin/include/asm/bfin_logo_230x230_lzma.h | bingchunjin/1806_SDK | d5ed0258fc22f60e00ec025b802d175f33da6e41 | [
"MIT"
] | 35 | 2019-04-26T04:00:10.000Z | 2022-03-30T11:37:06.000Z | uboot/arch/blackfin/include/asm/bfin_logo_230x230_lzma.h | bingchunjin/1806_SDK | d5ed0258fc22f60e00ec025b802d175f33da6e41 | [
"MIT"
] | 4 | 2016-08-30T11:30:25.000Z | 2020-12-27T09:58:07.000Z | uboot/arch/blackfin/include/asm/bfin_logo_230x230_lzma.h | bingchunjin/1806_SDK | d5ed0258fc22f60e00ec025b802d175f33da6e41 | [
"MIT"
] | 30 | 2018-05-02T08:43:27.000Z | 2022-01-23T03:25:54.000Z | /*
* Generated by EasyLogo, (C) 2000 by Paolo Scaffardi
*
* To use this, include it and call: easylogo_plot(screen,&bfin_logo, width,x,y)
*
* Where: 'screen' is the pointer to the frame buffer
* 'width' is the screen width
* 'x' is the horizontal position
* 'y' is the vertical position
*/
#define EASYLOGO_ENABLE_LZMA 28532
static unsigned char EASYLOGO_DECOMP_BUFFER[158700];
#include <video_easylogo.h>
#define DEF_BFIN_LOGO_WIDTH 230
#define DEF_BFIN_LOGO_HEIGHT 230
#define DEF_BFIN_LOGO_PIXELS 52900
#define DEF_BFIN_LOGO_BPP 24
#define DEF_BFIN_LOGO_PIXEL_SIZE 3
#define DEF_BFIN_LOGO_SIZE 158700
unsigned char DEF_BFIN_LOGO_DATA[] = {
0x5d, 0x00, 0x00, 0x80, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x6f,
0xfd, 0xf8, 0xb8, 0x51, 0x47, 0x76, 0x83, 0x1a, 0x36, 0xff, 0xdf, 0x25, 0x3b, 0x9e, 0x1e, 0xfc,
0x17, 0x17, 0x7c, 0x3f, 0x4c, 0x3f, 0x42, 0x00, 0x19, 0xe1, 0x7c, 0x13, 0xce, 0xa1, 0xb5, 0xdf,
0x06, 0x70, 0x2e, 0xb6, 0x6c, 0xe0, 0xcb, 0x11, 0xf6, 0x92, 0x94, 0x8a, 0x99, 0x3e, 0x21, 0xb2,
0x27, 0xe8, 0x4c, 0x5d, 0x4c, 0x45, 0x6d, 0xfa, 0x0d, 0x07, 0x51, 0x9c, 0xc1, 0xf2, 0x53, 0x6d,
0x9e, 0x57, 0xb5, 0x3a, 0x93, 0x8c, 0x7e, 0x3d, 0x18, 0x78, 0x1a, 0x13, 0x72, 0x7a, 0xa6, 0x0f,
0x90, 0x31, 0x39, 0xfe, 0xe1, 0x4c, 0x12, 0xda, 0x4f, 0xe8, 0xe7, 0x3f, 0x68, 0xe5, 0xc3, 0x2e,
0x8c, 0xeb, 0x62, 0x9a, 0x99, 0x26, 0xf6, 0x64, 0x2e, 0x15, 0x1f, 0xd6, 0xa2, 0xbd, 0xe9, 0xa2,
0x87, 0x70, 0xd8, 0x35, 0x60, 0x6d, 0x05, 0x11, 0x97, 0x62, 0x11, 0x11, 0x31, 0x08, 0xb8, 0xe5,
0xe1, 0x76, 0x47, 0x2d, 0x42, 0x5d, 0x06, 0xa1, 0x5c, 0x30, 0xf0, 0x11, 0x9d, 0xf7, 0x13, 0x4d,
0xbd, 0x5f, 0x8f, 0x2b, 0xb2, 0x2e, 0x47, 0x7e, 0x21, 0x1e, 0xce, 0x05, 0x29, 0x0d, 0x38, 0xcb,
0x05, 0xc9, 0x55, 0xde, 0xc9, 0x66, 0xb3, 0xf9, 0x0b, 0xbb, 0x76, 0x6b, 0x36, 0x81, 0x16, 0x59,
0xce, 0xbf, 0x02, 0x66, 0x52, 0xa1, 0x75, 0xff, 0xb0, 0xb7, 0x8e, 0x5b, 0x56, 0xaf, 0xdc, 0x62,
0x7a, 0xc5, 0xf0, 0xa8, 0xc3, 0xf8, 0xf5, 0x32, 0xef, 0xd7, 0x65, 0xdf, 0x2b, 0x64, 0x9d, 0x1b,
0x99, 0x63, 0x0d, 0x11, 0xb2, 0xc8, 0x4a, 0xf6, 0x27, 0xb7, 0xa1, 0xfb, 0x25, 0x7a, 0xfd, 0x69,
0x01, 0xfa, 0xc8, 0x2b, 0xe8, 0x44, 0x83, 0x66, 0x72, 0xb6, 0xa9, 0x8a, 0xb2, 0x2a, 0x6f, 0xfe,
0xe8, 0xca, 0x85, 0x21, 0x83, 0x77, 0x08, 0x03, 0xc2, 0xd5, 0xd0, 0x68, 0xc4, 0xb3, 0xca, 0x54,
0x9b, 0xa9, 0x2b, 0x3e, 0x59, 0xf7, 0x99, 0xa6, 0xed, 0x02, 0xb3, 0x37, 0x4f, 0x2c, 0x2f, 0x79,
0x09, 0x6e, 0x68, 0x64, 0xe4, 0xee, 0x3e, 0x25, 0x59, 0x6c, 0x19, 0xfa, 0x8e, 0x03, 0xb1, 0x1a,
0x47, 0xc6, 0x7f, 0xea, 0xe9, 0x6a, 0x5b, 0xff, 0x94, 0x8d, 0x93, 0xfd, 0x7e, 0x45, 0x39, 0x81,
0xe5, 0xbe, 0xe0, 0xa1, 0x9f, 0x08, 0xd6, 0x71, 0x5f, 0xd9, 0xa8, 0x99, 0x3b, 0xae, 0x4e, 0x03,
0xc9, 0x2c, 0x86, 0x61, 0xae, 0xe4, 0x33, 0x72, 0xed, 0xac, 0x53, 0x49, 0x7e, 0xb2, 0xc1, 0xab,
0xad, 0x71, 0x70, 0xff, 0x22, 0xff, 0xe6, 0x4f, 0x55, 0x3c, 0xf8, 0xb2, 0xc5, 0x55, 0x2a, 0x7e,
0x0f, 0x34, 0x9f, 0x64, 0x54, 0x2c, 0x91, 0x9e, 0xeb, 0x31, 0xa7, 0x83, 0x5f, 0x69, 0x97, 0xee,
0xc5, 0x24, 0x62, 0x3a, 0xa3, 0x69, 0x47, 0x06, 0x59, 0x56, 0x60, 0x5f, 0x74, 0xb3, 0x8f, 0x4f,
0xf5, 0x8e, 0xbe, 0xaa, 0x9d, 0xba, 0x6c, 0x27, 0xf7, 0x0b, 0x7b, 0xd6, 0x94, 0x73, 0x34, 0xc5,
0xa5, 0x3c, 0xbf, 0x4a, 0xde, 0x3f, 0x04, 0x74, 0x67, 0xeb, 0xc9, 0x9f, 0x93, 0x0e, 0xa0, 0xed,
0x1c, 0x17, 0x23, 0xb6, 0xac, 0x37, 0x41, 0xdc, 0x24, 0xc4, 0x10, 0xab, 0x0a, 0x14, 0x2c, 0xe8,
0x00, 0x34, 0x71, 0xe5, 0x21, 0x22, 0x84, 0x4b, 0x26, 0xf5, 0x59, 0x87, 0x39, 0xda, 0x59, 0x9d,
0xbb, 0x22, 0x63, 0x1b, 0x34, 0xfe, 0xb8, 0xba, 0xdf, 0x3c, 0x58, 0x68, 0xa1, 0x73, 0xab, 0x68,
0x3f, 0xba, 0xad, 0x30, 0x0d, 0x35, 0x75, 0xca, 0xa7, 0x54, 0xda, 0x8e, 0xdf, 0x43, 0x98, 0xc7,
0x72, 0xa3, 0x3b, 0x96, 0x93, 0x5d, 0x86, 0x1f, 0xa7, 0xe0, 0x97, 0x2c, 0xc7, 0x59, 0x30, 0x88,
0xec, 0xc2, 0x89, 0x56, 0x1d, 0xda, 0x76, 0xed, 0xf3, 0x53, 0xd5, 0x38, 0x63, 0x70, 0x36, 0x5d,
0x89, 0xb1, 0xa9, 0x1f, 0x99, 0x2d, 0x95, 0x89, 0xf3, 0x3f, 0xa7, 0x1a, 0x6b, 0x6a, 0xda, 0xb8,
0xba, 0x62, 0x87, 0x28, 0xac, 0x21, 0x7b, 0x47, 0xc2, 0x17, 0xb1, 0x1c, 0x97, 0x63, 0xf6, 0x43,
0xb2, 0x62, 0x28, 0x26, 0x0e, 0x76, 0x8c, 0x48, 0x92, 0x1a, 0xde, 0xa7, 0x54, 0xb7, 0xba, 0x4b,
0x87, 0xf1, 0xdf, 0xae, 0x4d, 0x72, 0xd4, 0x5d, 0x55, 0x60, 0x39, 0x04, 0x2c, 0xe6, 0x61, 0x09,
0x04, 0x74, 0xf9, 0x64, 0x40, 0x52, 0x40, 0xca, 0x04, 0xbb, 0xec, 0x1f, 0xe0, 0x65, 0x21, 0x6f,
0x11, 0x69, 0xe5, 0xca, 0xc1, 0xce, 0x70, 0xe0, 0x56, 0x2e, 0x40, 0x38, 0xeb, 0x74, 0x1b, 0x2e,
0xef, 0x4f, 0x2b, 0x6b, 0x9b, 0xa9, 0xbe, 0xa1, 0x83, 0x7e, 0x6c, 0x08, 0x1f, 0xc9, 0x2e, 0xf9,
0xc7, 0x41, 0xc5, 0xa4, 0xe4, 0x76, 0x0d, 0xca, 0x44, 0x23, 0x4f, 0x60, 0xb5, 0x11, 0x2d, 0xa0,
0x6d, 0x28, 0xf2, 0xc5, 0x46, 0x52, 0xe9, 0xfd, 0xa9, 0x9a, 0xf8, 0x5b, 0x9d, 0x60, 0x06, 0x0c,
0x25, 0x6c, 0xb6, 0x61, 0x86, 0x56, 0xf5, 0x07, 0x8d, 0xaa, 0xd7, 0x88, 0x9d, 0xc4, 0x40, 0x4a,
0x53, 0xd5, 0xe6, 0x3d, 0x06, 0xae, 0x77, 0xf4, 0x27, 0xa5, 0x65, 0x74, 0x98, 0xc7, 0xfe, 0x79,
0xca, 0x55, 0xce, 0x49, 0x26, 0x72, 0xd3, 0x54, 0xa9, 0x12, 0xac, 0xa0, 0xf1, 0xe6, 0x73, 0x17,
0xc2, 0xfa, 0x9b, 0x0f, 0x0c, 0xcc, 0x92, 0x0a, 0x53, 0x56, 0x4d, 0x8f, 0x58, 0x2d, 0xcb, 0xc0,
0x8c, 0xf9, 0x65, 0x24, 0xa4, 0xf0, 0xd4, 0x37, 0xa4, 0x3f, 0xd7, 0x46, 0xe7, 0x16, 0xcc, 0xf1,
0x52, 0x3f, 0xf8, 0xa0, 0x7a, 0xb3, 0x21, 0x39, 0x31, 0xfa, 0x6c, 0x23, 0xb2, 0xf8, 0x81, 0xf1,
0xc5, 0x53, 0xa5, 0x06, 0xaf, 0x01, 0x10, 0x7e, 0x80, 0xed, 0xe6, 0x04, 0xac, 0x32, 0x28, 0xb2,
0xaa, 0x9b, 0x8e, 0x58, 0xfa, 0x54, 0x43, 0xeb, 0x6c, 0x6e, 0xf9, 0x6d, 0x9a, 0x6b, 0x8c, 0xb1,
0x98, 0x6d, 0xf4, 0xd9, 0xd0, 0x0c, 0xba, 0x29, 0x01, 0x06, 0x7c, 0x8c, 0xb6, 0x55, 0xe1, 0x06,
0xa1, 0xed, 0x96, 0x13, 0x53, 0x33, 0x9e, 0x2a, 0xb3, 0x91, 0xc4, 0xbd, 0x1a, 0x86, 0xea, 0xaf,
0xa3, 0xb4, 0xf2, 0xa2, 0xc3, 0xe4, 0x09, 0x70, 0xe1, 0x2d, 0xd1, 0xf2, 0xf1, 0x32, 0xbd, 0x97,
0x7f, 0xfd, 0x80, 0x33, 0xa5, 0x5c, 0xf4, 0xf0, 0xba, 0x25, 0xb2, 0x6a, 0x7f, 0xe7, 0x1f, 0x22,
0x42, 0xa9, 0x0e, 0xa5, 0x1f, 0x12, 0x11, 0xe9, 0xa2, 0x1e, 0x53, 0x82, 0x64, 0x1b, 0x06, 0x3e,
0x69, 0x00, 0xb3, 0x7b, 0x82, 0xfa, 0x53, 0xc2, 0xab, 0x2c, 0xb0, 0x56, 0xda, 0xe9, 0x64, 0x25,
0x08, 0x8e, 0x85, 0x48, 0xd4, 0xd7, 0x7e, 0x0f, 0xa6, 0x59, 0xf3, 0xdf, 0x0f, 0x95, 0x88, 0x3f,
0x4f, 0xbd, 0xa6, 0x0e, 0x87, 0x53, 0xd0, 0x8c, 0x4f, 0x92, 0xe7, 0x80, 0xaf, 0x1e, 0x89, 0x83,
0x6c, 0x69, 0x5c, 0xe7, 0xc6, 0x19, 0x12, 0x31, 0xe8, 0x3a, 0x2c, 0x55, 0x9b, 0x40, 0xaf, 0xb3,
0xaf, 0x47, 0xcb, 0x1a, 0x66, 0x60, 0x79, 0x4c, 0x1b, 0x93, 0xbd, 0xf9, 0x03, 0x75, 0xce, 0xa1,
0xc1, 0x0c, 0x52, 0xd5, 0x82, 0x9f, 0xb3, 0x5c, 0xaf, 0x4c, 0x15, 0xef, 0x38, 0x00, 0xdc, 0x4b,
0x1d, 0x93, 0x7c, 0xc1, 0xa0, 0xe9, 0x0a, 0x2f, 0xa6, 0xf1, 0x0f, 0x3a, 0xfb, 0xe3, 0x31, 0xf8,
0x7d, 0x79, 0x83, 0xde, 0x23, 0x14, 0xfc, 0x74, 0x28, 0x7d, 0xad, 0x02, 0x53, 0x37, 0x50, 0x63,
0xc5, 0xa9, 0x80, 0x4c, 0x26, 0xf8, 0x30, 0xa7, 0xa5, 0x0d, 0xcf, 0x91, 0xd5, 0x7b, 0x82, 0x1e,
0xcd, 0x8c, 0x49, 0xde, 0x02, 0x9c, 0x95, 0x8f, 0xd0, 0x5b, 0x80, 0xaf, 0xd9, 0xc6, 0x62, 0x70,
0x1e, 0x41, 0x19, 0xe5, 0x36, 0xce, 0x06, 0x34, 0xc5, 0xe6, 0x16, 0x4b, 0x42, 0xfa, 0xca, 0x73,
0xdc, 0x1c, 0x74, 0xd5, 0x23, 0xcc, 0xde, 0x96, 0x57, 0x88, 0x8f, 0x12, 0x47, 0x24, 0xa3, 0x4e,
0x50, 0x17, 0xb0, 0x31, 0xe2, 0x89, 0x68, 0xd0, 0x29, 0xb4, 0x25, 0x01, 0xf7, 0x9d, 0x1b, 0xa1,
0x0d, 0xcf, 0xa3, 0x46, 0x83, 0xd0, 0x41, 0x00, 0x84, 0xd3, 0x6a, 0xe6, 0xd4, 0xff, 0x0a, 0x88,
0x9e, 0x4a, 0xd5, 0x57, 0xa0, 0x86, 0xe3, 0x35, 0x75, 0x95, 0x2a, 0x35, 0xaf, 0x93, 0x8c, 0x63,
0x14, 0x40, 0xc5, 0xe9, 0x74, 0xe7, 0xf6, 0x55, 0x38, 0xe1, 0x26, 0xb1, 0xc9, 0x03, 0x97, 0x5b,
0x23, 0xd5, 0xe8, 0x7b, 0xfe, 0xe5, 0xdd, 0x4d, 0x1b, 0x1a, 0x37, 0xb6, 0x12, 0x3a, 0xb4, 0x74,
0x9c, 0x08, 0xc1, 0x76, 0x77, 0xb7, 0x2f, 0xd7, 0xa7, 0x48, 0x1d, 0xa2, 0x3d, 0x68, 0x6b, 0x5d,
0xf1, 0xba, 0x82, 0x50, 0xe4, 0x80, 0x63, 0xdd, 0x47, 0xe8, 0xdf, 0x19, 0xb7, 0x26, 0x9b, 0x1a,
0xdf, 0x6a, 0x81, 0x3f, 0x0d, 0xe1, 0xa7, 0x9f, 0x7e, 0x1c, 0x5e, 0xbb, 0xe7, 0x9d, 0xff, 0x9d,
0x66, 0x82, 0xaf, 0x12, 0x49, 0xb2, 0xaa, 0xdb, 0xd1, 0x82, 0xe2, 0x22, 0xcb, 0xbc, 0xbf, 0x3f,
0xd2, 0xa7, 0x5f, 0xb7, 0x0e, 0x57, 0x5a, 0x24, 0xb2, 0xe8, 0x8c, 0x0f, 0x7f, 0xd6, 0x70, 0x50,
0x2c, 0x40, 0x5a, 0x8d, 0x97, 0x01, 0xe7, 0x21, 0x1c, 0xab, 0xa7, 0x55, 0x3e, 0x4e, 0xe2, 0x70,
0xf9, 0xb4, 0x69, 0x5b, 0xe1, 0x64, 0x12, 0xd3, 0x23, 0x26, 0x78, 0x2c, 0x60, 0xb4, 0xb1, 0xba,
0x1a, 0xff, 0x59, 0x26, 0x7a, 0x54, 0xa8, 0x8f, 0x4b, 0x2c, 0x6d, 0xe4, 0xeb, 0xb2, 0x12, 0xc6,
0x3d, 0x7b, 0xa8, 0x6d, 0x70, 0xd3, 0xcf, 0x73, 0x38, 0xf4, 0xab, 0x50, 0x1d, 0x49, 0xe0, 0xb0,
0x85, 0xd1, 0x9a, 0x8e, 0x14, 0x3e, 0x0c, 0x2b, 0x26, 0x61, 0x50, 0x48, 0x3d, 0xbe, 0xae, 0x53,
0xd8, 0xc1, 0x49, 0xe3, 0x58, 0x06, 0x9c, 0xd0, 0xdc, 0x4e, 0xc7, 0x8e, 0x43, 0xd1, 0x76, 0x0b,
0x27, 0xbe, 0x89, 0x96, 0x46, 0xdc, 0x66, 0x2f, 0x6c, 0xbf, 0xd9, 0x08, 0xf9, 0x04, 0xf8, 0x7e,
0x6b, 0x63, 0xb5, 0x2c, 0x4d, 0x4c, 0x91, 0x89, 0x62, 0xb2, 0x2e, 0x85, 0x95, 0x52, 0x38, 0x1a,
0xea, 0xac, 0x50, 0x2a, 0x33, 0x03, 0xe4, 0x0b, 0x78, 0x97, 0xaa, 0x35, 0xf5, 0x04, 0x6e, 0xf4,
0x5b, 0xf8, 0xb6, 0x1b, 0x3b, 0xf3, 0xf6, 0x99, 0xf5, 0x31, 0xf2, 0x96, 0xe4, 0x26, 0x7b, 0x00,
0x3a, 0x08, 0x7a, 0x94, 0xeb, 0xce, 0x61, 0xd4, 0x3b, 0x93, 0x4f, 0x86, 0x84, 0xaf, 0xee, 0x23,
0x8a, 0x8d, 0x7d, 0xab, 0x2d, 0xc0, 0xc6, 0x8d, 0x27, 0x0b, 0x80, 0x96, 0xb0, 0x6e, 0x86, 0xa7,
0xf1, 0xbc, 0x48, 0x3e, 0x74, 0x25, 0x8c, 0x5b, 0x74, 0xa1, 0xc4, 0xeb, 0xab, 0x09, 0xb8, 0xd2,
0x15, 0xa0, 0x7f, 0x20, 0x91, 0x6b, 0x09, 0xda, 0xbc, 0x98, 0x06, 0xec, 0xea, 0xdd, 0xae, 0xcd,
0xe8, 0xb6, 0x85, 0x26, 0x61, 0xb9, 0xa5, 0xc5, 0x4e, 0xae, 0xfc, 0x0f, 0x2b, 0x9c, 0x42, 0xc6,
0x8b, 0x28, 0x60, 0x04, 0x7d, 0x67, 0x23, 0x6a, 0xfd, 0xa3, 0x60, 0x19, 0x97, 0x50, 0x04, 0xd1,
0xb1, 0x7b, 0x6a, 0xa7, 0x0a, 0x44, 0x61, 0xfe, 0xeb, 0xe6, 0xcf, 0x42, 0x7c, 0x3b, 0x82, 0xcc,
0x41, 0x52, 0x82, 0xe0, 0xbd, 0xa2, 0x05, 0xf3, 0x98, 0xd3, 0xdc, 0x95, 0x6c, 0x59, 0x4b, 0x31,
0xdc, 0x5e, 0x1e, 0x4e, 0x3d, 0x18, 0x95, 0xe6, 0xc3, 0xcd, 0xa9, 0x9e, 0xf4, 0xfe, 0xf0, 0x85,
0xf8, 0xb1, 0xd0, 0x2f, 0x7d, 0x9c, 0xb5, 0x83, 0xde, 0xd7, 0x80, 0x0a, 0x56, 0xcd, 0xe8, 0x5b,
0xbd, 0xdc, 0x60, 0xce, 0x26, 0xf7, 0xc9, 0x11, 0xd7, 0x2a, 0x69, 0xf0, 0xa3, 0x62, 0x83, 0x2c,
0xe8, 0x9a, 0xec, 0x43, 0x91, 0x12, 0x2b, 0x2a, 0x41, 0x50, 0x67, 0x02, 0x30, 0xc0, 0x4d, 0xb4,
0xc8, 0x6c, 0x40, 0x25, 0x55, 0xf1, 0x67, 0x7a, 0x11, 0x05, 0x3b, 0x9f, 0x55, 0xce, 0xec, 0x69,
0x13, 0x68, 0x1a, 0x8c, 0x7d, 0xba, 0x3f, 0x98, 0x4a, 0xf7, 0x9a, 0x44, 0x31, 0x2a, 0x3d, 0x3b,
0xe6, 0x0e, 0x6a, 0x71, 0x1b, 0xea, 0xf9, 0x19, 0x9a, 0x09, 0x1a, 0x4d, 0xe9, 0xef, 0x39, 0xf2,
0x80, 0x77, 0x0e, 0x4e, 0x54, 0x0f, 0xc4, 0x8f, 0xdc, 0xa4, 0xb7, 0xb5, 0x63, 0xdd, 0x3a, 0x4f,
0xdc, 0xd2, 0x17, 0x3b, 0x1c, 0xbc, 0xfa, 0xa2, 0x15, 0x69, 0x26, 0x8c, 0x1e, 0x68, 0xc9, 0x14,
0xc5, 0x4e, 0x69, 0x98, 0xc1, 0x3c, 0x5d, 0x8b, 0x02, 0x70, 0xb5, 0x94, 0x90, 0x71, 0x1e, 0xb6,
0xd9, 0x10, 0x5d, 0x67, 0x37, 0x75, 0x38, 0x8e, 0x0e, 0x75, 0xf8, 0xcd, 0x67, 0x94, 0xdd, 0x82,
0xd6, 0xec, 0xc2, 0x91, 0xf6, 0x10, 0x5d, 0x9c, 0xf7, 0x28, 0xed, 0x5d, 0x70, 0x4c, 0x92, 0x45,
0xd8, 0x86, 0xbe, 0x9a, 0x3c, 0x31, 0x76, 0x18, 0x80, 0x0a, 0xdd, 0x7e, 0x06, 0x95, 0xc6, 0x14,
0x7e, 0x7d, 0xce, 0x1f, 0xd1, 0x66, 0xc6, 0xef, 0xc5, 0x63, 0x25, 0x95, 0x39, 0x64, 0x14, 0x28,
0xae, 0x51, 0x6d, 0x0d, 0x9c, 0xc0, 0x5a, 0x3a, 0xdb, 0x02, 0xae, 0x50, 0x43, 0x34, 0x3b, 0x49,
0x31, 0xf4, 0x6b, 0x4f, 0x85, 0xf6, 0x1d, 0x53, 0x88, 0x76, 0xd3, 0x01, 0x71, 0xfc, 0x23, 0x06,
0x63, 0x9f, 0x3d, 0xd2, 0x00, 0x8d, 0xc7, 0x5a, 0x2f, 0x8a, 0x54, 0xfc, 0x76, 0x0f, 0x7a, 0x76,
0x0f, 0xfb, 0x2f, 0x1c, 0x0a, 0x3b, 0x3f, 0xd6, 0xad, 0xfc, 0xcf, 0x68, 0x6b, 0x0b, 0xae, 0x9c,
0xda, 0xeb, 0x8d, 0x8f, 0x7f, 0x7d, 0x1a, 0x55, 0x28, 0x90, 0xa8, 0xc0, 0x04, 0x25, 0xa2, 0x7b,
0xb3, 0x3b, 0xd0, 0x9d, 0x79, 0xc0, 0xb5, 0x7f, 0x84, 0x7c, 0x85, 0xda, 0x59, 0xda, 0xfb, 0xb3,
0xab, 0x26, 0x51, 0x9e, 0x92, 0x6f, 0xce, 0x53, 0x8c, 0xf8, 0x72, 0x1b, 0xcf, 0x31, 0x41, 0x04,
0x9f, 0x7e, 0x8f, 0x9e, 0xc4, 0xfe, 0x56, 0xd3, 0x54, 0x1e, 0x1d, 0xe8, 0x3e, 0x49, 0xd3, 0x41,
0xf1, 0x37, 0x1e, 0xb1, 0xa9, 0x5d, 0x59, 0x5f, 0x17, 0x34, 0x0a, 0x86, 0x01, 0xb5, 0x71, 0xa0,
0x22, 0xe7, 0x35, 0x6f, 0xf1, 0x50, 0x55, 0x38, 0xa6, 0x4e, 0x80, 0x8a, 0xd4, 0x25, 0x67, 0x81,
0xa5, 0xc6, 0x3c, 0x45, 0x31, 0xf4, 0x1d, 0x31, 0x69, 0xf3, 0x25, 0xe2, 0xde, 0x0f, 0xb3, 0xc6,
0x44, 0x73, 0x7a, 0xd0, 0xf2, 0xac, 0x2e, 0xbf, 0xf7, 0xad, 0x8c, 0xe1, 0x33, 0x66, 0xf2, 0x03,
0x67, 0xbe, 0x4a, 0xbf, 0x4e, 0x3a, 0xf5, 0x99, 0x15, 0x55, 0x8f, 0xac, 0xe2, 0xa4, 0x82, 0x4e,
0x44, 0xbb, 0xd8, 0xa1, 0x26, 0x32, 0x5f, 0xf8, 0x54, 0x16, 0x96, 0x43, 0x37, 0x3d, 0x98, 0x6e,
0xec, 0x3a, 0xa4, 0x66, 0x65, 0x6a, 0xbc, 0x1e, 0xd1, 0xe8, 0xde, 0x44, 0x74, 0x1f, 0x32, 0x12,
0x3c, 0xe7, 0x4c, 0x1c, 0x15, 0x46, 0x9c, 0xa2, 0x27, 0x54, 0x64, 0x48, 0xe4, 0x36, 0xc2, 0x7d,
0xb4, 0xd7, 0xc9, 0xf7, 0xd2, 0x5c, 0x80, 0x0b, 0xe6, 0x52, 0x96, 0x42, 0x9e, 0xb3, 0x03, 0x60,
0x67, 0x29, 0x4f, 0x6a, 0xab, 0x62, 0x32, 0x0d, 0x9c, 0x20, 0x9e, 0xa9, 0x6c, 0x48, 0x51, 0x70,
0xe6, 0x17, 0x83, 0xfc, 0x56, 0xf4, 0xcc, 0xba, 0x06, 0x9d, 0x37, 0x7a, 0x55, 0xe3, 0xf0, 0xda,
0xe7, 0x27, 0x57, 0x3b, 0x35, 0x32, 0x9e, 0x13, 0xa5, 0x14, 0x2e, 0x1f, 0x88, 0xe5, 0xb8, 0x2c,
0x45, 0x16, 0x24, 0x7d, 0x1e, 0x28, 0x63, 0xdb, 0x67, 0x43, 0xcf, 0xda, 0x19, 0x99, 0x96, 0x3d,
0x6d, 0x06, 0x65, 0x8c, 0xce, 0x73, 0x51, 0x8c, 0x4f, 0xaf, 0x5c, 0xa8, 0x85, 0xce, 0x12, 0xe6,
0xf0, 0xfe, 0x20, 0x09, 0x08, 0xd0, 0x18, 0xdb, 0x61, 0x0e, 0x95, 0x5f, 0xa0, 0x48, 0xb9, 0xbb,
0xfe, 0x45, 0x15, 0x7d, 0x2f, 0x74, 0x88, 0x24, 0x14, 0xb3, 0x60, 0x39, 0x7b, 0x86, 0x3c, 0x8a,
0x3c, 0x81, 0x01, 0xc7, 0xbf, 0xc6, 0xd3, 0xf8, 0x36, 0xc7, 0x8b, 0x52, 0xec, 0x86, 0x9c, 0x01,
0x5b, 0xb6, 0x1a, 0x97, 0xc9, 0xc9, 0x5d, 0x26, 0x35, 0xb1, 0x33, 0x5b, 0x7b, 0xd3, 0x94, 0xb8,
0xe6, 0x32, 0xb6, 0x8c, 0x92, 0x95, 0x10, 0x8f, 0x20, 0xe9, 0x07, 0xf8, 0x4b, 0xb6, 0x45, 0xd0,
0x39, 0xed, 0xdb, 0xe5, 0x51, 0xf7, 0xa4, 0x02, 0x91, 0x29, 0x7c, 0xe6, 0x14, 0x52, 0x2a, 0x79,
0xcf, 0xe0, 0xcf, 0x16, 0x48, 0x90, 0x44, 0xcd, 0x34, 0x65, 0xef, 0x1f, 0xea, 0x26, 0xfd, 0x19,
0x0c, 0xea, 0x4b, 0x34, 0x2d, 0x39, 0x08, 0xd5, 0x48, 0xbf, 0xdc, 0x41, 0x7d, 0xb6, 0xa5, 0x92,
0x2a, 0xde, 0xf9, 0x99, 0xbe, 0xc8, 0x36, 0xd3, 0x31, 0x77, 0x3c, 0x2b, 0x2f, 0xa9, 0x1c, 0x80,
0x5b, 0xc9, 0x40, 0x21, 0xb8, 0x3e, 0xa4, 0x2f, 0x01, 0xe7, 0x2c, 0xce, 0x64, 0xdc, 0x1b, 0xfb,
0x10, 0xc5, 0x08, 0x18, 0x3a, 0x3b, 0x0d, 0x41, 0x32, 0xd3, 0x7c, 0x13, 0xb9, 0x85, 0x59, 0x94,
0x5e, 0x27, 0x0b, 0x77, 0x34, 0x33, 0xd7, 0x59, 0xee, 0x65, 0xab, 0xc3, 0xaf, 0xd2, 0xd3, 0x19,
0x6e, 0xcb, 0x09, 0x30, 0x46, 0x14, 0x69, 0x91, 0xb5, 0x0b, 0x61, 0x40, 0x55, 0xce, 0x49, 0x5d,
0x95, 0xfe, 0x81, 0xcb, 0xbe, 0x20, 0x59, 0x11, 0xa8, 0x89, 0xc1, 0xab, 0xf2, 0xcf, 0x8f, 0xf5,
0xe1, 0x67, 0x03, 0xb0, 0xf8, 0x5b, 0x23, 0x5b, 0x9c, 0x73, 0xb3, 0xb4, 0xb3, 0x71, 0x6e, 0xd7,
0x46, 0xed, 0x61, 0x1d, 0xd2, 0x37, 0x99, 0xa4, 0xe9, 0x3b, 0x60, 0xf1, 0x33, 0x7d, 0x6b, 0xda,
0xb7, 0xd9, 0x7c, 0xc6, 0x5d, 0x89, 0xbd, 0xcf, 0xc4, 0x94, 0x51, 0xc2, 0x94, 0xed, 0x09, 0x04,
0x4a, 0x98, 0x96, 0xd5, 0x96, 0xc5, 0xcc, 0x14, 0xc4, 0x37, 0xae, 0x61, 0x04, 0xe4, 0x20, 0xef,
0x75, 0x90, 0x84, 0xcb, 0x9f, 0xca, 0x6a, 0xb0, 0x00, 0xfb, 0x37, 0xfb, 0x95, 0xe1, 0xe1, 0xbc,
0xee, 0x71, 0xd1, 0xdb, 0xa9, 0x53, 0xf7, 0x5c, 0x81, 0x27, 0x72, 0x90, 0x2f, 0x06, 0x2c, 0xbf,
0x7a, 0x0a, 0xf0, 0x10, 0xb7, 0xd2, 0x31, 0xbd, 0xc8, 0x80, 0x90, 0x27, 0x87, 0x0a, 0x61, 0x67,
0x76, 0x4d, 0xeb, 0x96, 0xb7, 0x83, 0xfe, 0xf0, 0xac, 0x70, 0x59, 0xf8, 0xd6, 0x51, 0xe3, 0xb9,
0x02, 0x3e, 0xbc, 0xef, 0xdf, 0xc2, 0x08, 0x17, 0x72, 0x2c, 0xa5, 0xf8, 0xf8, 0xb6, 0xfb, 0x1b,
0x58, 0x47, 0x03, 0x92, 0xb0, 0xa9, 0xfd, 0x18, 0xd1, 0x6d, 0xad, 0x1d, 0xca, 0x71, 0xff, 0x3c,
0x1b, 0xa8, 0x61, 0xa8, 0x18, 0xad, 0x4a, 0xe8, 0xbb, 0xb9, 0x34, 0xda, 0xa3, 0x30, 0x2e, 0xd9,
0x30, 0x6b, 0x4d, 0xc9, 0xb7, 0xc8, 0x76, 0xd1, 0xe5, 0x51, 0x14, 0x1c, 0x17, 0x3e, 0x52, 0xf6,
0xd7, 0x70, 0xde, 0xe7, 0x25, 0xa6, 0x27, 0x6f, 0xba, 0x13, 0xc3, 0x91, 0x99, 0xaa, 0x42, 0x3d,
0xb2, 0xa3, 0x0b, 0xbe, 0x9a, 0xa7, 0x51, 0x75, 0xcf, 0x54, 0x4f, 0x39, 0x62, 0xe0, 0x72, 0x82,
0x24, 0x19, 0x69, 0x6e, 0x23, 0x2d, 0x7c, 0xfb, 0xd6, 0xf9, 0x68, 0xa3, 0x5d, 0x71, 0x5d, 0x21,
0x47, 0x05, 0x08, 0x0f, 0xed, 0x47, 0xa1, 0xd9, 0x6b, 0x42, 0xcf, 0x8e, 0xb8, 0x73, 0x12, 0x58,
0x90, 0x71, 0x0f, 0xf6, 0xfc, 0x4a, 0x33, 0xc9, 0xc9, 0xd6, 0xc6, 0xd7, 0x71, 0x3b, 0xfb, 0xd4,
0xbf, 0x87, 0x43, 0x37, 0xf6, 0x18, 0xe6, 0x5c, 0xaa, 0x0f, 0x33, 0x02, 0x9e, 0x34, 0xd4, 0xb0,
0xa8, 0x7c, 0xdb, 0x37, 0x2d, 0x8a, 0xf3, 0xba, 0x57, 0xb8, 0xc1, 0xcb, 0xea, 0x40, 0x26, 0x28,
0xae, 0xda, 0xe4, 0x96, 0x09, 0xea, 0x78, 0xe3, 0x70, 0xc6, 0x61, 0x17, 0x47, 0x9f, 0xd4, 0xd8,
0x01, 0x0c, 0x78, 0xc6, 0xba, 0x5a, 0xc2, 0x20, 0x33, 0x60, 0xe1, 0x4f, 0x59, 0x45, 0x41, 0xda,
0x75, 0xcb, 0x5f, 0x46, 0x1c, 0xdd, 0xa2, 0x2e, 0xd5, 0x5d, 0xba, 0x49, 0x7a, 0x34, 0x6b, 0x02,
0x7e, 0xe6, 0xaa, 0x08, 0x74, 0x60, 0xa9, 0x6d, 0xab, 0x9f, 0xfe, 0x72, 0xbf, 0x98, 0x1a, 0xec,
0x7a, 0x4d, 0x3b, 0xf9, 0x98, 0x6f, 0x58, 0x2c, 0xc9, 0x9c, 0xe2, 0xcc, 0xc0, 0x06, 0x2a, 0x4a,
0x57, 0x29, 0xdc, 0x83, 0xc9, 0xbd, 0x99, 0x67, 0xcb, 0x97, 0x1c, 0x6a, 0xd6, 0xf2, 0xbe, 0x95,
0xeb, 0xa4, 0xab, 0xae, 0xb3, 0xb3, 0x0d, 0x3a, 0xfb, 0x63, 0xfe, 0x57, 0xa3, 0xcb, 0x37, 0x3c,
0x7b, 0xc0, 0xd4, 0xf8, 0x3b, 0x1e, 0x66, 0x1a, 0xa4, 0xb0, 0xa6, 0x2f, 0x1b, 0x2f, 0x8a, 0xfd,
0x5e, 0xe7, 0x91, 0x5b, 0x38, 0x32, 0x08, 0xab, 0xad, 0xa0, 0x39, 0xab, 0xe7, 0xb1, 0x25, 0xfb,
0x57, 0x5e, 0xff, 0xc8, 0x98, 0xe2, 0xde, 0xd7, 0x82, 0x21, 0x86, 0x66, 0x04, 0xf3, 0x73, 0x82,
0x7b, 0x10, 0x11, 0x33, 0x7d, 0x44, 0x6e, 0xc4, 0x67, 0xf8, 0xca, 0x4d, 0x30, 0x29, 0xfe, 0x24,
0xa3, 0x2d, 0xd5, 0xfa, 0x48, 0x25, 0x9e, 0xa4, 0x1f, 0xc0, 0x43, 0xdb, 0x9c, 0x7e, 0x89, 0xe9,
0xf9, 0x9a, 0x5c, 0x16, 0xf3, 0xef, 0x59, 0xe9, 0xdf, 0x0f, 0x5d, 0xda, 0x61, 0x8d, 0x4c, 0xc1,
0x0e, 0xb4, 0xa2, 0x4d, 0x0d, 0xb3, 0x55, 0x31, 0x95, 0xa2, 0xf9, 0xaa, 0xee, 0xa8, 0xa6, 0xc9,
0x47, 0xec, 0x97, 0xe6, 0x10, 0xb5, 0x3f, 0xc5, 0xcf, 0x90, 0x46, 0xf6, 0xb0, 0xb5, 0xa3, 0x24,
0x35, 0xa5, 0x9a, 0xde, 0xe0, 0xda, 0x18, 0xd6, 0xdb, 0x47, 0x8b, 0xa0, 0x5c, 0x43, 0x6c, 0x9d,
0x44, 0x3d, 0xb5, 0xb5, 0x26, 0x13, 0xda, 0xe8, 0x60, 0x42, 0xa5, 0x85, 0x5b, 0x7e, 0x3a, 0x34,
0xb1, 0x28, 0x83, 0x8c, 0x09, 0x34, 0xd8, 0x2c, 0x74, 0xa9, 0x42, 0x9b, 0xa8, 0xd4, 0xb7, 0xa9,
0x4b, 0xdf, 0xa6, 0x6e, 0x2b, 0x44, 0xae, 0xb9, 0x36, 0xb8, 0xc9, 0x22, 0x03, 0xd7, 0x20, 0x59,
0x90, 0x8a, 0x92, 0xab, 0x88, 0x18, 0x8c, 0xeb, 0x72, 0x88, 0xa1, 0x96, 0x46, 0xad, 0x94, 0x92,
0xb6, 0x69, 0x73, 0x93, 0xe0, 0xd9, 0x79, 0x7b, 0x48, 0xb0, 0xa1, 0x28, 0x2d, 0x2d, 0x92, 0x84,
0x60, 0x37, 0x8b, 0xc6, 0x35, 0x8d, 0x70, 0x6a, 0x18, 0x12, 0xd6, 0xce, 0x58, 0x58, 0x6e, 0x67,
0xea, 0xb0, 0xdc, 0x79, 0x86, 0xe2, 0x5c, 0x6a, 0x39, 0x08, 0x38, 0x01, 0x31, 0x78, 0xcc, 0x18,
0x88, 0xde, 0x36, 0xbc, 0x82, 0xd2, 0xb4, 0x21, 0x67, 0x4e, 0x8d, 0x5a, 0x4a, 0x53, 0xbf, 0x77,
0x86, 0xf7, 0xf5, 0x6c, 0x47, 0x18, 0xee, 0xe6, 0xd3, 0xde, 0x2b, 0xcf, 0x1d, 0x39, 0x79, 0x7c,
0xd5, 0x52, 0xaf, 0x58, 0xbf, 0x6f, 0xfd, 0x62, 0x36, 0x33, 0xf2, 0xb1, 0x08, 0x7d, 0x67, 0x64,
0xea, 0x96, 0x48, 0x5f, 0xf6, 0x9e, 0x63, 0x51, 0xdc, 0x14, 0xae, 0x76, 0xbc, 0x8e, 0x89, 0x37,
0x9e, 0x1e, 0xae, 0xaa, 0x11, 0x9c, 0x11, 0xc2, 0x7e, 0xab, 0x32, 0x90, 0xdf, 0xb4, 0x02, 0x93,
0x45, 0x33, 0x81, 0x83, 0x00, 0x28, 0x78, 0xf6, 0x17, 0xad, 0x0c, 0x73, 0x19, 0x7b, 0x32, 0x5b,
0xe6, 0x9a, 0x35, 0x3d, 0x12, 0xe0, 0x29, 0xdd, 0xb4, 0xb5, 0xce, 0xcf, 0xc1, 0x75, 0xe9, 0x24,
0x8b, 0x02, 0x91, 0xdb, 0x1c, 0xb5, 0x03, 0xc7, 0xf0, 0xfd, 0xc5, 0xa0, 0x5e, 0xea, 0xa2, 0xfb,
0x80, 0xd2, 0xc4, 0x78, 0xd8, 0xb8, 0x85, 0x42, 0xc1, 0x3b, 0xf2, 0x46, 0x61, 0x32, 0xdb, 0xec,
0x57, 0x68, 0x56, 0x6d, 0x8e, 0x35, 0x56, 0x37, 0x92, 0x36, 0x73, 0x6c, 0xcd, 0x63, 0x82, 0x4f,
0xda, 0x29, 0xd7, 0x75, 0x8f, 0xef, 0x9a, 0xe3, 0x3d, 0x5c, 0xf5, 0x37, 0xf3, 0xd1, 0x82, 0x55,
0xeb, 0xcc, 0xa4, 0x22, 0x5e, 0x72, 0x9b, 0xcd, 0xdb, 0x9d, 0x49, 0x00, 0xeb, 0xe1, 0x43, 0x93,
0xdc, 0x5c, 0x18, 0x0a, 0xbb, 0xfb, 0x78, 0x26, 0xaf, 0x0a, 0x6a, 0x11, 0x52, 0xe0, 0xf5, 0xd3,
0xbc, 0x5d, 0x32, 0xbe, 0x69, 0xa6, 0x13, 0x67, 0xae, 0xf1, 0x7f, 0x00, 0x0d, 0x5a, 0xaa, 0x8c,
0x4a, 0xee, 0x44, 0x27, 0xa3, 0x02, 0x25, 0x7e, 0x5b, 0xb6, 0xcd, 0xd2, 0xea, 0x15, 0x2b, 0x6b,
0x9e, 0x66, 0x23, 0x31, 0x80, 0xb7, 0xee, 0x01, 0x80, 0x0d, 0x85, 0x51, 0xd7, 0x10, 0x6d, 0x0e,
0x64, 0x38, 0x3e, 0x3b, 0x87, 0x9c, 0x5e, 0xfc, 0xea, 0xb6, 0xd1, 0x9a, 0x46, 0x83, 0x53, 0x14,
0x85, 0x13, 0xce, 0x8f, 0x96, 0xf5, 0xa1, 0x6a, 0x2f, 0x68, 0x3f, 0xd4, 0xd7, 0xb2, 0x22, 0x3d,
0x3c, 0xf7, 0x0f, 0x90, 0x52, 0x73, 0xbb, 0x17, 0x7c, 0x76, 0xe1, 0x4f, 0x21, 0xed, 0x7a, 0xce,
0x0c, 0xf7, 0x7d, 0x38, 0x7f, 0xa3, 0x7b, 0x11, 0xbb, 0x0f, 0x81, 0xbe, 0xde, 0x98, 0x99, 0x0e,
0x7e, 0xeb, 0x0a, 0x21, 0x09, 0x32, 0xcf, 0xc2, 0x53, 0x47, 0x45, 0xfa, 0x16, 0x84, 0x3f, 0xf5,
0x8b, 0x11, 0x4a, 0x46, 0xa9, 0xbb, 0x5d, 0x2d, 0xa4, 0xeb, 0x6a, 0x8b, 0x5f, 0xc8, 0xab, 0xb1,
0xe1, 0xe4, 0x3d, 0x2b, 0xdd, 0x34, 0xd3, 0x35, 0x2a, 0x86, 0xf5, 0x5f, 0xf0, 0xd3, 0xc1, 0x6d,
0xd3, 0x6a, 0xec, 0x1d, 0x79, 0x4c, 0xdd, 0xa0, 0x3d, 0x8a, 0x8b, 0xa1, 0xc7, 0x4b, 0x3a, 0x94,
0x48, 0x9e, 0x88, 0xfe, 0xfd, 0x1c, 0x32, 0x75, 0xae, 0x7b, 0xaa, 0xe4, 0x06, 0xc8, 0x5a, 0x00,
0xc0, 0x66, 0x69, 0x46, 0xd2, 0x45, 0xd7, 0xc0, 0x9b, 0xe7, 0xb5, 0xd6, 0x45, 0x4f, 0xd5, 0x04,
0xd1, 0xa3, 0x33, 0xbb, 0x9b, 0x6d, 0xc2, 0xa1, 0xb1, 0x83, 0x5e, 0x9f, 0xd7, 0x94, 0xca, 0xe2,
0x7a, 0x00, 0x60, 0xf2, 0x8b, 0x68, 0xe2, 0xb2, 0x4e, 0x83, 0x7a, 0x5b, 0xa0, 0x68, 0xa1, 0xa8,
0x51, 0x3d, 0x52, 0x71, 0xe5, 0x04, 0x0e, 0x07, 0x26, 0xec, 0x5e, 0x71, 0xfa, 0x0b, 0x31, 0xbc,
0xbb, 0xc2, 0xf7, 0x7e, 0x2b, 0xca, 0xb7, 0xe7, 0x17, 0x24, 0x47, 0x5e, 0x78, 0x86, 0xf7, 0xd7,
0xe6, 0x9b, 0x7f, 0x6a, 0x72, 0xb0, 0x36, 0xf0, 0xdd, 0x86, 0x92, 0x01, 0x0e, 0xf3, 0xa0, 0x09,
0x4f, 0xd6, 0xbb, 0x68, 0x28, 0x3d, 0x5e, 0x93, 0x09, 0x59, 0x64, 0xa3, 0xa0, 0xad, 0x42, 0x4d,
0x65, 0xf7, 0xf4, 0x29, 0xea, 0x4f, 0x67, 0x23, 0xf3, 0x92, 0x3a, 0x08, 0x29, 0xe4, 0xdc, 0x73,
0x26, 0xa1, 0xd6, 0x4c, 0x13, 0x82, 0x3d, 0xe1, 0x9b, 0x8f, 0x5e, 0x5c, 0x9e, 0x49, 0xe5, 0x0e,
0x63, 0xd4, 0x7e, 0xd5, 0x46, 0x6f, 0xfd, 0xc1, 0x0f, 0x35, 0x3d, 0x37, 0xf8, 0xe3, 0x19, 0xe7,
0x7d, 0x3a, 0x79, 0x42, 0x9e, 0xc8, 0xff, 0x91, 0xbd, 0xdc, 0x62, 0xe5, 0xc8, 0x7a, 0xd2, 0x2f,
0xd0, 0xbf, 0x01, 0xad, 0x0f, 0x69, 0x54, 0x2e, 0x06, 0x41, 0xd0, 0x2b, 0x12, 0x4f, 0x4a, 0x13,
0xcd, 0xe7, 0x04, 0x49, 0x1b, 0x0a, 0x09, 0x11, 0xcc, 0x35, 0x33, 0xb6, 0xb9, 0xec, 0xc9, 0x39,
0xf5, 0x5f, 0x30, 0x7a, 0x9d, 0x2f, 0xbf, 0xee, 0xf8, 0xf0, 0x5e, 0x27, 0x3c, 0x82, 0xee, 0xbc,
0xc9, 0xa6, 0xec, 0x42, 0x1c, 0x5a, 0x57, 0x50, 0x47, 0xa6, 0x17, 0x2f, 0x68, 0x0a, 0xba, 0xe1,
0x8e, 0x39, 0x15, 0xf2, 0x33, 0x41, 0x2d, 0x6c, 0xe2, 0xac, 0x49, 0x81, 0x35, 0x4d, 0xb9, 0xf3,
0x0b, 0xf1, 0x49, 0xda, 0x68, 0x91, 0xf5, 0x9a, 0x09, 0x6b, 0x14, 0x49, 0x59, 0x60, 0x64, 0x43,
0x71, 0xa3, 0xff, 0xff, 0x82, 0xa7, 0xb9, 0x8d, 0x7d, 0x0d, 0x91, 0x9f, 0x05, 0xb0, 0xdd, 0xa8,
0x4b, 0xf5, 0xb7, 0xbd, 0x68, 0xed, 0xce, 0xa9, 0x66, 0x16, 0x67, 0x82, 0xc9, 0x7c, 0x22, 0xe4,
0x34, 0xab, 0xb9, 0x34, 0x5a, 0x5f, 0x67, 0x89, 0x34, 0x6b, 0x53, 0x4c, 0x2f, 0xb9, 0xf6, 0x11,
0x1e, 0x2f, 0xe3, 0xa6, 0x26, 0x42, 0x45, 0xe1, 0x62, 0x68, 0xbd, 0x16, 0xe1, 0xed, 0x74, 0xfa,
0x0c, 0xa5, 0x87, 0xd9, 0xbc, 0x80, 0xe2, 0xb8, 0xc1, 0x53, 0xe7, 0x66, 0x7f, 0x7c, 0x67, 0x1d,
0x43, 0x74, 0x9b, 0x94, 0x57, 0xd9, 0xb1, 0x86, 0x0d, 0xa1, 0xcf, 0x07, 0x87, 0x94, 0x0d, 0xca,
0xac, 0x01, 0xa5, 0x81, 0x09, 0xfc, 0x0a, 0x62, 0x7a, 0xe5, 0x31, 0xcc, 0xb9, 0x9f, 0xc2, 0x40,
0xd3, 0x33, 0xbc, 0x95, 0xce, 0x9f, 0x85, 0xf6, 0xf4, 0xbc, 0x44, 0xe5, 0x20, 0xa8, 0xba, 0x9b,
0x5c, 0x7d, 0x58, 0x8c, 0x9f, 0x35, 0xe7, 0x91, 0x64, 0xb8, 0x1f, 0x86, 0xe6, 0xca, 0xe5, 0x73,
0x08, 0xe5, 0x0b, 0xd2, 0x7b, 0x98, 0xe1, 0xb8, 0x6d, 0x19, 0x9e, 0xe5, 0xa7, 0x54, 0x7b, 0xdd,
0x24, 0x80, 0xd5, 0x6c, 0x27, 0x36, 0x75, 0x0b, 0x57, 0xc7, 0xd8, 0xde, 0xa6, 0xee, 0x02, 0xeb,
0xa2, 0x9d, 0xa3, 0xa2, 0x35, 0x5f, 0x65, 0xca, 0x24, 0x9a, 0xe1, 0xe0, 0x99, 0x6a, 0xd1, 0x25,
0x50, 0xd6, 0xed, 0x3e, 0x20, 0x52, 0xe6, 0xec, 0x14, 0x41, 0xf7, 0xbb, 0x2c, 0x53, 0x95, 0x70,
0x08, 0x02, 0xd3, 0x3c, 0xd2, 0x21, 0xa4, 0x8d, 0xaa, 0xc9, 0x31, 0x8e, 0x9e, 0xc9, 0x9d, 0x40,
0x8b, 0x8b, 0xc0, 0x63, 0x5a, 0xeb, 0xcb, 0x71, 0xa9, 0x7b, 0x30, 0xc3, 0xc0, 0xd6, 0x57, 0x00,
0x4b, 0x58, 0x9a, 0xce, 0x36, 0xd1, 0x06, 0xfb, 0xc2, 0xcd, 0x34, 0x2f, 0x6d, 0x14, 0x75, 0x46,
0xa0, 0xe2, 0x68, 0x9c, 0x5e, 0xcd, 0x13, 0xaf, 0xb4, 0xb3, 0xa3, 0xec, 0x48, 0x3a, 0x17, 0x8d,
0x98, 0xe3, 0xdc, 0x41, 0x62, 0x14, 0x17, 0xcc, 0x55, 0x7d, 0xdb, 0xd8, 0x96, 0x07, 0x02, 0xb0,
0x2a, 0xb8, 0x71, 0xc2, 0x79, 0x50, 0x5b, 0x7a, 0x84, 0x43, 0x4a, 0xc4, 0x14, 0xd3, 0x18, 0x7e,
0x5e, 0x4a, 0x9f, 0x90, 0x0e, 0x37, 0xbf, 0xcf, 0x15, 0xcd, 0xfd, 0x33, 0x91, 0x58, 0xdc, 0x78,
0x9e, 0x7f, 0x9a, 0xbc, 0xb5, 0x6e, 0x66, 0xa4, 0xed, 0x7d, 0xd7, 0x51, 0x7b, 0x21, 0x3b, 0x5b,
0x2c, 0xc3, 0xa3, 0x4f, 0x33, 0x5c, 0x49, 0xc2, 0x81, 0xf7, 0xc6, 0x78, 0x89, 0x93, 0x2b, 0xd2,
0xbf, 0x4b, 0x40, 0x26, 0xf5, 0x39, 0x18, 0xc9, 0x2c, 0xc1, 0xae, 0xb4, 0xa9, 0x20, 0xab, 0x6f,
0x89, 0x46, 0x56, 0xb7, 0xc6, 0xfc, 0xbb, 0x3a, 0x15, 0x73, 0x68, 0x12, 0xab, 0xfa, 0x76, 0x1d,
0x9f, 0x80, 0x78, 0xdf, 0x1e, 0x52, 0xc5, 0xa1, 0x73, 0xc4, 0x88, 0xf6, 0xb3, 0xe4, 0x94, 0x10,
0x1c, 0xe5, 0x70, 0x3f, 0x26, 0xf5, 0x46, 0x78, 0x97, 0xb6, 0xaf, 0x75, 0xf9, 0x2d, 0x5f, 0x13,
0x56, 0xb5, 0x27, 0x2e, 0x3c, 0x36, 0x18, 0xad, 0x10, 0x8e, 0xa9, 0x92, 0x39, 0x7d, 0x8b, 0x81,
0x43, 0x03, 0xbd, 0x65, 0x22, 0xd3, 0x1b, 0x80, 0xc6, 0xbc, 0xbd, 0x90, 0x1f, 0x59, 0xf8, 0xd7,
0xa4, 0xdc, 0x29, 0xfc, 0xd2, 0xb2, 0x73, 0x6b, 0x60, 0xd6, 0x2e, 0xe1, 0x1e, 0xc7, 0x1e, 0xf7,
0xea, 0xd1, 0x19, 0xfb, 0x5a, 0x23, 0x57, 0x9d, 0xbf, 0xdb, 0x41, 0xb9, 0x44, 0xe0, 0x8e, 0xe1,
0xc9, 0x9b, 0x6c, 0x0b, 0x33, 0xf5, 0x92, 0xe7, 0x33, 0xbc, 0x3b, 0x00, 0x00, 0x3f, 0x22, 0xd5,
0x27, 0xf0, 0xf7, 0x9f, 0x9a, 0x88, 0xc3, 0x3f, 0x0d, 0x5c, 0xff, 0x7b, 0x30, 0xd0, 0x58, 0x8d,
0xea, 0x52, 0xac, 0x57, 0xa8, 0x7f, 0x19, 0x84, 0x80, 0x70, 0x18, 0x6d, 0xb5, 0x8c, 0xfa, 0x03,
0x1c, 0xad, 0x0b, 0x75, 0x3f, 0xe9, 0x19, 0xf0, 0xb2, 0xb9, 0x64, 0xb4, 0xfe, 0xd8, 0x93, 0x09,
0xd9, 0x52, 0xde, 0x8a, 0x8d, 0x33, 0xf6, 0xfe, 0x03, 0xd6, 0x6f, 0x4a, 0x57, 0xcb, 0xc7, 0x80,
0x2b, 0x10, 0xed, 0xe7, 0x2d, 0x32, 0xf4, 0x15, 0x06, 0xf6, 0xf9, 0xa4, 0x70, 0x69, 0xd2, 0x74,
0x91, 0x33, 0xa0, 0xb6, 0xc9, 0x31, 0x8a, 0x46, 0xe3, 0xa9, 0x15, 0x04, 0xc5, 0xc4, 0xec, 0x04,
0x53, 0x1b, 0x0e, 0xe0, 0xf2, 0x8d, 0x78, 0x1c, 0xdc, 0x49, 0x91, 0x6f, 0x36, 0xd3, 0xf7, 0xe3,
0x3b, 0x69, 0x2a, 0xdb, 0x53, 0xdf, 0x2f, 0xb8, 0xe2, 0xdc, 0x20, 0x67, 0x09, 0x10, 0x81, 0xcf,
0xde, 0x25, 0xdd, 0xcf, 0x2d, 0x3c, 0x62, 0xff, 0xaf, 0x7d, 0xb0, 0xbe, 0x1b, 0x09, 0x62, 0xdb,
0x45, 0xc9, 0x2c, 0x56, 0x58, 0xe6, 0x2b, 0xed, 0x28, 0x12, 0xe6, 0x92, 0x7d, 0x77, 0x9c, 0x61,
0xe7, 0xbc, 0xa7, 0x4b, 0x2d, 0xb1, 0x79, 0xf8, 0x09, 0x6a, 0x7e, 0x9f, 0xf1, 0x68, 0x2c, 0x58,
0x4b, 0xa9, 0x28, 0x70, 0x3e, 0x17, 0xa3, 0x5b, 0xaf, 0xc0, 0x1d, 0x9c, 0x12, 0xa5, 0xd5, 0x77,
0x20, 0x24, 0x52, 0xcb, 0xd4, 0xbb, 0xd2, 0x1f, 0x6b, 0x0a, 0x60, 0x9c, 0x21, 0xa0, 0x3e, 0xd3,
0x1e, 0xf2, 0xae, 0x47, 0xe3, 0xf3, 0x70, 0x6f, 0x02, 0x1b, 0x35, 0xd4, 0xf6, 0x5a, 0xad, 0x94,
0xd6, 0xab, 0x1f, 0x52, 0x3f, 0x34, 0xfc, 0x9d, 0x4b, 0x65, 0x1c, 0x23, 0xaa, 0x7a, 0x5a, 0x65,
0x15, 0x0e, 0x71, 0xa4, 0x06, 0x18, 0xfc, 0xa6, 0xa4, 0xc3, 0x7f, 0x7c, 0x58, 0x3a, 0xbd, 0x91,
0x20, 0xe0, 0xdd, 0xf9, 0x35, 0xe4, 0x2b, 0x06, 0x1c, 0x60, 0x91, 0x1d, 0x8a, 0x3b, 0xea, 0x00,
0xb4, 0x2f, 0xcb, 0xd5, 0x92, 0xa4, 0x66, 0xc6, 0x54, 0x60, 0x15, 0x76, 0xbf, 0x9c, 0x73, 0xaf,
0x64, 0xab, 0x41, 0xc7, 0x54, 0xbf, 0xca, 0x97, 0xef, 0x1f, 0xc5, 0x55, 0xaf, 0x08, 0x52, 0x36,
0x64, 0xf4, 0x29, 0x9f, 0xa8, 0x53, 0xd6, 0x7e, 0x91, 0xd2, 0x17, 0xfa, 0x9e, 0xf7, 0x37, 0x09,
0x7d, 0x01, 0xf6, 0xd4, 0x29, 0x8c, 0xfd, 0x56, 0x56, 0x2f, 0x5f, 0xf5, 0xbe, 0x6f, 0xe1, 0xb9,
0x82, 0x00, 0x15, 0x1d, 0xdb, 0x4a, 0xde, 0xa1, 0x34, 0x80, 0x2e, 0x4a, 0xc9, 0xc5, 0x06, 0x60,
0xd2, 0x80, 0x3a, 0x71, 0x6a, 0x9f, 0x5a, 0x54, 0xa2, 0x2b, 0xf2, 0x0d, 0xcc, 0x46, 0x3e, 0x7c,
0x0c, 0x6c, 0x15, 0xe1, 0xe1, 0x5b, 0x3f, 0xe9, 0x76, 0x01, 0x00, 0x60, 0xc2, 0x61, 0x4f, 0xa1,
0x0e, 0x50, 0xc4, 0x28, 0xd4, 0xe6, 0x11, 0x2e, 0xcc, 0x8f, 0xf8, 0x40, 0x7a, 0x69, 0x47, 0x58,
0xd4, 0x31, 0xb9, 0xe7, 0x85, 0x76, 0xe3, 0x6c, 0x7a, 0x4b, 0xe6, 0x4b, 0x75, 0xe1, 0x6a, 0xa0,
0x7c, 0x30, 0xa5, 0x18, 0xc1, 0xb4, 0xf8, 0xc1, 0x3e, 0x13, 0x69, 0x0f, 0xc1, 0xef, 0xe2, 0x8c,
0x13, 0x0d, 0xbe, 0x09, 0x1c, 0x00, 0x8d, 0xc8, 0x95, 0x79, 0xe7, 0x18, 0xb2, 0x59, 0xc4, 0x0d,
0xba, 0xbe, 0x06, 0x3a, 0x97, 0x42, 0xd7, 0x00, 0x53, 0x49, 0x85, 0xf6, 0xb5, 0x4f, 0x6a, 0x9f,
0x81, 0xca, 0x49, 0x2d, 0xb3, 0x28, 0x81, 0x27, 0x8d, 0xec, 0x0a, 0x62, 0x95, 0xce, 0x1d, 0xf9,
0x24, 0xd5, 0x87, 0xb1, 0x82, 0x2f, 0xd5, 0x27, 0xb9, 0xbb, 0xb7, 0x36, 0x2d, 0xbc, 0xe7, 0xa7,
0xca, 0xf2, 0xaf, 0x61, 0x82, 0x3d, 0x1f, 0x05, 0x3e, 0x0b, 0x61, 0xf0, 0xd6, 0x37, 0x65, 0x61,
0xad, 0x5d, 0x4c, 0x4b, 0x3e, 0xee, 0x1e, 0xed, 0xaa, 0x28, 0x27, 0x4c, 0x89, 0x76, 0x84, 0x88,
0x46, 0xee, 0x7a, 0x9a, 0x7c, 0x66, 0x80, 0xa9, 0x0c, 0x90, 0xc9, 0x6e, 0x51, 0x33, 0x49, 0xdb,
0x2d, 0xde, 0x20, 0x03, 0xc0, 0x07, 0x31, 0x6f, 0xc6, 0x30, 0xd8, 0x3b, 0xdd, 0xe1, 0x51, 0x22,
0xb6, 0x73, 0x2a, 0x02, 0x49, 0x5e, 0xa9, 0x63, 0x4f, 0xbd, 0xb6, 0x40, 0x45, 0x79, 0x2f, 0x98,
0xd3, 0x72, 0xbd, 0x16, 0xed, 0xa0, 0x29, 0xcb, 0x08, 0xf3, 0x01, 0x48, 0x20, 0xb2, 0x9a, 0x94,
0x87, 0xf8, 0x1c, 0x26, 0x76, 0xa5, 0x96, 0x39, 0xd4, 0x12, 0xe2, 0xae, 0x8b, 0x32, 0xde, 0xcc,
0x05, 0x02, 0x76, 0x8f, 0x2b, 0x06, 0xc8, 0xfa, 0xe6, 0xd5, 0xbd, 0x79, 0x8d, 0xc3, 0x4d, 0xb4,
0x29, 0x9e, 0x24, 0x20, 0x13, 0x5c, 0xc2, 0xec, 0xc4, 0x53, 0x89, 0x6c, 0x25, 0xc0, 0xa9, 0xcc,
0xab, 0x09, 0x45, 0x6e, 0x78, 0x50, 0x2d, 0xae, 0xdd, 0x2b, 0xc7, 0xe6, 0x03, 0x15, 0xdc, 0xd6,
0x51, 0x58, 0x21, 0x50, 0xc2, 0x32, 0x98, 0x80, 0x7c, 0x37, 0x37, 0x10, 0x3f, 0x08, 0x93, 0x63,
0x5c, 0x91, 0x41, 0xe1, 0xd4, 0x6e, 0xaa, 0xaa, 0x37, 0x02, 0x42, 0xc9, 0x81, 0xad, 0x74, 0x34,
0x2e, 0x9c, 0xd3, 0x33, 0xf1, 0xe2, 0x28, 0xce, 0x9e, 0x26, 0x66, 0xdf, 0x19, 0x93, 0xea, 0x51,
0x51, 0x4f, 0x49, 0x70, 0xc2, 0x77, 0x0d, 0x28, 0xe2, 0x91, 0xf1, 0xf0, 0xe3, 0x54, 0x71, 0x42,
0x4b, 0xa7, 0xd1, 0x91, 0x15, 0x0e, 0x4e, 0x3c, 0x6f, 0x13, 0xd5, 0xc9, 0xae, 0xd4, 0x38, 0xef,
0xb1, 0x9d, 0x71, 0x58, 0x44, 0xa8, 0xdf, 0xd3, 0x2e, 0x7e, 0x2d, 0x59, 0xc2, 0x4f, 0x07, 0x6c,
0xc1, 0xc0, 0x5e, 0xcd, 0x14, 0x49, 0x88, 0x58, 0xc3, 0xa7, 0x55, 0x06, 0xed, 0x40, 0xab, 0xfc,
0x31, 0x71, 0xf3, 0x21, 0xad, 0xf4, 0xe9, 0x56, 0x59, 0x16, 0xc2, 0x19, 0xf9, 0x69, 0x67, 0x2c,
0xfa, 0xff, 0x36, 0x40, 0x79, 0x9c, 0x8f, 0xf7, 0xd8, 0xae, 0x03, 0x0b, 0x4b, 0x90, 0xad, 0x46,
0xbb, 0x90, 0x17, 0xad, 0xfb, 0xd8, 0xed, 0x87, 0xa8, 0xad, 0x9b, 0x20, 0x2d, 0xc0, 0x1f, 0x87,
0xe3, 0x8c, 0x7a, 0x34, 0x36, 0xc1, 0x33, 0x66, 0xad, 0x37, 0xd9, 0x94, 0xe0, 0x82, 0xbd, 0xca,
0xa9, 0xf5, 0xcc, 0xc0, 0xf5, 0x9a, 0xbf, 0xfa, 0x1b, 0x92, 0x39, 0x94, 0x29, 0x58, 0xd3, 0x87,
0x7c, 0x02, 0x54, 0xe0, 0x07, 0xbc, 0x3a, 0xb9, 0xd4, 0x16, 0x5a, 0x66, 0x96, 0x45, 0xe8, 0xed,
0x20, 0x2e, 0xf3, 0x60, 0x3e, 0x28, 0x1c, 0xfb, 0xd9, 0x20, 0xf2, 0x6b, 0x8c, 0x3b, 0x3e, 0x19,
0x3d, 0x3a, 0xad, 0xe5, 0xe6, 0x3d, 0x14, 0x04, 0x46, 0x39, 0xef, 0xba, 0x6f, 0x90, 0x9c, 0x3a,
0x2d, 0x34, 0x80, 0xbb, 0x8a, 0xbe, 0xe2, 0xd0, 0x9e, 0x06, 0xfb, 0xc8, 0xd6, 0x10, 0x19, 0xd3,
0x16, 0xd0, 0x3e, 0xa9, 0x7a, 0x54, 0xec, 0xa4, 0x11, 0x61, 0xbb, 0xc1, 0x16, 0x30, 0xa5, 0xe8,
0x70, 0xfb, 0x7d, 0xaf, 0x16, 0x36, 0x4e, 0xd7, 0x90, 0x2e, 0xc3, 0x80, 0x4b, 0xa0, 0xf0, 0x64,
0x4b, 0xa2, 0x6f, 0x19, 0x1a, 0x8a, 0x53, 0x86, 0xf5, 0x58, 0x81, 0xe1, 0x85, 0xc6, 0xe0, 0x7e,
0x1e, 0xf0, 0x53, 0x45, 0x52, 0x08, 0xbc, 0x42, 0xc2, 0x99, 0x4b, 0xc8, 0x7f, 0xbe, 0xb6, 0xdc,
0x80, 0xd9, 0xe7, 0x4d, 0x4f, 0x29, 0x24, 0xca, 0x5f, 0x32, 0xf7, 0x65, 0xad, 0x66, 0xf6, 0x24,
0x7e, 0x91, 0xae, 0xbc, 0xfb, 0xea, 0x8b, 0x1a, 0x8a, 0x37, 0xc2, 0x47, 0x4f, 0xe9, 0xdd, 0xcd,
0x4b, 0x10, 0x23, 0x7b, 0xee, 0x0f, 0x54, 0x09, 0x77, 0xd3, 0x67, 0xe1, 0x54, 0x20, 0x51, 0x2b,
0xfa, 0xc7, 0x9a, 0xec, 0xfe, 0x28, 0x1c, 0xc7, 0x96, 0x75, 0x8c, 0x6d, 0x07, 0xf5, 0xa2, 0xb9,
0x55, 0x74, 0xd1, 0x43, 0x5e, 0x52, 0x6c, 0xfb, 0xf1, 0xcb, 0x4a, 0x47, 0x2a, 0xe8, 0xf9, 0x5e,
0x89, 0x43, 0x51, 0x3c, 0x3e, 0xe1, 0xd2, 0xa4, 0x6e, 0xe2, 0x3f, 0x4c, 0x52, 0x17, 0x93, 0xd1,
0x2e, 0x63, 0xd4, 0x4e, 0x59, 0xd6, 0x9f, 0xa8, 0x9d, 0x2e, 0x04, 0x76, 0x06, 0x40, 0x9f, 0xe4,
0xc8, 0x11, 0xcb, 0x78, 0xf3, 0xf5, 0x66, 0xd9, 0xce, 0xe7, 0x1f, 0x43, 0x93, 0x7a, 0xca, 0xe5,
0x6d, 0x00, 0xfc, 0x18, 0xf6, 0xc4, 0xe3, 0x92, 0x2d, 0x46, 0xd4, 0x95, 0x70, 0x95, 0xae, 0x70,
0x8a, 0x78, 0xf4, 0x94, 0x74, 0x8f, 0x39, 0x8e, 0x7e, 0xdd, 0xc7, 0x69, 0x1a, 0x55, 0x77, 0xde,
0xff, 0xbb, 0x9a, 0x86, 0x43, 0x19, 0x78, 0xca, 0xbd, 0xff, 0x26, 0x88, 0xd9, 0xf7, 0x9f, 0x01,
0x37, 0xc4, 0x5c, 0xfc, 0xe6, 0x3f, 0x02, 0x01, 0x94, 0x90, 0xa4, 0xd2, 0xa2, 0xb4, 0xc0, 0x1a,
0xe5, 0x2e, 0xcf, 0x3a, 0x2e, 0x20, 0xb5, 0x40, 0xf7, 0x93, 0x82, 0x41, 0x9e, 0xfc, 0xeb, 0x02,
0xc6, 0x92, 0x07, 0xdb, 0x07, 0x3e, 0xe7, 0x8f, 0x9d, 0x2d, 0xff, 0x6d, 0x5f, 0x20, 0xee, 0x61,
0x15, 0xd8, 0xc1, 0xcc, 0xf0, 0x43, 0xdc, 0xe6, 0x70, 0xfd, 0x63, 0x76, 0xae, 0x09, 0xcb, 0x4d,
0x0a, 0x2c, 0x3c, 0x9f, 0xfe, 0xca, 0xb2, 0x5f, 0x1d, 0x37, 0xe9, 0x52, 0xcd, 0x90, 0x79, 0x45,
0x0f, 0x87, 0x3a, 0xb4, 0xd7, 0x90, 0xdd, 0x3e, 0x94, 0xf9, 0x51, 0x75, 0xdc, 0xff, 0xd9, 0xec,
0x4b, 0x6f, 0x61, 0x4d, 0xcb, 0x88, 0xf6, 0xaa, 0x78, 0xb1, 0xa1, 0xd4, 0xb1, 0xa6, 0x41, 0xdf,
0x96, 0xef, 0x16, 0x31, 0x49, 0x58, 0x7b, 0xdc, 0x94, 0x18, 0x8d, 0x15, 0xad, 0xff, 0x81, 0xa9,
0x66, 0x22, 0x12, 0x84, 0x9e, 0x59, 0xd3, 0x13, 0xcb, 0xad, 0x27, 0x3b, 0xbe, 0x2b, 0x2b, 0xaf,
0x2e, 0xfe, 0x6f, 0x73, 0x5f, 0x8c, 0xd2, 0x83, 0x5d, 0x60, 0xbc, 0x3b, 0xf5, 0x77, 0xdc, 0xe4,
0x03, 0xbe, 0xce, 0x8b, 0xf4, 0x28, 0x56, 0x53, 0x20, 0x2d, 0x7c, 0x8e, 0x66, 0x69, 0x4b, 0x12,
0xc4, 0x6e, 0xff, 0x6b, 0x6a, 0x0e, 0xba, 0x0a, 0x99, 0x43, 0xe3, 0x74, 0xf0, 0xe8, 0x5d, 0x3c,
0x32, 0x01, 0x3d, 0xf4, 0x96, 0xcd, 0x37, 0x69, 0xd3, 0x86, 0x71, 0xce, 0x58, 0xd9, 0xf2, 0x3d,
0xd8, 0x1b, 0xa0, 0x27, 0xcd, 0xd7, 0xb1, 0xcf, 0xac, 0xf1, 0x1f, 0x00, 0x8a, 0x84, 0x57, 0x1c,
0x47, 0xac, 0x31, 0x14, 0xf7, 0x06, 0x86, 0xcc, 0x4e, 0x00, 0x3e, 0x5b, 0xdf, 0x87, 0xe7, 0x98,
0x26, 0xd6, 0x90, 0xd5, 0x89, 0xa0, 0xcb, 0xa9, 0x58, 0x60, 0xfb, 0xd5, 0xc8, 0x1c, 0x85, 0x54,
0x5b, 0xf7, 0x2c, 0xde, 0xd9, 0x3c, 0xd1, 0xca, 0xfb, 0xc2, 0x71, 0x51, 0xe7, 0x91, 0xb0, 0x6d,
0x65, 0xea, 0x84, 0xd1, 0x3b, 0x4b, 0xb0, 0xd4, 0x2e, 0xe5, 0xc8, 0xcc, 0x4a, 0x0e, 0xc1, 0x73,
0x4d, 0x3b, 0x55, 0xfc, 0x96, 0xeb, 0xfa, 0x79, 0xd2, 0xe9, 0xe3, 0xfa, 0xef, 0x2c, 0x6f, 0xbf,
0x1a, 0x27, 0x4d, 0x3e, 0x35, 0x3a, 0x76, 0xbe, 0xde, 0xe7, 0x4a, 0x00, 0x5e, 0xf9, 0x7b, 0xcf,
0xb4, 0x17, 0x1e, 0xc6, 0x67, 0x5e, 0xb1, 0x65, 0xb5, 0x49, 0xba, 0xdc, 0xd3, 0x39, 0x7d, 0xab,
0x47, 0x42, 0x0a, 0xfa, 0x73, 0xb4, 0x25, 0x41, 0xbc, 0xb4, 0xfe, 0x38, 0xd1, 0xed, 0xc6, 0x64,
0x96, 0xe6, 0x61, 0x41, 0xfd, 0xfc, 0x6f, 0xd0, 0x03, 0xe9, 0x2d, 0x02, 0x06, 0xdc, 0x67, 0xf4,
0xbf, 0x8a, 0xaf, 0x0d, 0x47, 0x66, 0x77, 0xed, 0x12, 0x4c, 0x85, 0x23, 0xf7, 0xc4, 0x91, 0x8a,
0x9a, 0x18, 0xd2, 0x38, 0x8f, 0x16, 0xb4, 0xe5, 0xc1, 0xff, 0x72, 0xa6, 0x05, 0x3a, 0xa0, 0x30,
0x83, 0x78, 0x2f, 0xe4, 0x68, 0xbd, 0xbe, 0x6e, 0xce, 0x11, 0x82, 0x3c, 0x43, 0x66, 0xa0, 0xf4,
0x25, 0x59, 0xdd, 0xd5, 0x85, 0xd6, 0x0a, 0xdc, 0x0a, 0x51, 0x3c, 0xe7, 0xb4, 0x66, 0x87, 0xfe,
0x69, 0x75, 0xc1, 0x33, 0x5b, 0xce, 0x89, 0x76, 0xa8, 0x51, 0xd2, 0x6d, 0x6f, 0x07, 0x88, 0x7f,
0xe0, 0xfa, 0xbf, 0x1b, 0x00, 0x64, 0x19, 0xc1, 0x48, 0x35, 0x6f, 0x8d, 0x64, 0x9e, 0xc1, 0x5d,
0xee, 0x1b, 0xa7, 0xf3, 0xcd, 0xff, 0x40, 0x1a, 0xac, 0xd0, 0xc9, 0x76, 0xfe, 0xdf, 0xca, 0x49,
0x9b, 0xb0, 0xdd, 0x2f, 0x7d, 0x1f, 0x3c, 0x7c, 0x85, 0xf9, 0x49, 0x9c, 0x01, 0x28, 0x1c, 0xfe,
0x73, 0x5c, 0xc7, 0x3c, 0xa0, 0xeb, 0xd8, 0xc6, 0x2b, 0x80, 0xe7, 0x66, 0x57, 0xa2, 0x2c, 0xd1,
0x5c, 0x34, 0x3e, 0x66, 0xeb, 0xee, 0xca, 0x78, 0x4f, 0x96, 0xeb, 0x00, 0x5c, 0x42, 0x21, 0x7f,
0x9e, 0xee, 0xdd, 0xca, 0x5f, 0x4f, 0x46, 0x6c, 0x68, 0x5f, 0xbf, 0x6e, 0xa7, 0x38, 0x9b, 0x3a,
0xa1, 0xfd, 0xf8, 0xdd, 0xa1, 0x66, 0x12, 0x36, 0x3c, 0x81, 0xc5, 0x80, 0x9b, 0xf2, 0x52, 0x0e,
0xac, 0xf4, 0xbc, 0xc2, 0x6d, 0x48, 0x0c, 0x90, 0x41, 0xab, 0xa8, 0xce, 0xdd, 0x72, 0x3a, 0x59,
0x3a, 0x5c, 0xd4, 0xff, 0x76, 0xef, 0x05, 0x8e, 0x33, 0xf9, 0x63, 0x5c, 0x32, 0x52, 0x8a, 0xf0,
0xd3, 0x09, 0x77, 0x02, 0x34, 0x25, 0x23, 0x3c, 0x90, 0x01, 0x74, 0xdc, 0x6e, 0x78, 0x58, 0x90,
0x63, 0x4b, 0x8d, 0x38, 0x7a, 0x4a, 0x3f, 0x19, 0x4f, 0xfb, 0xdb, 0x31, 0x2c, 0xac, 0xd9, 0x84,
0x4d, 0x27, 0x4f, 0x9b, 0xdc, 0x97, 0xdd, 0xae, 0x6a, 0x97, 0xf3, 0x9e, 0xe6, 0xf2, 0xf9, 0x68,
0x68, 0xd1, 0x68, 0x4e, 0x1b, 0x78, 0xdd, 0xa6, 0xec, 0xf2, 0xe0, 0xf2, 0xa0, 0xc2, 0x74, 0xff,
0x62, 0xdd, 0xdf, 0xa0, 0x56, 0x86, 0x09, 0x89, 0x4b, 0x14, 0x61, 0x9a, 0x5a, 0x08, 0x14, 0xb2,
0xad, 0x6e, 0x5e, 0x4b, 0x55, 0x95, 0x11, 0x21, 0x8f, 0xbb, 0x01, 0xe7, 0x76, 0x18, 0x7a, 0x88,
0x0d, 0x36, 0xa4, 0x84, 0x0d, 0xbd, 0xa9, 0x1f, 0xf4, 0x78, 0x82, 0x72, 0xc2, 0x0c, 0x4c, 0xa2,
0x9b, 0x9a, 0xbe, 0xf7, 0x8e, 0xc4, 0xf1, 0xe3, 0xfe, 0xf8, 0x1a, 0x8f, 0xb8, 0xca, 0x2f, 0xb3,
0xf3, 0xb3, 0xc7, 0xfd, 0x05, 0x30, 0x1a, 0xc9, 0x03, 0x0c, 0xe2, 0x9e, 0xa3, 0x86, 0x45, 0x20,
0x78, 0x3a, 0xa4, 0xd6, 0xfb, 0xd7, 0xda, 0xe0, 0x1c, 0xe9, 0x85, 0x42, 0xa5, 0xab, 0xdf, 0x69,
0x8e, 0x45, 0xe6, 0x67, 0x0f, 0xc9, 0xd0, 0x20, 0xfd, 0xf5, 0x84, 0x00, 0xd3, 0x9c, 0xb9, 0x08,
0xe9, 0x75, 0xfe, 0xe9, 0x69, 0x79, 0x08, 0xb9, 0xc1, 0x3c, 0x46, 0x87, 0x02, 0xfc, 0x72, 0x65,
0x22, 0x2a, 0x76, 0x59, 0xcb, 0xd0, 0x70, 0xcf, 0xc7, 0xae, 0xd2, 0x34, 0x1d, 0x43, 0x8d, 0x47,
0x76, 0x10, 0x73, 0xf1, 0x84, 0x4c, 0x8d, 0x61, 0x5b, 0x42, 0x96, 0xdd, 0xa9, 0x1e, 0x47, 0x68,
0x22, 0xca, 0x3f, 0xfe, 0xb4, 0xfe, 0x80, 0xec, 0xcb, 0x1e, 0xa3, 0xbf, 0x77, 0x84, 0x04, 0x72,
0x48, 0x7a, 0xcf, 0x0a, 0xda, 0xe8, 0x24, 0xab, 0x58, 0x79, 0x3a, 0x9f, 0x33, 0x02, 0x82, 0xe7,
0x38, 0xe9, 0x31, 0x2e, 0x7a, 0x65, 0x25, 0x70, 0xfc, 0xe6, 0x93, 0x94, 0xf4, 0xfa, 0x20, 0x2a,
0xaa, 0x64, 0x85, 0xf7, 0xac, 0x7f, 0xdc, 0xc0, 0x0b, 0xa4, 0x34, 0x94, 0x33, 0xd9, 0x35, 0x35,
0x4c, 0x84, 0x55, 0x87, 0x7b, 0xa3, 0xb8, 0x55, 0x26, 0xec, 0x1d, 0x8e, 0xf6, 0x5d, 0x0b, 0x52,
0x37, 0x29, 0x69, 0x18, 0x2d, 0xcf, 0x37, 0xf9, 0x9d, 0x3d, 0x85, 0x4a, 0x81, 0xab, 0xd0, 0x2b,
0x2a, 0x0a, 0x8e, 0x17, 0xf9, 0x91, 0xfe, 0x91, 0x07, 0xfd, 0xe6, 0x2a, 0x07, 0xa1, 0x53, 0x06,
0xdf, 0x8f, 0x90, 0xb4, 0xbd, 0xfe, 0x8b, 0x93, 0xd8, 0xa2, 0x4c, 0x6a, 0xba, 0x0a, 0x6d, 0x09,
0x93, 0xb3, 0xaf, 0xd5, 0x5a, 0xad, 0xac, 0x97, 0x03, 0x1d, 0xea, 0x00, 0x1a, 0x60, 0x24, 0x6a,
0x5d, 0xcb, 0xa3, 0xd9, 0xd7, 0x67, 0xb3, 0xea, 0x21, 0x49, 0xc7, 0x14, 0x5a, 0x43, 0x68, 0xa6,
0x2e, 0xd7, 0xbf, 0x42, 0x95, 0x4c, 0x2e, 0xa6, 0x9e, 0xac, 0xf6, 0xf6, 0xb2, 0xb7, 0xe6, 0xa9,
0x3c, 0x7d, 0xd6, 0x74, 0x31, 0x7b, 0x9c, 0xab, 0x31, 0x33, 0xfc, 0xce, 0x39, 0x9b, 0x28, 0xd6,
0xd2, 0x97, 0x6c, 0xb4, 0xb4, 0x16, 0xd1, 0x9d, 0xff, 0x17, 0x0b, 0x49, 0x33, 0xec, 0x74, 0x49,
0x44, 0xa5, 0xa1, 0x24, 0x9a, 0x34, 0x77, 0x50, 0x2c, 0x4a, 0x25, 0x40, 0x64, 0xb3, 0x1a, 0x50,
0x0d, 0x0b, 0x1e, 0xca, 0xb5, 0x55, 0x68, 0x84, 0x9c, 0x4f, 0xdc, 0x68, 0xea, 0x9b, 0x58, 0x9a,
0x8d, 0x73, 0x9e, 0x82, 0xff, 0x39, 0xca, 0x76, 0x57, 0x7a, 0x7d, 0x3a, 0x71, 0x8c, 0x61, 0x5e,
0x20, 0x03, 0x58, 0xd5, 0x9f, 0x75, 0x1a, 0xec, 0xfb, 0x00, 0x81, 0x38, 0xdf, 0x0e, 0x43, 0x80,
0x05, 0xe0, 0xc9, 0xa0, 0xec, 0xe2, 0x6a, 0x5d, 0xbc, 0x46, 0xb4, 0xce, 0xf2, 0xdc, 0x3e, 0x99,
0x32, 0xd1, 0x3e, 0xf6, 0xd7, 0x88, 0x1f, 0xb8, 0x6a, 0x10, 0x2e, 0x7a, 0xd1, 0x51, 0xcb, 0xe4,
0x72, 0xd8, 0x12, 0x5d, 0x81, 0xf8, 0x66, 0x76, 0x94, 0x9f, 0x15, 0xce, 0x62, 0xa6, 0x63, 0x15,
0x85, 0x89, 0x6c, 0xbb, 0x18, 0x5d, 0xdf, 0x67, 0xdc, 0xc6, 0x23, 0xae, 0xb9, 0xa6, 0x0b, 0x65,
0xf4, 0xb0, 0xd6, 0x16, 0xf4, 0xae, 0xbe, 0x03, 0x04, 0xc6, 0xfa, 0x2a, 0x67, 0x07, 0x53, 0x0d,
0xb3, 0x9b, 0x73, 0x59, 0xa5, 0x17, 0x0c, 0x0b, 0x15, 0x25, 0xda, 0x3f, 0xe1, 0x89, 0x89, 0x09,
0xe6, 0x50, 0xec, 0x38, 0xc5, 0x4e, 0xae, 0xbd, 0xe7, 0x09, 0x7a, 0xc5, 0x3a, 0x09, 0xa5, 0xac,
0x22, 0x78, 0xca, 0x7b, 0xca, 0xe0, 0xee, 0x74, 0x61, 0xdb, 0xf5, 0xaf, 0xfb, 0x31, 0x08, 0x84,
0xb7, 0x63, 0xa6, 0x25, 0xc2, 0x0f, 0x2a, 0x6d, 0xf4, 0x4c, 0xf4, 0xae, 0x71, 0xe5, 0x9b, 0x1f,
0xd5, 0x1b, 0x76, 0x7b, 0xc7, 0xa1, 0x84, 0xdb, 0xa6, 0x4a, 0x82, 0xbe, 0x0c, 0x5d, 0xb4, 0x3a,
0x81, 0xb8, 0x75, 0x76, 0x72, 0xd8, 0xd4, 0x51, 0x86, 0x90, 0x28, 0x0f, 0xe6, 0xc8, 0xe3, 0xc3,
0xaf, 0x92, 0xa8, 0x36, 0xb2, 0x17, 0x65, 0x27, 0x87, 0xca, 0xe5, 0xdd, 0xea, 0x9a, 0x56, 0xaf,
0xf3, 0x1b, 0xa6, 0xd3, 0xbc, 0xb1, 0x60, 0xb4, 0x1c, 0xd1, 0xff, 0x6f, 0x25, 0x3e, 0x4d, 0x62,
0x14, 0x25, 0x27, 0xbd, 0x41, 0x76, 0xea, 0xeb, 0xb0, 0x01, 0xaa, 0xce, 0x4f, 0xe4, 0xd9, 0x0c,
0x6e, 0x4d, 0xe8, 0x83, 0x19, 0xf3, 0x34, 0x65, 0x47, 0x4b, 0x74, 0x91, 0x6b, 0xac, 0xcc, 0x2c,
0xe3, 0x6e, 0xef, 0x22, 0x74, 0x29, 0x9a, 0xc9, 0xe3, 0x58, 0xfa, 0xe0, 0x92, 0x0e, 0x65, 0x74,
0x58, 0x98, 0x2f, 0x61, 0x72, 0x29, 0xd3, 0x2e, 0x6d, 0x72, 0x5b, 0xc4, 0x45, 0x15, 0xd9, 0xca,
0xfe, 0x35, 0x3c, 0xf0, 0x18, 0xfc, 0xa5, 0xa9, 0x56, 0x4d, 0x80, 0xc9, 0xcd, 0xb5, 0x2c, 0x7c,
0x02, 0xff, 0x22, 0x4a, 0x1b, 0xef, 0x03, 0xe6, 0xd8, 0xfd, 0x68, 0x9d, 0x32, 0xdc, 0x92, 0x9f,
0x83, 0xef, 0xfb, 0xcc, 0xad, 0xfa, 0x27, 0x40, 0x2f, 0x17, 0x70, 0x5c, 0x0b, 0x78, 0xac, 0x5f,
0x9f, 0x72, 0xdb, 0x02, 0x24, 0xe6, 0x15, 0x1c, 0x35, 0xa3, 0xff, 0xff, 0x5c, 0xaf, 0x2e, 0x80,
0x03, 0x6f, 0x1f, 0x68, 0x35, 0x5d, 0x5a, 0xf3, 0x9e, 0x1e, 0xa5, 0x72, 0x50, 0x45, 0x43, 0x4e,
0x4a, 0x1e, 0x7f, 0x29, 0x39, 0xf7, 0xa8, 0x6d, 0x44, 0x40, 0x7e, 0x09, 0x53, 0x25, 0xb8, 0x82,
0xec, 0xa6, 0x79, 0x73, 0xf2, 0x9c, 0x57, 0xd8, 0xd6, 0x1b, 0x80, 0x84, 0x63, 0x47, 0xcb, 0xa8,
0x76, 0xd4, 0x4f, 0x18, 0xeb, 0xa0, 0xc8, 0xdd, 0xb4, 0x1d, 0xc5, 0xb0, 0x4d, 0x11, 0xaa, 0xdc,
0x94, 0x73, 0xf9, 0x33, 0x68, 0x43, 0x77, 0x71, 0x08, 0xde, 0xa1, 0x80, 0xeb, 0x42, 0xad, 0x44,
0x34, 0xf3, 0x13, 0x05, 0x7c, 0x1c, 0x9c, 0x34, 0xc6, 0xb5, 0x8f, 0xe7, 0xb3, 0xf8, 0x75, 0x0a,
0x28, 0x8b, 0x6b, 0x5f, 0xc8, 0xd5, 0x4e, 0x40, 0xfc, 0xc1, 0x20, 0xf4, 0xe9, 0x90, 0x74, 0x4c,
0x84, 0x4b, 0x10, 0xd8, 0x6f, 0xbf, 0xc7, 0x3c, 0xab, 0x3f, 0xec, 0xa2, 0xbf, 0x09, 0xf4, 0xf4,
0x35, 0xaa, 0xbb, 0x02, 0x21, 0x86, 0x83, 0xc6, 0x06, 0x9c, 0x10, 0x5c, 0x65, 0xc6, 0x06, 0x7a,
0xa7, 0xd5, 0x71, 0x2d, 0x5b, 0xc4, 0xdf, 0x70, 0xe3, 0x46, 0x81, 0x2c, 0x98, 0xd0, 0xb3, 0x72,
0x9c, 0xe4, 0xfd, 0xec, 0x69, 0x49, 0x57, 0x9c, 0xf0, 0x49, 0x55, 0x31, 0x19, 0xaa, 0xf7, 0xc8,
0x53, 0xe5, 0xb6, 0xc4, 0xd7, 0x3c, 0xab, 0xc7, 0x98, 0x4b, 0x63, 0x3b, 0xd6, 0x7f, 0x98, 0xef,
0x1e, 0x0d, 0xa8, 0xaa, 0xca, 0x79, 0xb4, 0xb0, 0x89, 0x50, 0xbf, 0x6f, 0x42, 0x9b, 0x16, 0x66,
0x86, 0xf6, 0x6a, 0x4a, 0x64, 0x9b, 0x1a, 0x9d, 0x33, 0x17, 0x2e, 0x4e, 0xdc, 0xa2, 0x7a, 0xfa,
0x17, 0xca, 0x33, 0x9e, 0xe7, 0xdd, 0x0c, 0x13, 0x3b, 0xf2, 0xc9, 0x8d, 0xc6, 0xae, 0x2d, 0x6f,
0x3e, 0xdc, 0xcb, 0x7f, 0xdd, 0xf0, 0x1e, 0x1b, 0xa3, 0xc7, 0x8f, 0x61, 0x94, 0xfb, 0x8c, 0xdf,
0xce, 0x5a, 0xac, 0x2b, 0x40, 0x98, 0x55, 0x93, 0xe8, 0xb5, 0x2a, 0x4c, 0xa0, 0x20, 0x00, 0x36,
0x2f, 0x17, 0x7f, 0x63, 0x48, 0xf6, 0xbc, 0x3b, 0xc2, 0x20, 0x17, 0x1a, 0x56, 0x3d, 0x68, 0x6d,
0xd7, 0x75, 0xd1, 0x9b, 0xf1, 0x62, 0x2d, 0xf9, 0x98, 0xe8, 0x7f, 0xf8, 0x63, 0xf8, 0x9f, 0x3c,
0x76, 0xd4, 0x91, 0x1a, 0x9b, 0x73, 0x30, 0xd8, 0xf6, 0xf5, 0x58, 0xac, 0xb4, 0x29, 0xda, 0xa1,
0x66, 0xfe, 0x1f, 0x49, 0x0f, 0x66, 0xa1, 0x4f, 0x31, 0x3b, 0x65, 0x93, 0xf8, 0x19, 0x2d, 0xe0,
0x8b, 0x79, 0xcf, 0x4a, 0x20, 0x2c, 0x52, 0x61, 0x37, 0x7c, 0xae, 0x8a, 0x52, 0xd4, 0x66, 0x50,
0xa7, 0xd9, 0x20, 0x96, 0x3f, 0xa5, 0x17, 0x31, 0x93, 0x29, 0xbc, 0xdb, 0x18, 0x6f, 0xdb, 0xc6,
0x0a, 0xa6, 0xb0, 0x0d, 0x41, 0xc1, 0x37, 0xab, 0x1e, 0xa4, 0x75, 0xe7, 0x33, 0x9d, 0x1a, 0x90,
0x29, 0x6e, 0x4e, 0x85, 0x57, 0x4b, 0x64, 0x0d, 0x7e, 0x98, 0x19, 0xa8, 0x1a, 0x84, 0xc9, 0x2b,
0xac, 0x83, 0x66, 0x28, 0x09, 0x2c, 0x8e, 0x16, 0x91, 0x13, 0xf5, 0x1a, 0x5e, 0xcc, 0xc7, 0x60,
0xfb, 0xea, 0x8f, 0xa5, 0x77, 0xf4, 0xa3, 0x31, 0xb8, 0x5f, 0x7a, 0x0a, 0xd7, 0x19, 0x13, 0x17,
0x5c, 0xc3, 0x64, 0x21, 0xba, 0x27, 0xef, 0xc9, 0xf9, 0xab, 0x51, 0x8d, 0x5a, 0x44, 0x4c, 0x79,
0x34, 0x05, 0xe0, 0xf7, 0x5b, 0xc8, 0x8e, 0xe7, 0xcf, 0x91, 0xe9, 0x35, 0x75, 0x0b, 0xc5, 0x5b,
0xad, 0xbd, 0x2e, 0xe6, 0xe2, 0x42, 0x70, 0x3d, 0x6d, 0xc4, 0x4b, 0xe1, 0x9c, 0x9c, 0x22, 0x9b,
0x9e, 0x85, 0x66, 0x85, 0x81, 0xf7, 0x3e, 0xf5, 0x59, 0x79, 0x6d, 0x2e, 0xc8, 0x80, 0x12, 0xd5,
0x53, 0xc7, 0x56, 0x61, 0xb2, 0xf9, 0x94, 0x86, 0xe3, 0xfd, 0x2b, 0x99, 0xdc, 0xeb, 0xb8, 0xeb,
0x73, 0xe0, 0xd7, 0xe2, 0xdc, 0xe8, 0x5d, 0x9e, 0x13, 0x5f, 0x66, 0x4e, 0x89, 0x4b, 0x41, 0x3d,
0xdf, 0xb8, 0x70, 0xe6, 0xce, 0xb3, 0x54, 0x91, 0xec, 0x53, 0x97, 0x6c, 0x01, 0xb2, 0xc8, 0x89,
0x9d, 0xad, 0x24, 0xfc, 0x58, 0x63, 0xc8, 0x4b, 0x39, 0xfb, 0xe4, 0x6a, 0x76, 0x9c, 0x11, 0x06,
0x37, 0x73, 0xc0, 0x35, 0x9a, 0x36, 0x62, 0x70, 0xe9, 0xb6, 0xc6, 0x9f, 0x53, 0xcf, 0x5d, 0x39,
0x13, 0x48, 0x49, 0x5c, 0xbb, 0xfd, 0x05, 0x2f, 0xb5, 0x00, 0x16, 0xe6, 0x59, 0x8c, 0x05, 0x86,
0xaf, 0x25, 0xe5, 0x4d, 0x64, 0x6f, 0x73, 0x6b, 0x8e, 0xad, 0x06, 0x37, 0x03, 0xaa, 0xa9, 0x0e,
0x39, 0x73, 0xac, 0xdd, 0x52, 0x5c, 0xea, 0x1e, 0x07, 0x6a, 0x7a, 0x58, 0x32, 0x84, 0xbb, 0x78,
0xa4, 0xa9, 0x7c, 0xfa, 0xcc, 0xa8, 0xa0, 0x10, 0xcf, 0x8c, 0xbd, 0x36, 0x34, 0x03, 0x6d, 0xe8,
0xba, 0xd5, 0x17, 0x88, 0x51, 0xb1, 0x8f, 0xd8, 0x8d, 0x4a, 0xa4, 0xf8, 0x19, 0xb6, 0x69, 0x68,
0xa8, 0x03, 0x89, 0x18, 0x99, 0xdb, 0x82, 0xd9, 0x78, 0x97, 0x6e, 0x31, 0xcb, 0xc3, 0x18, 0x8b,
0xc9, 0x2a, 0x3c, 0x4d, 0x64, 0x95, 0x88, 0x86, 0x4a, 0xca, 0xc3, 0xa5, 0x9a, 0x9b, 0xf4, 0xcf,
0x73, 0x0a, 0xb2, 0xd8, 0x33, 0x5a, 0x02, 0x84, 0xaa, 0xdd, 0x4f, 0xc6, 0xdf, 0x68, 0xca, 0xe0,
0x29, 0x73, 0x30, 0xd0, 0xe6, 0x9e, 0x5a, 0xb6, 0xb4, 0x4f, 0x09, 0xa8, 0x19, 0x3f, 0x90, 0xba,
0x73, 0x8c, 0xa5, 0xb8, 0x7d, 0xc4, 0x82, 0xb5, 0xfa, 0x3c, 0x00, 0x1b, 0xac, 0x94, 0x28, 0x89,
0x43, 0x0d, 0xbd, 0x88, 0x9d, 0xc7, 0xe4, 0xd9, 0xdc, 0x62, 0x8a, 0x5d, 0x39, 0x45, 0xa1, 0x12,
0xc9, 0xb0, 0x2f, 0x53, 0xf6, 0xd9, 0xee, 0xd6, 0x7a, 0xcf, 0x2f, 0xab, 0xdb, 0xa3, 0xec, 0x4a,
0x69, 0xa3, 0x77, 0x73, 0x84, 0x9f, 0x4b, 0x27, 0xfc, 0x01, 0xe1, 0x95, 0x92, 0xc7, 0x0c, 0x88,
0x88, 0xaa, 0x6f, 0xcf, 0x75, 0xd7, 0x1f, 0xb5, 0xb5, 0xaf, 0xca, 0x77, 0x28, 0x6e, 0xa8, 0xd1,
0x06, 0x25, 0x04, 0x32, 0xe9, 0x47, 0x28, 0x35, 0xab, 0xaf, 0x7b, 0x0b, 0x24, 0x0f, 0xbf, 0x58,
0xde, 0xb8, 0x24, 0x12, 0xeb, 0x74, 0xf9, 0x40, 0xc6, 0xcd, 0x24, 0x2d, 0x62, 0x7b, 0xbf, 0x35,
0x76, 0xf2, 0x6a, 0x62, 0xe2, 0x5a, 0x25, 0x13, 0x63, 0x52, 0x4d, 0x28, 0x55, 0x59, 0x6e, 0x14,
0x5c, 0x77, 0x0d, 0x39, 0xfd, 0x5d, 0xbe, 0xe4, 0x0f, 0x51, 0x2a, 0xc1, 0xe2, 0x04, 0x9a, 0x83,
0x6f, 0x78, 0x4b, 0x44, 0x70, 0xc2, 0x4b, 0x97, 0xae, 0xfe, 0x87, 0x85, 0xc0, 0xb8, 0x82, 0x95,
0xc3, 0x8e, 0x2a, 0x63, 0x05, 0x1a, 0x30, 0x9f, 0xcd, 0x95, 0x66, 0xc0, 0x1d, 0x37, 0x80, 0x41,
0x61, 0xe7, 0xea, 0xb8, 0x37, 0x61, 0x9b, 0x4b, 0xe8, 0xec, 0x01, 0x48, 0x3f, 0xbd, 0xfb, 0x3a,
0x0d, 0x7a, 0x2c, 0x5c, 0x27, 0xed, 0x8e, 0x14, 0xa1, 0x43, 0xd7, 0x22, 0x5e, 0xe4, 0x76, 0xe0,
0x78, 0xb3, 0x09, 0xeb, 0xf3, 0x10, 0xcf, 0x60, 0x9a, 0x88, 0xb0, 0xaa, 0xa8, 0x87, 0x0a, 0xf5,
0xd6, 0xf5, 0x42, 0xbc, 0x82, 0x89, 0x55, 0xd1, 0x03, 0x98, 0xa6, 0x47, 0x76, 0x03, 0x62, 0x5d,
0x19, 0xa5, 0x21, 0x99, 0x46, 0x12, 0x5d, 0x26, 0x17, 0xc4, 0xbe, 0x3c, 0x86, 0xac, 0xe3, 0x17,
0xc7, 0xf5, 0x5d, 0x88, 0x0f, 0x45, 0x0b, 0xf2, 0x71, 0x31, 0xe3, 0x7b, 0x15, 0xc1, 0x98, 0x51,
0xb0, 0xd2, 0xe3, 0x78, 0x50, 0x3d, 0x97, 0x55, 0x9d, 0x74, 0xc3, 0x1c, 0x47, 0x54, 0xb4, 0xb2,
0xfd, 0xe6, 0x7d, 0xa1, 0x09, 0x58, 0xe6, 0x1e, 0x99, 0xb3, 0x2d, 0xe3, 0xe7, 0x84, 0xdc, 0xd2,
0xa0, 0x92, 0x58, 0x00, 0x6c, 0x1f, 0x0c, 0xd5, 0xe1, 0x3e, 0x75, 0x77, 0x92, 0x34, 0x94, 0xac,
0x2f, 0x0c, 0xfb, 0xf8, 0x66, 0x52, 0x86, 0x61, 0xcf, 0x64, 0x13, 0xf8, 0xa0, 0x3e, 0x0e, 0xc8,
0xf0, 0xed, 0xeb, 0xa0, 0x60, 0x9f, 0x19, 0xdc, 0x3c, 0x79, 0xfe, 0x79, 0x6a, 0x96, 0x5b, 0x2e,
0x24, 0x12, 0x56, 0xc9, 0xf3, 0x66, 0x81, 0x8f, 0x50, 0xd7, 0x5c, 0x5f, 0x7a, 0x42, 0xec, 0x5a,
0xa0, 0x22, 0xc3, 0x07, 0xb5, 0x95, 0xdc, 0x3f, 0x2b, 0xca, 0x40, 0x3a, 0x23, 0xac, 0xdd, 0x1d,
0x44, 0x2b, 0xb4, 0x09, 0x3c, 0x1b, 0xd5, 0xee, 0xe0, 0xc4, 0x19, 0x57, 0x36, 0x13, 0xf2, 0x2e,
0xb8, 0xf4, 0xfd, 0xc5, 0x76, 0x69, 0xa8, 0xc9, 0x4f, 0x52, 0x40, 0x8a, 0x86, 0x71, 0xf4, 0xc1,
0x8d, 0x11, 0xcf, 0xba, 0xc7, 0x60, 0x7e, 0xc4, 0xb1, 0x96, 0xa3, 0x0d, 0xc4, 0x71, 0x69, 0x07,
0x66, 0x13, 0xa1, 0x10, 0x73, 0x98, 0xb4, 0xe8, 0xf4, 0x77, 0x39, 0xe6, 0xe2, 0x00, 0x1b, 0x1d,
0x09, 0x4a, 0x74, 0xaa, 0x62, 0xba, 0x36, 0x60, 0x83, 0xa5, 0xad, 0xfa, 0xfb, 0xac, 0xde, 0x25,
0x0f, 0x7d, 0x63, 0xc6, 0x8f, 0xa5, 0xd3, 0x52, 0xec, 0xc6, 0xde, 0x56, 0x18, 0x95, 0x3d, 0x3b,
0xdf, 0xd8, 0x0e, 0x0e, 0x89, 0xa1, 0xb0, 0xc6, 0x94, 0x02, 0x5a, 0x7f, 0x83, 0x32, 0x02, 0x1e,
0x31, 0x2e, 0x96, 0x5f, 0xb6, 0xb7, 0x39, 0x65, 0x94, 0xbc, 0xf2, 0x81, 0x7b, 0xd6, 0xc6, 0xcc,
0x7f, 0x0a, 0x26, 0x26, 0x0a, 0x9b, 0xbe, 0xa8, 0x39, 0x7d, 0xc3, 0x76, 0x33, 0x82, 0x83, 0x57,
0x8b, 0x5c, 0x25, 0xf7, 0x3b, 0xb1, 0x93, 0xa8, 0xd7, 0x72, 0x2d, 0x8e, 0xf2, 0xdc, 0x16, 0xb4,
0x37, 0x1f, 0x24, 0x2b, 0x27, 0xe2, 0x6d, 0x7c, 0xed, 0x4c, 0xde, 0x1e, 0xe7, 0x61, 0xd9, 0x1b,
0xc4, 0x78, 0xc9, 0xa2, 0x87, 0x5e, 0xed, 0xfa, 0x76, 0x5e, 0x25, 0x17, 0xd6, 0x5c, 0x61, 0xc6,
0x2c, 0x0a, 0x33, 0xfe, 0xc7, 0x47, 0xa3, 0x23, 0xa8, 0x07, 0x00, 0x0a, 0x52, 0x8a, 0xca, 0xd4,
0x7c, 0xc5, 0xe4, 0xf9, 0x79, 0x8d, 0xd8, 0x69, 0x79, 0x5a, 0x32, 0x6e, 0x19, 0x06, 0x5c, 0x22,
0xfe, 0x6e, 0xb9, 0x95, 0x07, 0x7b, 0x04, 0xdd, 0xbd, 0x09, 0x07, 0xa4, 0x86, 0x02, 0xd5, 0xcc,
0xdb, 0xef, 0xd4, 0xcb, 0x33, 0xce, 0xfd, 0x88, 0xc2, 0x36, 0x15, 0x76, 0xed, 0xe2, 0xa9, 0x23,
0xee, 0x23, 0x3e, 0xaf, 0x69, 0x0f, 0xb6, 0x43, 0x5e, 0x44, 0x3c, 0x37, 0x60, 0xe6, 0xe6, 0xe8,
0xed, 0x2b, 0x08, 0xf9, 0x63, 0x50, 0x0b, 0x86, 0x96, 0x07, 0xaa, 0xee, 0xa7, 0xae, 0x92, 0x8a,
0x5c, 0x4f, 0xdc, 0x74, 0x0f, 0xa2, 0xbd, 0x82, 0x46, 0x11, 0xbb, 0x36, 0x7d, 0x66, 0xf6, 0x88,
0x9b, 0x6c, 0x0d, 0x59, 0xcb, 0x99, 0x0b, 0xc2, 0x81, 0x88, 0xc7, 0xf3, 0x97, 0x2c, 0xae, 0x3a,
0x74, 0x3e, 0x32, 0x2b, 0x36, 0xd8, 0x43, 0xdc, 0x36, 0x07, 0x07, 0x49, 0xae, 0x36, 0x48, 0xad,
0x81, 0x76, 0xcd, 0xd4, 0xde, 0x8f, 0xb6, 0x8e, 0x8b, 0xf3, 0x3c, 0x22, 0xbf, 0xad, 0xad, 0x26,
0x9d, 0x37, 0xd7, 0xb3, 0x1c, 0x22, 0x9e, 0x4f, 0xaf, 0x86, 0x4b, 0xa6, 0x66, 0xe4, 0x3e, 0x91,
0xdb, 0xfe, 0xf0, 0x60, 0x49, 0x92, 0x83, 0x8b, 0xa2, 0x56, 0xb7, 0xac, 0x62, 0x2b, 0xfd, 0x0c,
0xde, 0x51, 0x26, 0x81, 0xf6, 0x8a, 0x8b, 0x5e, 0x41, 0xd1, 0x86, 0x48, 0x8c, 0x69, 0x44, 0x28,
0xc8, 0xdd, 0x74, 0xe6, 0xbf, 0xdf, 0x69, 0x5a, 0xcb, 0xd2, 0x0b, 0xcc, 0x84, 0x45, 0x17, 0xc7,
0x2c, 0x14, 0xf6, 0x79, 0x9d, 0xac, 0x03, 0x8f, 0x11, 0x8d, 0xf3, 0xef, 0x79, 0xa3, 0x00, 0xaf,
0xcd, 0x8c, 0x57, 0xe2, 0x0f, 0x31, 0x77, 0x9f, 0x5e, 0x59, 0xcb, 0x50, 0xd2, 0xdf, 0x36, 0x90,
0xb0, 0x9e, 0xbe, 0xf8, 0xc0, 0xac, 0xea, 0xa2, 0x8f, 0xae, 0xfd, 0x06, 0xe8, 0x19, 0x0b, 0x06,
0xec, 0x86, 0x6c, 0xd2, 0x41, 0xab, 0x60, 0x7f, 0x76, 0xb7, 0x88, 0x1e, 0xcc, 0xab, 0x5a, 0x46,
0x43, 0x4b, 0x94, 0x33, 0xa6, 0x5b, 0x5d, 0x6e, 0xb6, 0xa0, 0x78, 0x99, 0xf6, 0x15, 0xb4, 0x07,
0x71, 0xbc, 0xd1, 0x9f, 0x0e, 0xa8, 0x1e, 0xa9, 0x73, 0x60, 0x8e, 0x76, 0xe8, 0x8d, 0x01, 0x91,
0x4f, 0x18, 0x43, 0xab, 0x11, 0xe8, 0x6b, 0xa6, 0x02, 0xe3, 0x8e, 0xe4, 0xca, 0x7f, 0x79, 0x52,
0x44, 0x47, 0x05, 0x1e, 0x75, 0x72, 0x00, 0xdf, 0x0c, 0x25, 0x4d, 0xaf, 0xc7, 0x61, 0x2f, 0x76,
0x29, 0x95, 0x5c, 0x0d, 0x92, 0x67, 0xd9, 0xc7, 0x8a, 0xe8, 0x30, 0x68, 0x3e, 0x48, 0x0d, 0x17,
0x5a, 0x65, 0x70, 0xce, 0x84, 0xba, 0x23, 0x81, 0x42, 0xd2, 0x01, 0x23, 0x02, 0xf0, 0xb8, 0x2a,
0x6f, 0xa3, 0xc3, 0x97, 0x42, 0x18, 0xcd, 0xab, 0x37, 0x48, 0x55, 0x4b, 0x5a, 0x1a, 0xd5, 0x23,
0xf8, 0xe8, 0x2e, 0xc7, 0xb1, 0x05, 0x37, 0xac, 0xb7, 0x4a, 0xe9, 0xfb, 0xc2, 0xb6, 0x80, 0x82,
0x48, 0xd6, 0x71, 0xaa, 0xe8, 0x78, 0xca, 0x8b, 0x5e, 0x69, 0x5a, 0x02, 0x89, 0x5b, 0x0c, 0x67,
0x7a, 0x93, 0x05, 0x31, 0x23, 0x82, 0x4e, 0xf5, 0x59, 0xf3, 0xf4, 0xc2, 0xb1, 0x47, 0xc6, 0xd8,
0xc1, 0xcd, 0x2b, 0x4b, 0x59, 0x1a, 0xcd, 0xdd, 0x03, 0x52, 0x14, 0x28, 0x94, 0xf6, 0xdc, 0xb2,
0xfd, 0x4e, 0xa5, 0x5e, 0xeb, 0x03, 0x4e, 0x7c, 0x4b, 0x9a, 0x23, 0x4f, 0x8c, 0xb4, 0xf3, 0x7f,
0x3e, 0x84, 0x04, 0x70, 0x6f, 0x04, 0x35, 0x2a, 0x66, 0xcf, 0xab, 0x51, 0x3f, 0xef, 0xb2, 0x5c,
0xba, 0xaa, 0x88, 0xf4, 0x80, 0xb1, 0x35, 0x83, 0xdc, 0xe4, 0xb7, 0xa8, 0xe9, 0x5e, 0x08, 0x91,
0x10, 0xf9, 0x7b, 0x97, 0x54, 0x60, 0x40, 0x83, 0xc8, 0xb8, 0xa8, 0x6c, 0xc3, 0x19, 0xf2, 0xbb,
0xc6, 0xea, 0xa2, 0x5e, 0x5f, 0x56, 0xba, 0xfc, 0x46, 0x32, 0xa7, 0x78, 0x0a, 0x8e, 0x0d, 0x2f,
0x74, 0xc4, 0x76, 0x01, 0x7f, 0x01, 0x83, 0xac, 0xa6, 0x96, 0x39, 0xff, 0xe3, 0x1f, 0x63, 0x26,
0x8d, 0x33, 0xb2, 0x22, 0xab, 0x97, 0x7d, 0xcf, 0x6b, 0x88, 0x41, 0x3c, 0x70, 0x5a, 0x73, 0x70,
0x2d, 0x72, 0x9a, 0xcf, 0x0d, 0xc1, 0x03, 0x8b, 0x81, 0x43, 0xa0, 0xd5, 0xac, 0xa7, 0xab, 0xfb,
0xc4, 0x6b, 0xf7, 0x06, 0xf6, 0x4a, 0xff, 0x2f, 0xad, 0x42, 0x50, 0xa9, 0x88, 0x02, 0x98, 0xf3,
0xd2, 0x6e, 0xc6, 0xe0, 0x2b, 0xf9, 0x2b, 0x8e, 0x6f, 0x4e, 0x47, 0x85, 0xe2, 0x67, 0xfb, 0xd7,
0xb9, 0x17, 0x6c, 0x9e, 0x26, 0xde, 0x56, 0xce, 0xf0, 0x77, 0xaa, 0xe8, 0xfd, 0x9c, 0x60, 0x34,
0x92, 0x36, 0x3d, 0xfc, 0xf6, 0xc6, 0xf0, 0xbd, 0xb7, 0x59, 0x96, 0x3d, 0xdd, 0xcf, 0x93, 0x30,
0xf3, 0xed, 0x3c, 0x69, 0xa0, 0x4e, 0xa8, 0x02, 0xcf, 0x87, 0xde, 0x94, 0x23, 0x1e, 0x68, 0xe6,
0xb6, 0x4f, 0xee, 0x59, 0xdc, 0xfe, 0x1f, 0xc9, 0xff, 0x02, 0x02, 0x0b, 0x10, 0x23, 0xee, 0xde,
0xe0, 0x18, 0x79, 0x78, 0x6f, 0x0f, 0x19, 0x8c, 0x8c, 0x8e, 0x2f, 0x7f, 0x22, 0xab, 0xab, 0x37,
0x89, 0xc7, 0x4b, 0x85, 0x68, 0x66, 0xd8, 0x37, 0x23, 0x17, 0x71, 0xc5, 0x4b, 0x6d, 0xe6, 0x92,
0xe5, 0xbf, 0xbc, 0x1f, 0xa4, 0x34, 0x19, 0x70, 0x59, 0x0b, 0x47, 0x4f, 0xa5, 0x60, 0x75, 0xb2,
0xc8, 0x11, 0x28, 0x22, 0x53, 0xfd, 0x6f, 0xf0, 0x22, 0xb0, 0x5b, 0xed, 0x8b, 0xd0, 0xbd, 0x54,
0xd3, 0x0f, 0x89, 0xf7, 0xd8, 0xde, 0x14, 0x15, 0x57, 0x2e, 0xf8, 0xe9, 0x54, 0xd9, 0xde, 0x5e,
0xa8, 0x3f, 0x0e, 0xf1, 0xbe, 0x16, 0x35, 0x37, 0x11, 0xab, 0xc2, 0xaa, 0x2e, 0x29, 0x5f, 0xb2,
0x93, 0x70, 0x73, 0x10, 0x03, 0xa1, 0x4c, 0x79, 0x0d, 0xd7, 0x62, 0x18, 0x41, 0xcc, 0x6d, 0x17,
0x03, 0x5f, 0x75, 0xb0, 0x7d, 0x11, 0x18, 0x46, 0x4f, 0x3c, 0xf0, 0xdc, 0x1b, 0x28, 0xc9, 0xbb,
0x62, 0x49, 0x4d, 0xfc, 0xba, 0xae, 0xff, 0xf3, 0x12, 0x9e, 0x4c, 0x86, 0x17, 0x38, 0x2e, 0x45,
0x48, 0xc0, 0x9b, 0x27, 0x3e, 0x7b, 0x91, 0xd2, 0xa0, 0xad, 0x77, 0x69, 0x22, 0x56, 0xad, 0x0b,
0xd3, 0xc6, 0x50, 0x57, 0xd5, 0xc7, 0x57, 0x35, 0xff, 0xb5, 0x5d, 0xb4, 0xa0, 0x05, 0x31, 0xf2,
0x55, 0x50, 0x98, 0xf3, 0x99, 0xbc, 0x23, 0x66, 0x64, 0x20, 0x1b, 0xaf, 0xa3, 0xdb, 0xc7, 0xe3,
0xdc, 0xd4, 0xb3, 0x73, 0x1a, 0xf1, 0x9d, 0xd9, 0x8a, 0xab, 0x85, 0x26, 0xf9, 0xab, 0xf4, 0xec,
0xca, 0x35, 0x08, 0x0e, 0x7b, 0xca, 0xf9, 0xa9, 0xb0, 0x42, 0xca, 0x1c, 0x33, 0xec, 0x97, 0x15,
0xad, 0x28, 0x8f, 0x01, 0x50, 0xc1, 0xdd, 0xb5, 0xcc, 0xd2, 0xf9, 0xb6, 0x03, 0xf8, 0x5b, 0x41,
0xf6, 0x98, 0x55, 0xf6, 0xfe, 0xe9, 0x4a, 0x11, 0xac, 0xed, 0xc1, 0x18, 0x95, 0xeb, 0x7b, 0x7c,
0xf6, 0xc8, 0x10, 0xe5, 0xfd, 0x0d, 0x78, 0xcf, 0x73, 0x20, 0xab, 0xed, 0xad, 0x89, 0x29, 0x58,
0x7e, 0x47, 0x0d, 0x0e, 0x19, 0x2b, 0xc6, 0x93, 0x46, 0x5d, 0xb0, 0xd1, 0x73, 0x8c, 0x41, 0x0a,
0xb4, 0x38, 0x04, 0x1b, 0x14, 0x02, 0xf5, 0x23, 0x08, 0xea, 0xac, 0x2f, 0x50, 0xfd, 0x13, 0xe8,
0xb7, 0xbc, 0x4c, 0x57, 0xfa, 0x12, 0xc1, 0x47, 0x48, 0x9d, 0xe3, 0xff, 0x69, 0x35, 0x22, 0xc0,
0x47, 0x83, 0x1d, 0x25, 0x6c, 0x2c, 0x16, 0xe4, 0x0f, 0x43, 0x69, 0x7b, 0xa0, 0x4d, 0x5e, 0x53,
0x6f, 0x35, 0xcd, 0x3c, 0xcb, 0x89, 0x2f, 0x9e, 0xdf, 0x88, 0x6d, 0xeb, 0xda, 0xcd, 0x91, 0x22,
0xf9, 0xd3, 0x13, 0xb1, 0xd4, 0xfe, 0x15, 0xe2, 0xcb, 0x14, 0x5d, 0x41, 0x79, 0xce, 0xbb, 0x71,
0xb0, 0x96, 0xba, 0x07, 0x36, 0xa6, 0xe2, 0x91, 0xda, 0x19, 0xe0, 0x8d, 0x0b, 0xcb, 0x42, 0xd0,
0x6c, 0xcf, 0x44, 0xa6, 0x8e, 0x1b, 0x9c, 0x2b, 0x02, 0xdb, 0xec, 0xd0, 0x5b, 0xbe, 0x30, 0x8a,
0xd0, 0x1c, 0x61, 0x02, 0x2a, 0x9c, 0x1a, 0xc8, 0x71, 0x47, 0xa3, 0x49, 0x45, 0x92, 0x4c, 0xea,
0xd4, 0x9c, 0x96, 0xf2, 0x6c, 0xf0, 0x53, 0x63, 0xcc, 0x70, 0xe2, 0x38, 0x0f, 0xc3, 0x22, 0xd5,
0x91, 0x27, 0xc3, 0x98, 0x16, 0xb8, 0x1d, 0xbf, 0x13, 0x69, 0x77, 0x97, 0x87, 0x87, 0x23, 0xc5,
0xe1, 0x66, 0x94, 0x4c, 0x9f, 0x27, 0x32, 0x88, 0x3d, 0xef, 0xfb, 0xcc, 0x71, 0x4f, 0x24, 0xb1,
0x06, 0xdb, 0xc3, 0x88, 0x33, 0xc5, 0x47, 0xca, 0xbc, 0x16, 0x6e, 0xdc, 0x55, 0x75, 0x2a, 0xa1,
0x28, 0x73, 0xb3, 0x7e, 0xe8, 0x1c, 0x23, 0x2a, 0xee, 0x69, 0x5f, 0xf8, 0x5c, 0x79, 0x73, 0x87,
0x7f, 0x4d, 0x72, 0xba, 0x7e, 0x5e, 0xdc, 0x47, 0xba, 0xc4, 0x83, 0xd7, 0x62, 0x9c, 0x89, 0x62,
0xea, 0xbe, 0xc5, 0x45, 0xee, 0xa3, 0xde, 0x89, 0x03, 0x16, 0x1f, 0xee, 0x48, 0x94, 0x9e, 0x5a,
0xb4, 0x06, 0x70, 0x3d, 0xe0, 0x58, 0xe4, 0xd6, 0xc7, 0xf3, 0xdc, 0x31, 0xa1, 0xa2, 0x9f, 0x93,
0x41, 0x45, 0x98, 0x23, 0xc8, 0x69, 0x34, 0x9e, 0x8e, 0xf5, 0x01, 0x61, 0x4a, 0xbc, 0x94, 0xa9,
0x69, 0x40, 0xea, 0x9f, 0xa0, 0xd8, 0xb4, 0x96, 0x0d, 0xf7, 0x78, 0xd6, 0xdf, 0xdc, 0x45, 0x26,
0xfc, 0x39, 0x83, 0xde, 0xa3, 0x94, 0x27, 0xf9, 0xed, 0x72, 0xae, 0xd9, 0x40, 0x27, 0xe3, 0xc6,
0x3c, 0x69, 0x98, 0x6a, 0xd9, 0x8f, 0x4d, 0x7d, 0x71, 0xd4, 0xc8, 0x42, 0xfa, 0x37, 0xaa, 0x68,
0x7e, 0x7d, 0xab, 0x40, 0xfd, 0x8b, 0x88, 0xae, 0x4d, 0xe4, 0x0f, 0x20, 0x3e, 0x61, 0x35, 0x62,
0xe2, 0xf0, 0x19, 0x84, 0xf8, 0x77, 0x85, 0x9d, 0x9f, 0xb7, 0x5c, 0x07, 0x89, 0x80, 0x7f, 0xa6,
0x64, 0xf3, 0x33, 0xdc, 0x27, 0x8b, 0x08, 0xe6, 0xf0, 0xb2, 0xc7, 0xd1, 0x30, 0xe5, 0x72, 0xb1,
0x24, 0x6d, 0x5d, 0xcb, 0x45, 0x77, 0x7a, 0xbf, 0x61, 0x8b, 0xaf, 0xd1, 0x80, 0xf2, 0x6a, 0x63,
0xb5, 0x15, 0xe4, 0x86, 0xc5, 0xa7, 0x82, 0x28, 0x99, 0x78, 0x03, 0xcb, 0x53, 0x80, 0xf4, 0xb4,
0x7d, 0x5a, 0x26, 0x2a, 0x04, 0xb5, 0x57, 0xdf, 0x02, 0x16, 0x3b, 0xa0, 0x24, 0x39, 0xdd, 0x9b,
0xd4, 0x27, 0x3a, 0x3b, 0xd6, 0x0d, 0x6f, 0xa6, 0x8d, 0x36, 0xc5, 0x20, 0x6b, 0x5b, 0xc0, 0x68,
0xd6, 0x32, 0x29, 0x91, 0x0c, 0xbe, 0xf4, 0x50, 0xeb, 0xbf, 0xb2, 0x72, 0xa4, 0xcc, 0xcd, 0x90,
0x36, 0x56, 0xee, 0x4e, 0xd3, 0x2f, 0x22, 0x27, 0x97, 0x7f, 0xd1, 0xb2, 0x8a, 0x84, 0xce, 0xee,
0xd0, 0x57, 0xb6, 0xea, 0xf6, 0x01, 0x7e, 0x69, 0xd8, 0xcb, 0xe0, 0x91, 0xfa, 0x8d, 0xed, 0xee,
0x5f, 0xdb, 0x2d, 0xb3, 0xc8, 0x78, 0x69, 0x93, 0x35, 0x0c, 0x2a, 0x26, 0x22, 0xa8, 0x4d, 0xea,
0x95, 0x8c, 0x94, 0x84, 0x70, 0xd1, 0xfc, 0x4c, 0xbb, 0xf7, 0xca, 0xce, 0x47, 0x16, 0xa2, 0x9e,
0x49, 0x3b, 0x3e, 0x13, 0xd3, 0xf0, 0xa3, 0xc2, 0x56, 0x29, 0xb2, 0xa3, 0xee, 0x55, 0x7a, 0x42,
0x9b, 0x01, 0xd7, 0x59, 0xe8, 0x34, 0xa5, 0x6b, 0xb0, 0xf0, 0x76, 0xff, 0x59, 0xb5, 0x09, 0x47,
0x1c, 0x88, 0xd4, 0xb8, 0xec, 0x3b, 0x75, 0xf7, 0xbc, 0x13, 0x80, 0x95, 0x0c, 0x9b, 0x5d, 0x43,
0xa4, 0x59, 0xa5, 0xd9, 0x08, 0xe3, 0x39, 0x23, 0xf9, 0xb7, 0xdb, 0x60, 0xbe, 0x4d, 0xd9, 0x8a,
0x94, 0xb7, 0xb6, 0x5c, 0x5f, 0x2d, 0x02, 0xeb, 0x90, 0x31, 0x91, 0x22, 0xc2, 0x9d, 0xcf, 0xaa,
0x41, 0x31, 0xf9, 0x8b, 0x91, 0x18, 0x70, 0x36, 0xbe, 0x50, 0x10, 0x02, 0xf1, 0x56, 0x15, 0x7c,
0x18, 0x28, 0x31, 0x70, 0xed, 0x29, 0x69, 0xde, 0xb4, 0xf5, 0x35, 0x6d, 0x99, 0x38, 0xcf, 0x20,
0x18, 0xc3, 0xf4, 0x1d, 0xde, 0xdc, 0x90, 0x67, 0x61, 0xba, 0x8a, 0x45, 0xc2, 0xf9, 0xad, 0x6e,
0x41, 0x4f, 0x07, 0x75, 0xe3, 0x18, 0xb0, 0xe7, 0x4a, 0xe3, 0x03, 0xf7, 0xfe, 0x69, 0x69, 0x3b,
0xea, 0x74, 0x4c, 0xc8, 0x47, 0x9f, 0x70, 0xe9, 0x00, 0xc4, 0xce, 0xcc, 0x90, 0x73, 0x45, 0xb1,
0xe6, 0xee, 0xd5, 0x74, 0xce, 0xca, 0x39, 0x5c, 0xcd, 0x9a, 0xe3, 0x70, 0x70, 0x91, 0x5b, 0xc3,
0x49, 0x99, 0x71, 0x67, 0x7e, 0x4f, 0x37, 0xf3, 0x92, 0x75, 0xc8, 0x2b, 0x1a, 0x33, 0xf7, 0xd7,
0x6b, 0x83, 0x35, 0xac, 0xba, 0x36, 0x1b, 0x66, 0x30, 0xee, 0x66, 0x8b, 0xeb, 0x82, 0xc7, 0x1d,
0x9c, 0xdf, 0xeb, 0x2c, 0x60, 0x4c, 0xb5, 0x41, 0xe0, 0x3e, 0xe3, 0xeb, 0x79, 0x57, 0x0a, 0x1c,
0x02, 0x05, 0xba, 0xc0, 0xcd, 0x78, 0x60, 0xa3, 0x87, 0x99, 0x65, 0x04, 0x3b, 0x62, 0x01, 0x06,
0x7f, 0xe0, 0xe9, 0x36, 0x25, 0xf9, 0x97, 0x1b, 0x77, 0x33, 0x97, 0xdc, 0x12, 0x42, 0x50, 0xe5,
0x95, 0xb5, 0x7e, 0xf2, 0x70, 0xb3, 0x06, 0x60, 0x7f, 0xd7, 0x5e, 0xc6, 0xff, 0x73, 0x22, 0x03,
0x6b, 0xc7, 0x05, 0x98, 0x5b, 0x7e, 0xc5, 0x54, 0xaf, 0x9d, 0xe5, 0xa1, 0xc9, 0x64, 0xca, 0x43,
0xca, 0xec, 0xfa, 0x74, 0xaa, 0x50, 0x82, 0x68, 0x8c, 0xd1, 0x01, 0x60, 0x02, 0xce, 0x97, 0x09,
0x7e, 0x3a, 0xc3, 0x6b, 0x8a, 0x67, 0x91, 0x34, 0x06, 0xbc, 0xc5, 0x3e, 0xf9, 0x7e, 0xe6, 0xdd,
0x84, 0xa8, 0xbc, 0xc4, 0x5c, 0xcc, 0xb4, 0xaa, 0xd0, 0xe1, 0x06, 0xc1, 0x9d, 0x06, 0xdd, 0x4a,
0xa1, 0x39, 0x30, 0x02, 0xe8, 0xfc, 0x40, 0x85, 0x96, 0x10, 0x14, 0x14, 0x54, 0xc9, 0x9e, 0x9c,
0x5b, 0xe8, 0x13, 0x2e, 0xaa, 0x93, 0x71, 0xde, 0xb3, 0x71, 0xbf, 0x6a, 0x12, 0xac, 0x26, 0x70,
0x55, 0x62, 0x04, 0x49, 0x2e, 0x05, 0xbc, 0x57, 0x1c, 0xa9, 0xe6, 0x57, 0xdc, 0x9a, 0xea, 0x92,
0x76, 0xe9, 0x4a, 0x5e, 0x09, 0x0f, 0x2e, 0xd1, 0x0d, 0xc2, 0x54, 0xf3, 0x14, 0xcb, 0x8b, 0xe3,
0x05, 0x0a, 0xdd, 0x2e, 0xeb, 0x7e, 0x2b, 0x2c, 0xb0, 0x53, 0xf1, 0xd2, 0x2c, 0x76, 0x6a, 0xa9,
0x06, 0x77, 0x15, 0x70, 0x9a, 0x71, 0x0d, 0x3a, 0x27, 0x1b, 0x00, 0x09, 0x35, 0xeb, 0x07, 0x74,
0xb3, 0x1c, 0x77, 0x77, 0x5c, 0xc8, 0xe3, 0xe5, 0xb1, 0xa9, 0x35, 0x69, 0xc9, 0x49, 0xad, 0xeb,
0xbb, 0x52, 0x50, 0x8c, 0x03, 0x6f, 0x40, 0x20, 0xc0, 0xdd, 0xbe, 0xe8, 0x60, 0x23, 0xdc, 0x2c,
0x69, 0x35, 0x8a, 0xfa, 0x4a, 0x40, 0xee, 0xf6, 0xc0, 0xd7, 0xce, 0x54, 0x4a, 0x99, 0x81, 0x81,
0xef, 0x95, 0xec, 0x1b, 0x1d, 0xd5, 0xcf, 0xf2, 0xf2, 0xd3, 0xa2, 0x93, 0x84, 0xa9, 0x36, 0xd9,
0x1a, 0x41, 0xff, 0xe8, 0x25, 0xfd, 0xf8, 0x49, 0xef, 0xb1, 0x1a, 0xf3, 0x54, 0x31, 0xcf, 0x4e,
0xc7, 0x12, 0xbc, 0xac, 0xa2, 0x98, 0xa9, 0x7a, 0xa9, 0x47, 0x65, 0x0e, 0xf0, 0x29, 0xc5, 0xf3,
0x2c, 0x90, 0x20, 0x29, 0xcc, 0x28, 0x9c, 0x02, 0x22, 0x2d, 0x07, 0xab, 0x30, 0xfd, 0x52, 0x0b,
0xde, 0x85, 0x00, 0x01, 0xdf, 0x8a, 0x2d, 0x22, 0xcb, 0x7e, 0xce, 0xe0, 0xf3, 0x12, 0x19, 0x14,
0x78, 0x88, 0x19, 0x3e, 0x11, 0x66, 0x22, 0x00, 0x20, 0x85, 0x98, 0xa2, 0xd3, 0x92, 0x56, 0x68,
0x6e, 0x44, 0xc2, 0xc2, 0x2e, 0x56, 0x1c, 0x3e, 0x47, 0x87, 0x95, 0x6c, 0xe4, 0x11, 0xea, 0xf6,
0x0b, 0x84, 0x2f, 0xce, 0x0f, 0x62, 0x00, 0xa5, 0x4a, 0x5d, 0xda, 0x68, 0x66, 0x20, 0xe5, 0x24,
0xaf, 0x08, 0xe0, 0x6f, 0xdd, 0xa5, 0xc1, 0x62, 0x11, 0x27, 0x0f, 0xd4, 0x88, 0x8f, 0x4e, 0x9c,
0xfc, 0x52, 0x41, 0x93, 0x93, 0x43, 0xcf, 0xec, 0x73, 0x0a, 0x26, 0x7d, 0x9e, 0x1d, 0x16, 0xc5,
0xf6, 0x4d, 0x24, 0x3c, 0xdd, 0x5f, 0x4d, 0x14, 0xb7, 0x90, 0x63, 0xa9, 0x59, 0x57, 0x66, 0x81,
0xd5, 0x29, 0x09, 0x8d, 0x9d, 0x08, 0xf2, 0xbe, 0xb2, 0xe2, 0xed, 0x09, 0xda, 0x2b, 0x4a, 0x86,
0xbf, 0x85, 0xb7, 0x5c, 0x91, 0x38, 0x32, 0x4c, 0xcc, 0x26, 0x72, 0x97, 0xa9, 0xcb, 0x50, 0x75,
0x52, 0xc4, 0x99, 0x75, 0xef, 0x04, 0x9e, 0xf0, 0xff, 0xe8, 0x11, 0xcd, 0x85, 0x3b, 0xfb, 0x98,
0xcb, 0x65, 0x4a, 0xe3, 0x3d, 0xf6, 0x05, 0x67, 0x72, 0x5e, 0x24, 0xb2, 0x89, 0x0e, 0x19, 0xc9,
0xeb, 0x4e, 0x34, 0xc6, 0xc6, 0xe5, 0xc2, 0x93, 0xca, 0x1c, 0xc4, 0x47, 0x2b, 0x21, 0xe6, 0x5b,
0x0d, 0x0d, 0x38, 0xb1, 0xbd, 0xd4, 0xe1, 0x38, 0xce, 0x53, 0xcc, 0xa8, 0xf3, 0x2a, 0x16, 0x55,
0x10, 0x77, 0xe1, 0xe9, 0x63, 0xdd, 0xe0, 0xd0, 0xd2, 0xff, 0x87, 0x21, 0xca, 0x09, 0xd9, 0xd1,
0xc6, 0x35, 0x24, 0x26, 0x22, 0xdf, 0xc0, 0xe6, 0x7f, 0xe7, 0x33, 0xbf, 0x7b, 0x54, 0x98, 0x7b,
0x88, 0x3c, 0x3a, 0x0c, 0x1e, 0x9f, 0x39, 0x02, 0xc1, 0xce, 0x06, 0xbe, 0x2e, 0xb7, 0xb6, 0x21,
0xe6, 0x4b, 0xb4, 0x65, 0x3a, 0x77, 0xe3, 0xca, 0xe0, 0x83, 0x75, 0xd4, 0x5d, 0xbc, 0x77, 0x24,
0x69, 0x9b, 0xd4, 0x77, 0x23, 0x49, 0x0e, 0x9a, 0xf3, 0x26, 0x9d, 0xa9, 0x31, 0x81, 0x0d, 0xba,
0x94, 0x58, 0x9a, 0x82, 0x8a, 0x4e, 0x6a, 0x65, 0x90, 0xbf, 0x4a, 0x85, 0x51, 0x65, 0x3a, 0x1d,
0xac, 0xbf, 0x39, 0x11, 0xf6, 0xe2, 0x1f, 0x6c, 0xeb, 0x96, 0xde, 0x7a, 0x59, 0x83, 0x6d, 0x8f,
0x3b, 0xd5, 0xb9, 0x54, 0x5a, 0x05, 0xe7, 0x11, 0xd8, 0x52, 0x12, 0x2e, 0xf5, 0x44, 0x99, 0x55,
0xf7, 0xcd, 0xb8, 0x37, 0x16, 0xa7, 0xaa, 0xc0, 0x9a, 0x64, 0x44, 0x1e, 0xd7, 0x48, 0x40, 0x52,
0xdd, 0xcc, 0x99, 0x98, 0x33, 0x06, 0xe7, 0xec, 0x00, 0x91, 0x81, 0x48, 0x27, 0xdf, 0xb2, 0xe1,
0xfd, 0x87, 0x22, 0x66, 0x81, 0xde, 0x0b, 0xcd, 0xb2, 0xaf, 0x8c, 0xaf, 0xd4, 0xe6, 0xc9, 0xb9,
0xd9, 0xb9, 0x16, 0x84, 0xcb, 0xb3, 0x65, 0xb9, 0x6c, 0x00, 0xcb, 0x31, 0x22, 0x36, 0xa9, 0x1a,
0xfb, 0xf7, 0x3a, 0xd2, 0x70, 0xf7, 0x97, 0x63, 0xbf, 0x35, 0x8c, 0x17, 0xd7, 0x10, 0x05, 0x32,
0xfe, 0x80, 0xd9, 0x04, 0x02, 0x1a, 0xc9, 0xb1, 0xcf, 0xa6, 0x26, 0x0e, 0x99, 0xf8, 0x6c, 0x32,
0x27, 0x2f, 0xac, 0xf2, 0x17, 0x95, 0xcf, 0x11, 0x97, 0x10, 0x26, 0x17, 0xe8, 0x78, 0xc2, 0xaf,
0x3a, 0x53, 0x71, 0x96, 0x41, 0x55, 0x6a, 0xdc, 0x9a, 0xbc, 0x57, 0x5c, 0x5a, 0x10, 0x97, 0x50,
0xa4, 0x08, 0x4c, 0x21, 0x6c, 0x95, 0xfa, 0xff, 0xdd, 0xf8, 0xd2, 0xf0, 0x6d, 0x6d, 0x24, 0x19,
0x9a, 0x42, 0x0a, 0xe8, 0xef, 0x90, 0xf7, 0xb0, 0xe0, 0xfa, 0xbe, 0xf8, 0xf1, 0x47, 0xff, 0xe6,
0x23, 0x23, 0x97, 0x42, 0xde, 0x35, 0x89, 0xf0, 0xd2, 0x1b, 0xee, 0x1f, 0x2c, 0xd1, 0xb1, 0x85,
0xbf, 0x1a, 0x08, 0x15, 0xc1, 0x7e, 0xcc, 0x85, 0xc2, 0xec, 0x50, 0x8c, 0x97, 0xe4, 0xf7, 0x5d,
0x0a, 0x39, 0x00, 0x57, 0x56, 0x0f, 0x35, 0x0b, 0x7d, 0x8d, 0x68, 0x32, 0x85, 0x70, 0x55, 0x83,
0x9a, 0x31, 0x62, 0x25, 0x01, 0xb2, 0xc6, 0x54, 0xbc, 0xf0, 0x98, 0xdd, 0x78, 0xe9, 0xa1, 0x6c,
0x8e, 0x2c, 0x74, 0x17, 0xe9, 0xec, 0x0e, 0x7b, 0x64, 0xa0, 0x70, 0xe7, 0xab, 0x12, 0xf0, 0x5f,
0xa6, 0x7d, 0x9b, 0xa6, 0x86, 0xbc, 0x4c, 0x22, 0x88, 0x11, 0x54, 0x53, 0x6a, 0x55, 0x09, 0x7f,
0xd9, 0xab, 0xaf, 0x2e, 0x29, 0xa3, 0xc0, 0x75, 0xbe, 0x67, 0x8e, 0x49, 0x1c, 0xb5, 0x59, 0x85,
0xbf, 0xfe, 0x68, 0x84, 0x75, 0xf5, 0xa6, 0xd1, 0xe5, 0x29, 0xd9, 0x43, 0xf6, 0xc2, 0x8a, 0xd8,
0xe8, 0xfa, 0x14, 0x4f, 0x71, 0xa7, 0x24, 0x5a, 0xff, 0xe8, 0x01, 0x50, 0x5e, 0x37, 0x00, 0x96,
0xbf, 0x17, 0xf6, 0x17, 0xce, 0x18, 0xd0, 0x25, 0x07, 0x6a, 0x8a, 0x51, 0xd4, 0x4a, 0xde, 0x16,
0x10, 0x83, 0x1f, 0x68, 0xcf, 0xe6, 0xcb, 0xea, 0xe0, 0x8d, 0x43, 0x46, 0x41, 0x7c, 0xf2, 0x40,
0xcb, 0xa8, 0x79, 0x00, 0xe5, 0xec, 0xb3, 0x4d, 0x74, 0x7f, 0x3e, 0xee, 0xee, 0x70, 0x33, 0xfc,
0x94, 0x6c, 0x08, 0x8a, 0xb2, 0x75, 0x74, 0x3e, 0xc7, 0x90, 0xd2, 0xdd, 0x4a, 0x5d, 0x51, 0x5b,
0xa5, 0x3a, 0xb4, 0x4b, 0xd9, 0xf4, 0xf0, 0xe5, 0xc5, 0x54, 0x74, 0x16, 0x03, 0x99, 0x0b, 0x92,
0x4a, 0x91, 0x93, 0x29, 0x83, 0x9c, 0x89, 0x41, 0xb0, 0x88, 0x5c, 0x10, 0x55, 0xda, 0x32, 0x2c,
0x07, 0x37, 0x4a, 0xee, 0x4b, 0xc2, 0xaf, 0x42, 0x7b, 0x68, 0x7e, 0xc3, 0xe1, 0x2c, 0x1f, 0x81,
0xf2, 0xee, 0xea, 0x89, 0x4a, 0xf4, 0x9c, 0x60, 0x75, 0xea, 0x90, 0x0a, 0x7f, 0x89, 0x7e, 0xbd,
0x05, 0x6e, 0x81, 0xc1, 0x9c, 0x8d, 0x65, 0xa0, 0x52, 0xb5, 0xc4, 0x74, 0x97, 0x47, 0xff, 0x55,
0x85, 0x8c, 0x78, 0x99, 0xb7, 0x32, 0xda, 0x11, 0x7a, 0xf4, 0x4f, 0x29, 0xd9, 0x3f, 0x51, 0x82,
0xac, 0xdb, 0x5e, 0x1a, 0xef, 0x9b, 0xbf, 0x97, 0xad, 0x0c, 0x42, 0x2e, 0xe2, 0x17, 0x52, 0x25,
0xa9, 0x2d, 0xcb, 0xa4, 0x0a, 0x2f, 0xb7, 0xe0, 0xe4, 0xdc, 0xab, 0xe0, 0x4d, 0x88, 0xf3, 0x00,
0x15, 0x52, 0x2e, 0x4d, 0x52, 0xe1, 0xe0, 0x84, 0x61, 0xcd, 0x78, 0x42, 0x38, 0x2e, 0xa2, 0x57,
0xc5, 0x56, 0x7c, 0x5e, 0x90, 0xfa, 0x77, 0xa3, 0x0c, 0x86, 0xc1, 0x2b, 0x8e, 0x2a, 0x80, 0x64,
0x69, 0x10, 0xcb, 0x0e, 0x09, 0xd6, 0x40, 0x60, 0x28, 0x76, 0x01, 0x18, 0xb0, 0x7f, 0xf6, 0x30,
0x5f, 0x04, 0x2c, 0x51, 0x01, 0xfa, 0xc1, 0x3a, 0x07, 0x60, 0x52, 0x44, 0xfe, 0xc9, 0x69, 0xcd,
0x52, 0x5a, 0xa8, 0x1d, 0x67, 0xc6, 0xee, 0x79, 0x98, 0x5a, 0xff, 0x80, 0x5b, 0x3a, 0x57, 0x49,
0xfa, 0x18, 0xf6, 0x6d, 0x51, 0x15, 0xc6, 0x0e, 0xb9, 0x35, 0xff, 0x88, 0xef, 0xa9, 0x4f, 0xf5,
0x0f, 0x87, 0x5a, 0x58, 0x30, 0x3e, 0xde, 0xee, 0xff, 0x06, 0x7b, 0xa6, 0x20, 0x24, 0xd6, 0x12,
0x4c, 0x3f, 0x1d, 0x3d, 0x4d, 0xc9, 0xd9, 0x23, 0x4d, 0x18, 0x92, 0xf7, 0xa8, 0x45, 0xb0, 0x18,
0x47, 0x66, 0xd1, 0x30, 0x0d, 0x8d, 0x14, 0x6c, 0xdd, 0xf8, 0x34, 0x05, 0x25, 0x11, 0x1e, 0x3b,
0xf6, 0xb2, 0xe1, 0xdf, 0x77, 0xba, 0xd1, 0x82, 0x2d, 0xe7, 0xc2, 0x92, 0x38, 0x6e, 0xda, 0x53,
0xa3, 0xba, 0x92, 0x3e, 0x55, 0xd8, 0x6a, 0xf0, 0xfa, 0x88, 0x4c, 0x1f, 0xaf, 0x73, 0x59, 0x33,
0x88, 0xa5, 0xe8, 0xe5, 0x85, 0x4f, 0x4d, 0x93, 0x1c, 0x89, 0x88, 0x71, 0xff, 0x47, 0x0b, 0xf8,
0xfb, 0x20, 0x44, 0x26, 0x57, 0x01, 0x45, 0x08, 0xf5, 0x4a, 0x51, 0x67, 0x4a, 0xc7, 0xe4, 0x4d,
0xd6, 0x93, 0x42, 0x6b, 0x90, 0x0b, 0x09, 0x18, 0x02, 0x23, 0x5b, 0x05, 0x45, 0x0e, 0xda, 0x57,
0xc1, 0xa8, 0x7b, 0xe4, 0x98, 0x80, 0x12, 0x2d, 0x11, 0xaf, 0x8c, 0x0c, 0xb9, 0xb2, 0x2f, 0xf5,
0xad, 0xce, 0x4c, 0x3a, 0x0a, 0x32, 0x67, 0x87, 0x1c, 0x85, 0x57, 0x1d, 0x4a, 0x26, 0x52, 0xe6,
0x89, 0xef, 0x75, 0x19, 0x08, 0x9d, 0x05, 0x9d, 0x08, 0xa9, 0xc0, 0x15, 0x39, 0x98, 0x44, 0x71,
0x35, 0xa3, 0xe2, 0x94, 0x37, 0x00, 0x11, 0x6d, 0xed, 0x20, 0x83, 0x51, 0x21, 0xd1, 0x60, 0x94,
0xe8, 0x41, 0x91, 0x8a, 0x4b, 0xc7, 0x80, 0x2d, 0x46, 0xfe, 0x57, 0xed, 0x5c, 0x37, 0xeb, 0xaa,
0x8a, 0x73, 0x64, 0xd6, 0xa3, 0x9d, 0x6b, 0x7f, 0x57, 0xf0, 0x2d, 0xae, 0xfb, 0x11, 0x62, 0x6a,
0x61, 0x5a, 0x48, 0xa5, 0x07, 0xb1, 0x4d, 0x79, 0x40, 0x5c, 0x34, 0x2d, 0xcc, 0x87, 0xbb, 0xcd,
0xe5, 0x7f, 0xa6, 0x09, 0xcd, 0x90, 0xdb, 0xf6, 0xdc, 0x3a, 0xa7, 0xa4, 0x20, 0x9c, 0x3f, 0x4c,
0x24, 0x10, 0x7c, 0x75, 0x35, 0x10, 0x4a, 0xc5, 0x6f, 0x2e, 0xc4, 0x98, 0x84, 0x0d, 0x86, 0xf3,
0xc6, 0xb1, 0x4a, 0x54, 0xac, 0x08, 0x6e, 0x13, 0xd2, 0xbe, 0x14, 0x39, 0xb9, 0xa9, 0x4f, 0xb9,
0x85, 0xbf, 0xf5, 0x18, 0x4b, 0x4f, 0x26, 0x2a, 0x39, 0x50, 0xf5, 0x01, 0x58, 0x8a, 0xbd, 0x22,
0xd0, 0x29, 0xa6, 0x53, 0x40, 0xc0, 0x73, 0xdc, 0xd9, 0x03, 0x6a, 0xfd, 0x57, 0xdc, 0x2b, 0x4b,
0xd0, 0xe7, 0x4c, 0xed, 0xa7, 0x2a, 0x88, 0x37, 0x4f, 0x75, 0x43, 0x8b, 0x5e, 0xae, 0x1c, 0xc5,
0xad, 0xbb, 0xbe, 0x43, 0x59, 0xc4, 0x5d, 0xa1, 0x1f, 0xb0, 0xbb, 0x71, 0xb5, 0x13, 0x74, 0xce,
0x0b, 0x62, 0x36, 0x66, 0x9d, 0x0d, 0xe5, 0x5a, 0x34, 0xd1, 0x6d, 0xec, 0xab, 0x92, 0x7c, 0xf1,
0xed, 0x5c, 0xe5, 0x61, 0x14, 0xf5, 0x72, 0xe5, 0xbf, 0x92, 0xc2, 0xb3, 0x3a, 0x82, 0xcb, 0xef,
0xa0, 0xbf, 0xa7, 0x88, 0x06, 0x6a, 0x20, 0x9d, 0xb8, 0x04, 0xb1, 0x52, 0x5f, 0x7f, 0x16, 0x74,
0x98, 0xbe, 0xf6, 0x02, 0x0c, 0x42, 0x91, 0xaf, 0x8d, 0x1e, 0x24, 0x19, 0x04, 0x27, 0x2b, 0x8a,
0x73, 0xb5, 0x7a, 0x61, 0x86, 0x4b, 0x1d, 0xa2, 0xff, 0xe9, 0xe9, 0x04, 0x50, 0x04, 0x22, 0xa6,
0xe1, 0xa2, 0xa6, 0xfd, 0xc5, 0x87, 0xbf, 0x2e, 0xab, 0x92, 0xc4, 0xf1, 0xf5, 0x9d, 0xe8, 0xfa,
0x67, 0x3a, 0xb1, 0x75, 0x38, 0x76, 0x2c, 0xce, 0x4a, 0x55, 0xc5, 0xa9, 0x0b, 0x91, 0x72, 0x40,
0x78, 0x61, 0x87, 0xb1, 0x3d, 0x85, 0xfc, 0x59, 0x5f, 0x80, 0x9b, 0x9d, 0xc8, 0x07, 0x93, 0x4a,
0x61, 0x7f, 0xed, 0xaa, 0x01, 0x2d, 0x2d, 0x5b, 0x49, 0xf6, 0xa9, 0x91, 0x6c, 0xda, 0x67, 0xe5,
0xcb, 0x64, 0xc5, 0x12, 0x14, 0xa4, 0x6e, 0x04, 0x68, 0xa9, 0xe2, 0xc2, 0x58, 0xe8, 0x95, 0xe5,
0x35, 0x73, 0xbf, 0x85, 0x09, 0x21, 0xb9, 0xd3, 0x57, 0xda, 0xb7, 0xa5, 0xfe, 0x12, 0x7f, 0xf4,
0xa5, 0x75, 0x03, 0xe5, 0x6b, 0x1a, 0x4e, 0x10, 0xcc, 0x06, 0x6e, 0x7f, 0xac, 0x14, 0x8b, 0xdd,
0xa7, 0x52, 0xa5, 0xfb, 0xc7, 0x5c, 0xe5, 0x3c, 0x6d, 0xd8, 0xf4, 0xaa, 0x28, 0x42, 0xb3, 0x78,
0x2c, 0x37, 0x00, 0x3e, 0xb2, 0x12, 0x44, 0x91, 0x43, 0xa0, 0xe4, 0xcc, 0x3a, 0x46, 0xa4, 0x69,
0xe8, 0x41, 0xb5, 0xee, 0x1e, 0xbb, 0x24, 0xa3, 0x2f, 0xf8, 0x8c, 0x02, 0x90, 0xae, 0x05, 0xb4,
0xd5, 0xaa, 0x76, 0x5b, 0x66, 0x5e, 0x3e, 0x45, 0x0e, 0x6a, 0xd6, 0xbd, 0x5c, 0xab, 0x7a, 0xb8,
0x71, 0xa1, 0xf5, 0xf0, 0x96, 0xc7, 0xa6, 0x1b, 0xf7, 0x71, 0xbc, 0xa6, 0x71, 0x10, 0x9f, 0x35,
0xca, 0x1d, 0xf6, 0x24, 0x22, 0x49, 0xd5, 0xdc, 0xbf, 0x35, 0x01, 0xc4, 0x69, 0xce, 0x31, 0x72,
0x38, 0xee, 0x05, 0x18, 0x75, 0xcd, 0xed, 0x40, 0xd7, 0x14, 0xa3, 0x53, 0x74, 0x47, 0xc6, 0x40,
0x60, 0x5c, 0x34, 0x1a, 0x98, 0x31, 0x37, 0xa7, 0x5e, 0x21, 0x20, 0xaf, 0x9e, 0xc8, 0x59, 0x54,
0x2a, 0xde, 0x34, 0xc4, 0x3a, 0x9d, 0x66, 0x64, 0x8b, 0x1f, 0x1d, 0x4a, 0xad, 0x6b, 0xb1, 0x7e,
0x8c, 0x17, 0x18, 0x4d, 0x41, 0x32, 0x68, 0xf8, 0x44, 0x0d, 0x7f, 0x21, 0x77, 0x95, 0x09, 0x70,
0xc3, 0xe3, 0xe3, 0xf8, 0x01, 0xe3, 0xa4, 0xdd, 0x53, 0x96, 0x1b, 0x2e, 0xcd, 0xd3, 0xc3, 0xf1,
0x5c, 0xdf, 0xf9, 0x78, 0xd5, 0x2b, 0xfc, 0x6f, 0xbe, 0xe8, 0x3f, 0x64, 0x2b, 0xc1, 0xd9, 0xf7,
0xc3, 0xad, 0xad, 0x44, 0x55, 0xa4, 0xac, 0xab, 0xfa, 0xe8, 0x39, 0xd7, 0xd3, 0xfa, 0x28, 0x7f,
0x7f, 0xca, 0x98, 0xbf, 0x2a, 0xe6, 0xef, 0xd0, 0x4d, 0xb4, 0x52, 0x5b, 0x34, 0x38, 0x8f, 0x96,
0xa3, 0x76, 0x4d, 0x73, 0x43, 0xe9, 0x1d, 0x36, 0x2b, 0xc4, 0xb3, 0x0b, 0xe8, 0x4c, 0xb2, 0xca,
0x5a, 0x00, 0xdf, 0x84, 0x83, 0xaf, 0x74, 0xfe, 0xe4, 0x17, 0x00, 0x28, 0xe8, 0xb4, 0x51, 0x0d,
0xc0, 0xb8, 0x32, 0xbb, 0xc0, 0xb0, 0xd7, 0x8b, 0x95, 0x82, 0xe4, 0xf2, 0x30, 0xac, 0x80, 0x5e,
0x07, 0xe5, 0xe7, 0x33, 0x6c, 0xc4, 0xd2, 0x25, 0xe7, 0x73, 0x7c, 0x33, 0xe8, 0x2e, 0x47, 0xca,
0x90, 0x72, 0x4d, 0x58, 0xad, 0x09, 0xbb, 0x69, 0x19, 0x64, 0x08, 0xd9, 0x0c, 0xdc, 0x13, 0x47,
0x8b, 0xe3, 0x0d, 0x83, 0xcc, 0x32, 0x8f, 0xf5, 0x53, 0xec, 0x6f, 0xe9, 0xa7, 0xa3, 0x48, 0x92,
0x91, 0x4b, 0xe2, 0xc0, 0x5f, 0x0e, 0xe2, 0x4b, 0xd0, 0xaa, 0x33, 0x05, 0x5f, 0x88, 0x77, 0xc0,
0x5c, 0x06, 0xa3, 0x2f, 0x4e, 0x7d, 0x9e, 0xbf, 0x10, 0x18, 0x68, 0x74, 0x54, 0x09, 0xb0, 0x52,
0x21, 0x72, 0x1c, 0x6b, 0x6f, 0x22, 0x9c, 0x7c, 0xe8, 0x0b, 0x98, 0x1a, 0x96, 0x0a, 0xd4, 0xd4,
0x5a, 0x08, 0x3c, 0xf9, 0x93, 0x2c, 0xde, 0x49, 0x3d, 0xed, 0xe4, 0x7a, 0xeb, 0x31, 0x51, 0x47,
0xa9, 0xcd, 0xd5, 0x1d, 0xaa, 0x8e, 0x95, 0x03, 0x2c, 0x7e, 0xd3, 0x24, 0x1c, 0x4d, 0xeb, 0x5d,
0xda, 0x57, 0x6e, 0xb0, 0x5a, 0xf2, 0x1a, 0x2a, 0x78, 0x5c, 0xcf, 0x3c, 0xc0, 0xe1, 0x2d, 0x2b,
0xb3, 0xe6, 0xde, 0x25, 0x0f, 0x61, 0x5a, 0x9a, 0x88, 0xba, 0x91, 0x0d, 0xd1, 0x63, 0x96, 0x20,
0x59, 0xa0, 0xe8, 0x14, 0x40, 0x42, 0x3f, 0xa5, 0x4b, 0xf1, 0x0e, 0xc0, 0xa1, 0x7f, 0x92, 0xd6,
0x89, 0xd6, 0x64, 0x12, 0x31, 0x75, 0xb5, 0x82, 0x82, 0xab, 0xba, 0xbd, 0xdf, 0x0d, 0x7e, 0x53,
0x39, 0x84, 0x8d, 0x8c, 0x2e, 0xa6, 0xc3, 0xa4, 0x3c, 0x68, 0x5a, 0x8c, 0xff, 0x47, 0xca, 0xca,
0x27, 0x43, 0x5a, 0x7b, 0x0b, 0xbe, 0xff, 0x02, 0x7d, 0x42, 0xe6, 0x44, 0xb5, 0x73, 0xdc, 0xa9,
0x6d, 0x54, 0x0e, 0x4e, 0x04, 0x24, 0x01, 0x87, 0x6f, 0x10, 0x2b, 0x43, 0x08, 0xf2, 0x8a, 0xe7,
0x60, 0xb9, 0xd4, 0x09, 0xce, 0x66, 0x42, 0xde, 0xa7, 0xa6, 0xaa, 0x4a, 0xc7, 0x81, 0x5b, 0xdc,
0x66, 0xd0, 0x7a, 0x90, 0x24, 0xf5, 0x6a, 0xf1, 0x7e, 0xe8, 0x35, 0x0d, 0x66, 0x15, 0x9b, 0x54,
0xe8, 0xbe, 0x99, 0xcf, 0x59, 0x0f, 0x30, 0x43, 0x36, 0x6c, 0xb0, 0xb9, 0xf5, 0xcc, 0x32, 0x19,
0x11, 0x06, 0x6c, 0x7f, 0xec, 0x34, 0x0c, 0xf6, 0xab, 0x31, 0xaa, 0xe0, 0xd5, 0xd4, 0x99, 0xd7,
0x39, 0x22, 0x3f, 0xa8, 0x7e, 0x79, 0xf1, 0x0e, 0x33, 0x0b, 0xe2, 0x28, 0xbf, 0xfb, 0x94, 0x3c,
0x58, 0xf8, 0x79, 0xb3, 0x4b, 0xbc, 0x1c, 0x50, 0xe9, 0x39, 0x41, 0xd5, 0xe3, 0x6c, 0x5c, 0x07,
0x9a, 0x12, 0x74, 0x71, 0x54, 0xaf, 0x14, 0x3a, 0x67, 0x0b, 0xb8, 0x40, 0xe1, 0x64, 0x96, 0x2a,
0x28, 0x9a, 0x86, 0xe6, 0x0f, 0x48, 0x57, 0x60, 0xd9, 0xf4, 0x95, 0xd5, 0x02, 0xa7, 0x80, 0x2c,
0xfd, 0x33, 0xf5, 0xb7, 0xc6, 0x30, 0xf4, 0x1f, 0xee, 0xdc, 0x60, 0xcc, 0x8a, 0xfa, 0x85, 0x23,
0x00, 0x3a, 0x04, 0xc0, 0xf3, 0x8f, 0xd6, 0x59, 0xf5, 0x1a, 0xcf, 0x07, 0xaf, 0xac, 0xab, 0x01,
0x5b, 0xf7, 0x3d, 0x5b, 0xeb, 0xf4, 0x01, 0xf3, 0xa3, 0x1f, 0xb9, 0xea, 0xf1, 0xcc, 0xb4, 0x10,
0x46, 0x2f, 0x46, 0xb3, 0xd2, 0x36, 0x40, 0x9c, 0x8c, 0xa4, 0xdc, 0xb3, 0x8c, 0xfc, 0xa8, 0xdd,
0xce, 0x82, 0xe3, 0x4c, 0x08, 0xf7, 0x94, 0x0a, 0x4d, 0x92, 0x1e, 0x62, 0xfb, 0xfa, 0x90, 0xf4,
0x10, 0x4e, 0x65, 0x04, 0x7b, 0x8e, 0xd7, 0x18, 0x02, 0x24, 0xf5, 0xf3, 0x93, 0xe8, 0x5b, 0x00,
0x94, 0xc8, 0xbb, 0x7e, 0xd6, 0x7b, 0xa5, 0x85, 0x3f, 0x56, 0xe1, 0x37, 0xb0, 0x47, 0x98, 0x5d,
0x9e, 0x22, 0x7e, 0x25, 0x3a, 0x7c, 0x44, 0xb1, 0xbf, 0xfd, 0x09, 0x61, 0xbb, 0x86, 0x45, 0xa4,
0xbc, 0x7c, 0x6c, 0xb3, 0x25, 0xb1, 0x45, 0x5c, 0x92, 0x3e, 0x4b, 0xf4, 0xa3, 0x7f, 0x5d, 0x0a,
0x58, 0xee, 0x28, 0xbc, 0xac, 0x77, 0x4f, 0xcf, 0xb8, 0x72, 0x1d, 0x2c, 0x2c, 0x2e, 0x3d, 0x41,
0xb7, 0xe3, 0x77, 0xe4, 0x31, 0xdd, 0x6e, 0xf2, 0x6a, 0x20, 0x0b, 0x2a, 0x55, 0xdf, 0x29, 0x9a,
0xfd, 0xf9, 0x15, 0x2b, 0x3e, 0xe9, 0xa8, 0xb3, 0xff, 0x85, 0x4c, 0x53, 0xb7, 0x8a, 0xb8, 0x99,
0xde, 0x88, 0x27, 0xa6, 0xa9, 0xd2, 0x4a, 0xe1, 0xac, 0xb4, 0xff, 0x12, 0xc8, 0x55, 0xe2, 0x58,
0x95, 0xf5, 0xdd, 0x3d, 0xcf, 0xa0, 0xba, 0x8a, 0x20, 0xb7, 0xe8, 0x2b, 0x7e, 0xd9, 0x5a, 0x07,
0xa0, 0x1f, 0xec, 0x0f, 0x89, 0x1c, 0xc4, 0xae, 0xcd, 0xdd, 0x97, 0x08, 0x02, 0xca, 0x02, 0x70,
0x24, 0xc4, 0x83, 0xcb, 0xc8, 0x19, 0x52, 0x6f, 0xe7, 0x9a, 0x05, 0xa7, 0x89, 0xa4, 0xc1, 0xc4,
0x15, 0x12, 0x95, 0x04, 0x16, 0xc8, 0x07, 0xe2, 0xb2, 0x76, 0x5c, 0x67, 0x96, 0x35, 0x23, 0xda,
0x1a, 0xd7, 0xe8, 0xb5, 0xa9, 0x98, 0x31, 0x5f, 0x6d, 0xfd, 0xae, 0xf1, 0xc2, 0x44, 0x49, 0x7f,
0x58, 0x9b, 0x07, 0x4c, 0x84, 0xf4, 0x24, 0x70, 0x1e, 0xe0, 0xfb, 0xa3, 0xa1, 0xfc, 0x6c, 0x8d,
0xaa, 0x2f, 0xef, 0xa7, 0x2d, 0x2f, 0x01, 0x2b, 0xed, 0x73, 0xf6, 0xc6, 0x89, 0x52, 0x2e, 0xf5,
0x91, 0x87, 0x00, 0x79, 0x3a, 0xec, 0xb9, 0xe9, 0x71, 0x98, 0xdf, 0x7b, 0x01, 0x8e, 0x21, 0x1f,
0x50, 0xab, 0xd4, 0x2a, 0x82, 0x62, 0xbf, 0x8a, 0x8d, 0x24, 0x13, 0x95, 0xd0, 0xe9, 0x93, 0x39,
0x3e, 0x73, 0x1a, 0x4e, 0xb4, 0x41, 0xca, 0x08, 0x79, 0xea, 0x14, 0x29, 0xaa, 0x0d, 0xff, 0x12,
0x85, 0x5c, 0xc2, 0x5e, 0xea, 0x54, 0xa2, 0x4c, 0xf1, 0x3f, 0xdc, 0x73, 0x38, 0x12, 0xec, 0x02,
0x67, 0x8e, 0x7b, 0xca, 0x41, 0x15, 0xfe, 0xa1, 0x59, 0x12, 0x5d, 0xd4, 0x23, 0x12, 0x19, 0x81,
0x2c, 0x58, 0x5b, 0x1a, 0x78, 0x51, 0xe3, 0xb7, 0xb2, 0xdc, 0xbd, 0x9b, 0xa4, 0x74, 0x6d, 0xa5,
0xda, 0x5d, 0x6c, 0xbf, 0x0c, 0x50, 0xd4, 0xf9, 0x34, 0xab, 0x9f, 0x2f, 0xc2, 0x81, 0x48, 0x2f,
0x09, 0x23, 0x0f, 0xbf, 0x58, 0x07, 0x20, 0x53, 0x88, 0xe1, 0x54, 0x1e, 0x17, 0xe9, 0x04, 0xdf,
0x48, 0xc3, 0x04, 0x89, 0xa9, 0x5e, 0x4f, 0x0e, 0xb8, 0xc4, 0x67, 0x0d, 0x7e, 0x55, 0xe6, 0x1b,
0x1a, 0x3e, 0xd4, 0x1f, 0x94, 0xf4, 0x56, 0x2f, 0x70, 0x68, 0x6d, 0xa0, 0xaa, 0xa0, 0x5b, 0xf2,
0x97, 0xa7, 0x0a, 0x56, 0x7a, 0xa3, 0x4b, 0x9d, 0x48, 0xce, 0xe0, 0xac, 0xe2, 0x1e, 0xb4, 0x73,
0x55, 0xdd, 0xad, 0x09, 0xb0, 0x5a, 0x6d, 0x8c, 0x34, 0xd0, 0x20, 0x6b, 0x71, 0x18, 0x4c, 0xb9,
0x7f, 0x8e, 0xdc, 0x05, 0x2d, 0xea, 0x77, 0xe5, 0xa4, 0xab, 0xbb, 0x33, 0xb9, 0x03, 0x87, 0x62,
0x60, 0x13, 0xfd, 0x3b, 0x4e, 0x3f, 0x20, 0x1c, 0xb2, 0x11, 0x42, 0xda, 0xc7, 0xe5, 0x1c, 0x4e,
0x40, 0xfd, 0x61, 0xa6, 0x07, 0x51, 0x97, 0x91, 0x31, 0xd1, 0xf6, 0xe7, 0xed, 0xaa, 0x56, 0xcf,
0x91, 0x17, 0xa5, 0x7f, 0x7e, 0xce, 0xd2, 0x31, 0x54, 0xb7, 0xca, 0xf8, 0xdd, 0x05, 0x4a, 0xf5,
0x81, 0xd3, 0x6b, 0x49, 0x18, 0x57, 0xfa, 0x0e, 0x9b, 0xdb, 0xf5, 0x16, 0x51, 0xc4, 0xa4, 0x4a,
0xe6, 0x64, 0x86, 0xe7, 0x2b, 0x66, 0x53, 0x1e, 0x71, 0xe7, 0x37, 0xf3, 0xb6, 0x06, 0x0e, 0x3e,
0x98, 0x09, 0x9e, 0x97, 0xc6, 0x26, 0xc8, 0x3f, 0x4a, 0x27, 0xbc, 0xd5, 0x32, 0x0b, 0x9c, 0xba,
0xe1, 0xc7, 0xaf, 0x1f, 0x30, 0x3d, 0xf2, 0xf0, 0x4f, 0x34, 0x45, 0x88, 0x3f, 0xb5, 0x7c, 0x44,
0xc2, 0x68, 0x5e, 0xe0, 0x36, 0x3a, 0x82, 0x93, 0xd7, 0x89, 0xb6, 0xbd, 0x2b, 0xb9, 0x02, 0x9d,
0x31, 0x55, 0x30, 0xf6, 0xe2, 0x7f, 0x1e, 0x65, 0x70, 0xf6, 0x41, 0x7f, 0x33, 0x3c, 0xa2, 0x31,
0x35, 0x66, 0x1b, 0x51, 0xb2, 0xa0, 0xf8, 0x9a, 0x8a, 0xa9, 0xa8, 0x48, 0x6d, 0x8b, 0xeb, 0x70,
0x46, 0x55, 0xd5, 0x81, 0x0b, 0xdf, 0x3f, 0xe5, 0xf7, 0xb4, 0xd1, 0x58, 0xe5, 0x7e, 0xc3, 0xc5,
0x69, 0x19, 0xa7, 0xdf, 0xc0, 0x4c, 0xf0, 0x05, 0x2c, 0x8b, 0xbb, 0x01, 0xe2, 0x21, 0x96, 0x57,
0x06, 0x22, 0xe1, 0xcf, 0x59, 0x61, 0x8a, 0x7f, 0x9c, 0x30, 0xf1, 0x63, 0xca, 0x47, 0xfd, 0x77,
0xf0, 0x00, 0xff, 0xa0, 0xe8, 0xd4, 0xc1, 0x9c, 0xb9, 0xba, 0x48, 0xb9, 0x3d, 0xef, 0x54, 0xd7,
0xe3, 0x8c, 0x25, 0x3a, 0x2b, 0x8d, 0x1c, 0x67, 0xc7, 0xe9, 0xf4, 0x22, 0x37, 0xa9, 0xa7, 0x9f,
0xd9, 0x0c, 0x4d, 0xea, 0x84, 0x70, 0xfb, 0x7f, 0x8c, 0x7d, 0xbe, 0x28, 0x88, 0x50, 0xff, 0x87,
0xcd, 0x85, 0x5f, 0x15, 0xac, 0xc2, 0x97, 0xb0, 0x6e, 0x83, 0x9b, 0xe5, 0x7e, 0xc2, 0x54, 0x38,
0x0b, 0xeb, 0x7a, 0x22, 0xb2, 0xe7, 0x1f, 0x3d, 0xe6, 0x7f, 0x2e, 0x34, 0x5f, 0xea, 0x27, 0x7e,
0x17, 0xd5, 0xf1, 0xcc, 0x25, 0x90, 0x9d, 0xa3, 0x87, 0xf8, 0x3b, 0xf3, 0x3e, 0x55, 0x3a, 0xbd,
0xdd, 0x76, 0x26, 0x30, 0x45, 0xa1, 0x2c, 0x1f, 0x2b, 0x64, 0xd2, 0xf1, 0x1a, 0x6d, 0x54, 0x53,
0x55, 0x5e, 0xde, 0x63, 0x86, 0x90, 0x6b, 0x37, 0x29, 0xc2, 0xb1, 0x75, 0x82, 0xf6, 0x59, 0xc2,
0x40, 0xc1, 0x95, 0x6f, 0x85, 0xbc, 0x22, 0x64, 0x97, 0xba, 0x56, 0x63, 0x9b, 0x3f, 0xe8, 0xda,
0x68, 0xe1, 0xed, 0x4c, 0x53, 0xb8, 0x8f, 0x12, 0x59, 0x12, 0xf1, 0x52, 0x91, 0x06, 0x17, 0x01,
0x64, 0xa8, 0xe2, 0xa7, 0x48, 0xb7, 0x99, 0x00, 0x6f, 0x67, 0x59, 0x3d, 0x82, 0x34, 0xfe, 0x7d,
0x82, 0xd9, 0x79, 0x4a, 0xbd, 0xad, 0x91, 0x3c, 0xb2, 0xd2, 0xde, 0x1e, 0x46, 0xae, 0xd0, 0x2b,
0xe7, 0x2f, 0x60, 0x72, 0x0b, 0x07, 0xc8, 0x05, 0x4b, 0xed, 0xeb, 0x31, 0x83, 0x9d, 0x48, 0x06,
0x24, 0x4f, 0x9c, 0xcb, 0x35, 0x63, 0x1c, 0x01, 0x8f, 0x75, 0xa1, 0x65, 0xd1, 0xac, 0xe1, 0x26,
0x92, 0x43, 0xb8, 0x2d, 0x1a, 0x30, 0xf9, 0x9f, 0x82, 0xdc, 0xbf, 0x84, 0xc4, 0x72, 0x2b, 0x42,
0x9e, 0xc9, 0x55, 0x14, 0x35, 0xf3, 0x40, 0xbb, 0x20, 0x8a, 0xbf, 0x2c, 0x3a, 0x2f, 0x80, 0x00,
0xe3, 0x80, 0x0f, 0x91, 0x7a, 0xfd, 0xf6, 0xf2, 0x36, 0x24, 0x42, 0x36, 0xdd, 0xdd, 0xf3, 0x68,
0x7a, 0xf3, 0x75, 0x63, 0x50, 0x0b, 0x34, 0x22, 0x70, 0xa3, 0x51, 0x9a, 0x2f, 0x47, 0xbf, 0x76,
0x26, 0x74, 0x3e, 0xf2, 0x9b, 0x4b, 0x7a, 0x82, 0x2b, 0x48, 0x99, 0x90, 0x91, 0xd4, 0xb4, 0xc4,
0xcd, 0x09, 0xe0, 0x56, 0x1f, 0x0b, 0x88, 0x2f, 0xfb, 0xc7, 0x41, 0x39, 0x2e, 0x98, 0xd3, 0xc1,
0x9b, 0xd2, 0xba, 0x9d, 0xd3, 0xf3, 0x08, 0xce, 0x64, 0x0f, 0x85, 0xd1, 0x17, 0x6d, 0x11, 0xbf,
0x1b, 0x07, 0x07, 0x6d, 0x1d, 0x4b, 0x71, 0xd0, 0x86, 0xa6, 0x30, 0x0f, 0x44, 0xa5, 0x6b, 0x41,
0x78, 0x9e, 0xe8, 0xc9, 0x1c, 0xa0, 0x54, 0x04, 0x4a, 0x8b, 0x7f, 0x1b, 0x41, 0xe3, 0x13, 0xe3,
0xca, 0xf1, 0x4b, 0x6a, 0xa4, 0x16, 0x77, 0x02, 0xe2, 0x69, 0x8d, 0x02, 0x5a, 0xe2, 0x46, 0x29,
0x3e, 0xee, 0x14, 0x59, 0xd0, 0x05, 0x9a, 0x67, 0xda, 0x01, 0x0a, 0xce, 0x95, 0xb3, 0x90, 0xef,
0x47, 0x3d, 0x86, 0xab, 0xa3, 0xed, 0x71, 0xa7, 0xb7, 0x3e, 0xfd, 0x88, 0x6a, 0xe8, 0xf1, 0x1e,
0x65, 0x63, 0x39, 0x3f, 0x06, 0x9b, 0x81, 0x6c, 0x22, 0x69, 0x67, 0xb9, 0x02, 0x1b, 0x16, 0x5e,
0xe8, 0x7b, 0xf7, 0x5c, 0x37, 0x78, 0x0c, 0x84, 0x43, 0xef, 0x4d, 0xf7, 0xf0, 0xe6, 0x3d, 0xde,
0x8c, 0xbb, 0x7d, 0xcc, 0xe3, 0x3a, 0xf8, 0x97, 0xab, 0xe8, 0xed, 0xdf, 0x67, 0x46, 0xfc, 0x6f,
0x07, 0x02, 0xaa, 0x83, 0xbe, 0xd0, 0x0b, 0xe3, 0x7d, 0x4f, 0xaa, 0xf1, 0x1d, 0x70, 0x5b, 0x7b,
0xb4, 0xab, 0x35, 0xc3, 0x3e, 0x36, 0x8b, 0xb0, 0x18, 0x3d, 0x3c, 0x89, 0x3d, 0x3b, 0xdf, 0x89,
0xed, 0x6c, 0x21, 0xc3, 0xc9, 0x57, 0x11, 0x42, 0x55, 0xb2, 0x51, 0x7b, 0x5e, 0x04, 0x8c, 0x20,
0xea, 0xa0, 0xfd, 0x57, 0xf4, 0x2e, 0x5f, 0xee, 0x07, 0x10, 0xd5, 0xa9, 0x89, 0x23, 0x84, 0x5c,
0x7d, 0x12, 0x8b, 0x83, 0x70, 0x77, 0x40, 0x5a, 0x60, 0xa3, 0x13, 0x9d, 0x14, 0x5f, 0xaf, 0x74,
0x83, 0xfe, 0xda, 0xcc, 0xf7, 0xfb, 0x7d, 0x62, 0xbd, 0x42, 0x55, 0x44, 0xc5, 0xde, 0x55, 0xd3,
0xb0, 0x0b, 0xd3, 0xea, 0x7d, 0x96, 0xe5, 0xee, 0xe1, 0x45, 0x6d, 0xe0, 0x3d, 0x9e, 0x62, 0xd4,
0xef, 0xb5, 0x0a, 0x32, 0x05, 0xcd, 0x38, 0x99, 0x61, 0xdd, 0xf6, 0xf3, 0x85, 0xce, 0x1a, 0xb3,
0x57, 0xfc, 0xd1, 0x63, 0x7c, 0x84, 0xb6, 0xa2, 0x84, 0xf4, 0x3e, 0x34, 0xb9, 0x3f, 0xb9, 0x8e,
0xd0, 0x30, 0x23, 0x0a, 0x27, 0x3c, 0x19, 0xc6, 0xd2, 0x8e, 0xb9, 0x55, 0xb7, 0x34, 0xab, 0x60,
0x52, 0xd3, 0x45, 0x09, 0xde, 0x0b, 0x41, 0x66, 0x04, 0x71, 0x1e, 0x4e, 0xba, 0x09, 0x7b, 0xab,
0x3a, 0x85, 0x7d, 0xfc, 0x95, 0x9b, 0x71, 0xb9, 0x78, 0x3f, 0x41, 0x44, 0x5c, 0xd2, 0x5f, 0x9f,
0xe7, 0xc7, 0xf4, 0x6c, 0x52, 0x07, 0xda, 0xb2, 0x39, 0xc8, 0xd9, 0x77, 0x60, 0x12, 0xd3, 0x7b,
0x70, 0x5a, 0x7e, 0x66, 0xb1, 0x0b, 0x4e, 0x86, 0xa4, 0x31, 0x47, 0x1c, 0x72, 0x8a, 0x89, 0x96,
0x8e, 0x24, 0xa4, 0x1f, 0x07, 0x11, 0x50, 0xc3, 0x05, 0x77, 0x82, 0xfa, 0x98, 0xba, 0xec, 0xa0,
0x71, 0x59, 0x95, 0x6f, 0xa3, 0x2d, 0x1f, 0x26, 0xc0, 0x73, 0x2e, 0x13, 0x38, 0xdc, 0x57, 0x46,
0xec, 0x4d, 0x4f, 0x11, 0xa4, 0x35, 0x5e, 0x37, 0x0e, 0x1b, 0xe7, 0x32, 0x02, 0xf8, 0x81, 0x67,
0xb1, 0x51, 0x1f, 0x34, 0xe5, 0xad, 0xa0, 0x07, 0xd8, 0xc0, 0xae, 0x52, 0xed, 0x4e, 0xbe, 0x6e,
0xe8, 0x92, 0x85, 0x76, 0x8d, 0x71, 0xd6, 0xac, 0x21, 0x61, 0x14, 0x75, 0xf3, 0xb7, 0x66, 0x8e,
0xf5, 0xd1, 0x8b, 0x7a, 0xfd, 0xc6, 0x39, 0x2d, 0x0a, 0x0e, 0x63, 0x86, 0x1e, 0x0c, 0x55, 0xbc,
0xf3, 0x52, 0xf8, 0x8e, 0x9e, 0x94, 0xae, 0xa9, 0x29, 0x28, 0x98, 0x8c, 0x64, 0x2a, 0x8c, 0x87,
0x21, 0x01, 0x5d, 0xd3, 0x79, 0xbf, 0x09, 0x1f, 0x8c, 0xe4, 0xa2, 0xf7, 0xc6, 0x49, 0xa9, 0xe1,
0xea, 0x6d, 0x6d, 0xc6, 0x40, 0x4a, 0x02, 0x25, 0x2a, 0xb2, 0xc5, 0x29, 0x87, 0x00, 0x21, 0x40,
0x88, 0x6b, 0x18, 0xea, 0x19, 0x09, 0xec, 0x39, 0x54, 0x33, 0xea, 0x10, 0x6b, 0x5a, 0x10, 0x50,
0x3b, 0x5a, 0xd6, 0x1e, 0x12, 0x02, 0xc4, 0x09, 0x12, 0x01, 0xc1, 0x2a, 0x31, 0xd1, 0x73, 0xa3,
0xf8, 0xcf, 0x28, 0x05, 0xe5, 0xb3, 0x46, 0x90, 0x35, 0xf2, 0x7f, 0xd5, 0x1b, 0x5f, 0xe5, 0x11,
0x5a, 0x47, 0x6f, 0xa0, 0xf8, 0x59, 0x94, 0xeb, 0xd7, 0x08, 0x64, 0x6f, 0x3a, 0x97, 0x86, 0xeb,
0xad, 0xa0, 0x72, 0x8d, 0xac, 0x55, 0xc5, 0xd1, 0xd4, 0xa0, 0xb9, 0x0e, 0xc0, 0x9b, 0x03, 0xd3,
0x01, 0xef, 0xdd, 0xa9, 0x2a, 0x98, 0x11, 0xfa, 0xd6, 0x2b, 0xc2, 0x51, 0xe8, 0xed, 0x0e, 0x34,
0x2a, 0x16, 0x04, 0xbf, 0x6f, 0x46, 0x15, 0x57, 0x26, 0xee, 0xd1, 0x6b, 0xd9, 0x06, 0x1d, 0x8c,
0x52, 0xf3, 0xa0, 0x56, 0xe8, 0x5d, 0xb2, 0xbd, 0x95, 0x0f, 0x08, 0x14, 0xa0, 0x5b, 0x08, 0xd9,
0x89, 0x21, 0x38, 0x39, 0x5f, 0x1a, 0x22, 0xc1, 0x20, 0x00, 0x8f, 0x98, 0x8d, 0xd1, 0x5e, 0xc7,
0xc0, 0x97, 0x59, 0xb4, 0xe4, 0xe5, 0x69, 0xbd, 0x33, 0x75, 0xbe, 0x86, 0x0d, 0xbb, 0x28, 0xe0,
0x3e, 0xf5, 0x09, 0xb7, 0x8f, 0xbd, 0xca, 0x27, 0x5d, 0x1d, 0x9b, 0x80, 0x89, 0x44, 0xc2, 0xc6,
0xc6, 0x93, 0x9c, 0x3f, 0x1e, 0x5d, 0x41, 0xc4, 0xb3, 0x73, 0x1f, 0x22, 0x0d, 0x49, 0x6b, 0x68,
0x5d, 0xb2, 0x4a, 0xba, 0x9e, 0xe8, 0x63, 0x3c, 0xa3, 0x67, 0x59, 0x5e, 0xea, 0x88, 0x35, 0xbf,
0xc4, 0xfe, 0xb4, 0xa5, 0x93, 0x1f, 0x1e, 0x8e, 0x79, 0x5e, 0x0c, 0x64, 0x12, 0x9e, 0xf5, 0x04,
0xf2, 0x9c, 0x29, 0x01, 0xb9, 0xf3, 0xc2, 0x33, 0xa5, 0xbb, 0xc5, 0x1f, 0x72, 0x1c, 0x73, 0x78,
0xc1, 0x21, 0x50, 0x1d, 0x41, 0x47, 0xad, 0x5c, 0x0e, 0x7b, 0x55, 0xb9, 0x75, 0x8f, 0x56, 0xd3,
0x0d, 0xb2, 0x4c, 0x61, 0x40, 0x83, 0xe8, 0xd7, 0xa6, 0x7b, 0x67, 0xd6, 0xac, 0x60, 0xb2, 0x04,
0x6d, 0x1c, 0x3a, 0x59, 0x28, 0x20, 0x23, 0x6a, 0xdc, 0x1c, 0x59, 0xc2, 0x0f, 0xc4, 0xb4, 0xe9,
0x31, 0xec, 0x91, 0xa8, 0x31, 0xb9, 0x28, 0x86, 0xb4, 0xe4, 0x15, 0xf2, 0x71, 0x71, 0xcc, 0xfc,
0x7d, 0xf7, 0x6d, 0x6a, 0x21, 0x1b, 0x36, 0x35, 0x3e, 0xe9, 0x81, 0x3b, 0x65, 0xdd, 0x2b, 0x59,
0xd6, 0x26, 0xf3, 0xb0, 0x02, 0xc8, 0x89, 0x4a, 0xf8, 0x12, 0x87, 0x97, 0xb8, 0x05, 0x8d, 0xea,
0xff, 0x07, 0xe6, 0x22, 0x58, 0x34, 0x4c, 0x13, 0xf1, 0x9e, 0xf4, 0x39, 0x49, 0x60, 0x92, 0x63,
0x21, 0x53, 0x17, 0x2d, 0x48, 0x18, 0xf4, 0x19, 0x71, 0xf1, 0xae, 0x18, 0x67, 0x33, 0xbc, 0x97,
0xcf, 0x83, 0x5f, 0x05, 0xf1, 0xe6, 0x61, 0x07, 0x1d, 0x8c, 0xd6, 0x6e, 0x5a, 0xb9, 0xdd, 0xdc,
0xa7, 0x58, 0x25, 0xa2, 0x32, 0xee, 0x48, 0x49, 0x86, 0x1b, 0x15, 0x5e, 0x56, 0x31, 0x91, 0x28,
0x94, 0xf8, 0xde, 0x07, 0x70, 0x30, 0x98, 0x67, 0xa9, 0x47, 0xc0, 0x19, 0x82, 0xcf, 0x0b, 0x55,
0x2a, 0xe6, 0x7f, 0xd2, 0x96, 0x14, 0x2a, 0xbe, 0xb5, 0x4b, 0x82, 0xe7, 0x80, 0x4b, 0x11, 0xeb,
0x25, 0xfe, 0xdd, 0xc8, 0xdc, 0xb6, 0xa2, 0x74, 0x8c, 0x61, 0xab, 0xc5, 0x08, 0x4a, 0xcd, 0x51,
0x94, 0x2b, 0xf6, 0xcc, 0x1c, 0x09, 0xc7, 0x84, 0xb5, 0x96, 0x24, 0xdf, 0x5a, 0x2d, 0x73, 0xb0,
0xe1, 0xaa, 0x19, 0xca, 0x0f, 0x31, 0x28, 0xd1, 0xea, 0xe4, 0x48, 0x12, 0x0b, 0xe0, 0xb5, 0x31,
0x70, 0x58, 0xd9, 0x80, 0xf1, 0x31, 0xff, 0xa3, 0x60, 0x0c, 0x58, 0x7d, 0x18, 0x06, 0x4d, 0x54,
0x04, 0x3e, 0x8d, 0xb1, 0x5b, 0x4c, 0xde, 0x1c, 0x35, 0xf7, 0xab, 0x5a, 0x5e, 0x1e, 0x25, 0x41,
0x22, 0xc4, 0xd7, 0x46, 0x52, 0x6c, 0xe3, 0xbf, 0xd6, 0xc0, 0x4a, 0x9a, 0x66, 0x0f, 0xe0, 0xa9,
0xcb, 0x0f, 0x7b, 0xcb, 0x3e, 0xa2, 0x8f, 0xd3, 0x93, 0x2c, 0xec, 0x92, 0xf1, 0x51, 0x51, 0x6f,
0x5e, 0x84, 0x4c, 0x41, 0x07, 0x8c, 0xa6, 0x82, 0x63, 0x80, 0x7e, 0x95, 0x94, 0xaf, 0x63, 0xc6,
0x2a, 0x26, 0x0d, 0x01, 0x8d, 0x6a, 0x86, 0x7c, 0xaf, 0x55, 0x3b, 0x6b, 0xc6, 0x81, 0xfb, 0xe8,
0x64, 0x12, 0xef, 0x81, 0x38, 0x2b, 0xaf, 0xd9, 0x57, 0x56, 0xb6, 0xe2, 0x83, 0x7e, 0x7d, 0x19,
0x63, 0xd5, 0x10, 0x4f, 0x14, 0xfe, 0xb0, 0x57, 0x87, 0x5e, 0x6e, 0xe7, 0xb3, 0xb6, 0xd3, 0x0d,
0x6e, 0x18, 0xcf, 0xa5, 0x0f, 0x5d, 0x71, 0x8d, 0x6b, 0xc7, 0xb4, 0xb1, 0x54, 0x0e, 0xe4, 0x2d,
0xf2, 0xff, 0x0a, 0xa0, 0x75, 0xee, 0xc7, 0x37, 0xd0, 0xbd, 0xba, 0xd7, 0x35, 0x89, 0xf8, 0x7d,
0x4b, 0x32, 0x83, 0x4f, 0x41, 0xca, 0xd9, 0xc7, 0x4b, 0xee, 0x1d, 0x95, 0xf7, 0xab, 0xdf, 0x8f,
0x53, 0xaf, 0xac, 0x77, 0x47, 0xea, 0x92, 0x47, 0xa4, 0x25, 0xd7, 0x19, 0x8c, 0x99, 0xf7, 0x59,
0x74, 0xb4, 0x9b, 0xe2, 0xcc, 0x6c, 0x56, 0xdc, 0xc1, 0x30, 0xa1, 0x85, 0x5b, 0xdd, 0xfa, 0x91,
0x59, 0x2d, 0xd9, 0xce, 0x93, 0x0c, 0x31, 0xa8, 0x85, 0xcf, 0xb3, 0xb4, 0x64, 0x32, 0xa3, 0x7b,
0xc7, 0xd4, 0x16, 0xc2, 0x57, 0x20, 0x60, 0x9b, 0x5b, 0x79, 0x4a, 0xab, 0xe1, 0xc3, 0x41, 0x30,
0xc9, 0xe2, 0x4d, 0x60, 0x8f, 0xab, 0x0a, 0xbf, 0x42, 0x80, 0xc2, 0xc6, 0x51, 0xa2, 0xa2, 0x6a,
0x9d, 0x5f, 0xab, 0x69, 0x7f, 0x5c, 0x7d, 0x3a, 0x13, 0xce, 0x99, 0x31, 0x55, 0x59, 0x09, 0x89,
0xda, 0x17, 0x7d, 0x1e, 0xea, 0x7a, 0xe0, 0x75, 0x4b, 0xba, 0xb1, 0x93, 0xbc, 0xc7, 0xc5, 0x84,
0xc7, 0x15, 0xb0, 0x9e, 0xc1, 0xd5, 0x36, 0x67, 0xe6, 0x27, 0xb4, 0xb2, 0xcc, 0xd8, 0x9b, 0x8d,
0x58, 0x62, 0x90, 0x3b, 0x89, 0x3c, 0x84, 0x0a, 0x69, 0x7a, 0xc9, 0x24, 0x52, 0xf3, 0x50, 0x51,
0x23, 0x52, 0x0d, 0x3d, 0xbf, 0x12, 0x0a, 0x92, 0x50, 0xae, 0xb1, 0xb5, 0xa9, 0xc9, 0x46, 0x0c,
0xf6, 0x09, 0xdc, 0x86, 0x6b, 0x67, 0x2e, 0x8d, 0x8d, 0x93, 0x21, 0x85, 0x34, 0xdb, 0x98, 0x21,
0x6a, 0x32, 0xa1, 0x9d, 0xec, 0x09, 0xc0, 0x92, 0x60, 0x65, 0xd8, 0xad, 0xad, 0x7b, 0xda, 0xd6,
0xb2, 0xe5, 0xe5, 0x33, 0xd0, 0xe6, 0x85, 0x9e, 0xf6, 0x34, 0xba, 0x5e, 0xf2, 0x9f, 0x05, 0x6e,
0x95, 0xd6, 0xfd, 0xc6, 0x18, 0x22, 0x74, 0x1a, 0x33, 0xa6, 0xad, 0x68, 0x13, 0x85, 0x05, 0xdc,
0xb3, 0xc1, 0x76, 0xee, 0xf5, 0x6f, 0xd9, 0x27, 0x82, 0xa5, 0x28, 0x80, 0xf7, 0x0d, 0xf9, 0x80,
0xeb, 0x41, 0x66, 0xe9, 0x7f, 0x53, 0x1c, 0x1d, 0x1c, 0x53, 0xfa, 0x55, 0xe6, 0xc0, 0x2b, 0x80,
0xe1, 0x47, 0x5a, 0xce, 0x4b, 0x6e, 0xab, 0x20, 0xa5, 0x43, 0x34, 0xec, 0x24, 0x12, 0xc8, 0x40,
0x86, 0x54, 0x82, 0x46, 0xe4, 0x1f, 0x8b, 0x0b, 0x5f, 0x54, 0xa1, 0xfc, 0xfd, 0xee, 0x71, 0x64,
0x49, 0xc8, 0xd7, 0x38, 0x89, 0xea, 0x6e, 0xf4, 0x66, 0x8d, 0x1c, 0xee, 0x8d, 0xa8, 0xa0, 0x6c,
0x15, 0xdc, 0xe6, 0x41, 0xac, 0x6b, 0x9a, 0xbb, 0x9e, 0xe7, 0x10, 0xea, 0x6e, 0x37, 0xe1, 0x9f,
0x3d, 0x17, 0xa5, 0x93, 0x54, 0x92, 0xc2, 0x2e, 0xe9, 0x08, 0x57, 0x6c, 0x46, 0xff, 0x2e, 0xd9,
0x80, 0x03, 0xdf, 0x99, 0xa4, 0xf4, 0xde, 0x11, 0xc6, 0x5b, 0xe0, 0x88, 0x0f, 0x87, 0x6b, 0x20,
0x61, 0xf5, 0x37, 0x74, 0x64, 0x35, 0x62, 0xb9, 0x36, 0xcc, 0x95, 0x2a, 0xaf, 0x0e, 0x95, 0x09,
0xe2, 0x61, 0xb2, 0xa3, 0x85, 0x21, 0x24, 0xd6, 0x5d, 0xeb, 0x7d, 0x13, 0xe4, 0xd9, 0x2e, 0xec,
0x64, 0x24, 0x2d, 0x01, 0x07, 0xc2, 0xba, 0x5c, 0xc1, 0x2a, 0x77, 0x88, 0xf0, 0x01, 0x75, 0xf1,
0x7b, 0xe3, 0x63, 0x67, 0x5a, 0x7c, 0x97, 0x61, 0x43, 0x36, 0x40, 0x43, 0x31, 0x40, 0x76, 0x2c,
0x26, 0x62, 0xb1, 0xc3, 0x82, 0xc3, 0xc1, 0xec, 0xe4, 0xd6, 0x3f, 0x57, 0x41, 0xfb, 0xbc, 0x00,
0xa4, 0x49, 0xf5, 0xd1, 0x16, 0x3a, 0x2b, 0x7c, 0x67, 0x52, 0x7a, 0x03, 0xa7, 0xf3, 0xb2, 0xa1,
0x31, 0x18, 0x67, 0x41, 0x26, 0x59, 0x26, 0xc9, 0x1f, 0x94, 0x37, 0x72, 0xfd, 0xf8, 0x75, 0xae,
0x63, 0xe2, 0x6b, 0xb0, 0x33, 0x6d, 0x14, 0x15, 0xf3, 0x63, 0xc4, 0xe0, 0x10, 0x77, 0xf8, 0xc8,
0x3b, 0xc2, 0xd5, 0x5a, 0x8a, 0x6f, 0xea, 0x2a, 0xa2, 0xa0, 0xcf, 0x2f, 0xd2, 0xaf, 0x03, 0x51,
0x97, 0x31, 0x55, 0x75, 0x4e, 0xa3, 0xa5, 0xe7, 0x2b, 0xb9, 0x1f, 0x31, 0x23, 0x78, 0x7f, 0xff,
0x63, 0x63, 0x77, 0x5b, 0x28, 0x2d, 0xe1, 0x12, 0x6a, 0xe7, 0xf3, 0xca, 0xd0, 0x20, 0x18, 0x86,
0x9e, 0x1b, 0xbc, 0xb4, 0x0e, 0x94, 0xbb, 0x64, 0xf3, 0x38, 0x70, 0x55, 0x6b, 0xf4, 0x5f, 0xfb,
0x1c, 0x66, 0x4c, 0xb1, 0xe4, 0x7c, 0xea, 0x26, 0x39, 0x24, 0xe6, 0xda, 0x1f, 0x7e, 0x7f, 0x13,
0x18, 0xf1, 0x8b, 0x5d, 0x53, 0xd3, 0xc1, 0xf9, 0xe9, 0x7c, 0x4d, 0x62, 0xeb, 0x21, 0x63, 0x90,
0xe0, 0x5b, 0x14, 0x63, 0xed, 0xa6, 0xfc, 0x69, 0xd4, 0x29, 0x03, 0xb8, 0xfd, 0x14, 0x30, 0xd3,
0x45, 0x18, 0x40, 0x58, 0xb5, 0x93, 0xe7, 0x5e, 0x97, 0xcf, 0x77, 0x7a, 0x14, 0x5a, 0x9c, 0x92,
0xb5, 0xe0, 0x63, 0xa0, 0x89, 0x41, 0xf2, 0xfe, 0xe2, 0x96, 0x7e, 0x63, 0x70, 0xec, 0x72, 0x91,
0x57, 0x6b, 0xe1, 0x3e, 0x44, 0x87, 0xdd, 0x42, 0xd2, 0x41, 0x4e, 0x9e, 0x6d, 0x6f, 0x75, 0x87,
0xca, 0x35, 0xab, 0x46, 0xe3, 0xa4, 0x69, 0x55, 0x92, 0x60, 0x66, 0x26, 0x33, 0x66, 0xbd, 0x52,
0x64, 0x44, 0xcf, 0x67, 0x12, 0xaa, 0x65, 0x90, 0x39, 0xe6, 0x3b, 0x7d, 0xdf, 0x77, 0xb3, 0xaa,
0x4b, 0x31, 0x0f, 0x90, 0x76, 0x55, 0x7b, 0xd0, 0xfc, 0x6c, 0x44, 0x96, 0xd7, 0xf1, 0xd0, 0x4e,
0xa3, 0x6c, 0xf4, 0xf5, 0xdd, 0xa9, 0xb2, 0x79, 0x32, 0x9a, 0xc7, 0x71, 0xac, 0xd1, 0x88, 0x91,
0x11, 0x1b, 0x87, 0x08, 0x46, 0xca, 0x53, 0xed, 0x3c, 0x06, 0xed, 0x5f, 0xd7, 0xd5, 0xe9, 0x5b,
0xdb, 0xb9, 0xfa, 0xc1, 0x90, 0x2a, 0xb2, 0x75, 0xbb, 0xb4, 0xd3, 0xf7, 0xa2, 0xd7, 0x28, 0xbe,
0x5d, 0xa6, 0x1d, 0x02, 0x33, 0x6b, 0x43, 0x82, 0x08, 0x49, 0xe0, 0x62, 0x1c, 0x9d, 0x54, 0x1b,
0x6b, 0xa9, 0x75, 0xe5, 0xf8, 0x17, 0xf4, 0x0f, 0x1f, 0x8b, 0x5d, 0x02, 0x6c, 0xca, 0x2a, 0x99,
0x88, 0xa7, 0xcf, 0x05, 0xe9, 0x40, 0xe6, 0x46, 0xa5, 0xf6, 0x8a, 0x1c, 0x84, 0x1f, 0x2a, 0x17,
0x01, 0xc8, 0xd0, 0x9d, 0x9f, 0xd2, 0x41, 0x91, 0xe6, 0xdb, 0xd2, 0xc0, 0x9c, 0xf3, 0x27, 0xe1,
0x45, 0x75, 0x7d, 0x31, 0x25, 0x14, 0x8c, 0xc5, 0xb0, 0x76, 0x35, 0xa3, 0x93, 0xf4, 0xcc, 0xd8,
0xa1, 0x1e, 0x10, 0x5c, 0x17, 0x9d, 0x7d, 0xc1, 0x37, 0xb7, 0xa1, 0xd7, 0xbf, 0x3a, 0x58, 0x7e,
0x30, 0x3b, 0x24, 0xbd, 0x4d, 0xa7, 0x96, 0xa7, 0x5a, 0x48, 0xc6, 0x91, 0x7b, 0x03, 0x05, 0xf1,
0xa8, 0xd8, 0x1b, 0xd4, 0xf1, 0x3d, 0xc0, 0x02, 0x2d, 0xc8, 0xec, 0x74, 0x18, 0xc9, 0x77, 0xd0,
0x18, 0x2f, 0xba, 0x2e, 0x1b, 0x5b, 0xe8, 0x68, 0x7b, 0xec, 0xe7, 0xde, 0x59, 0xe0, 0x10, 0x9e,
0x9d, 0xd8, 0x7e, 0x41, 0x6d, 0xc3, 0x23, 0x21, 0x84, 0xa5, 0x90, 0xb9, 0x35, 0x69, 0x43, 0x0c,
0x03, 0xc2, 0x82, 0x52, 0xbe, 0x69, 0x2f, 0x25, 0x4c, 0x8b, 0x1b, 0x6f, 0xe9, 0xf4, 0x51, 0xce,
0xe7, 0xe4, 0x96, 0x57, 0x6b, 0x51, 0x6c, 0x2f, 0x1e, 0xd5, 0x4d, 0xea, 0xdf, 0xbf, 0x06, 0x12,
0x84, 0x9d, 0xe5, 0x7e, 0x98, 0x49, 0xff, 0xa5, 0x1b, 0x3c, 0x72, 0x30, 0xac, 0xe3, 0xf4, 0xba,
0xe4, 0x07, 0x59, 0xba, 0x57, 0x41, 0x21, 0x5f, 0xc2, 0x4d, 0x2c, 0x3f, 0xcf, 0x74, 0xdf, 0xc9,
0xf4, 0x50, 0x0a, 0x20, 0x24, 0x56, 0xec, 0xec, 0xd3, 0xfd, 0x3c, 0xdb, 0x46, 0x86, 0x4d, 0x0b,
0x8c, 0xc0, 0xe0, 0x67, 0x4c, 0x78, 0x25, 0x9a, 0xc8, 0xfc, 0x77, 0xa8, 0xf4, 0xf8, 0x43, 0x87,
0xdc, 0x66, 0xbd, 0x34, 0x26, 0x06, 0xc8, 0x5d, 0x66, 0x63, 0x80, 0x45, 0x09, 0x8f, 0x57, 0xfd,
0xd9, 0x80, 0x67, 0x8e, 0x62, 0xf1, 0x70, 0xee, 0x7e, 0x43, 0xd5, 0x3d, 0x11, 0x35, 0x5b, 0xf9,
0xb9, 0xb7, 0x56, 0x4c, 0x9c, 0x59, 0x71, 0x80, 0xfb, 0x35, 0xcb, 0x58, 0xb3, 0xdb, 0x0c, 0xf3,
0x29, 0xe6, 0x38, 0x93, 0x72, 0xef, 0x19, 0x24, 0x71, 0xa4, 0x7e, 0xc2, 0x0f, 0xa7, 0x88, 0x60,
0xa7, 0x0e, 0x65, 0x7f, 0xd7, 0x60, 0x30, 0x7a, 0xe8, 0xf0, 0x37, 0xee, 0x68, 0x87, 0x31, 0xc8,
0x32, 0xe4, 0xa1, 0x71, 0xd2, 0xdb, 0x86, 0x9b, 0xe2, 0xf5, 0x63, 0xe6, 0x70, 0x79, 0x79, 0xa6,
0x79, 0xab, 0x44, 0xdc, 0xe5, 0xe7, 0xe2, 0x95, 0x9a, 0x07, 0x50, 0x4a, 0xc9, 0x95, 0xa7, 0x39,
0x8b, 0xcb, 0xb7, 0xa2, 0xf1, 0xc5, 0x37, 0x96, 0x58, 0x29, 0xd7, 0x05, 0x9b, 0xf7, 0x39, 0x9c,
0xef, 0xbb, 0x0d, 0xde, 0xb7, 0xb1, 0xab, 0xa1, 0x31, 0xc2, 0xe1, 0x01, 0xfb, 0x76, 0xfe, 0x2a,
0x61, 0x35, 0x8f, 0x50, 0x93, 0x48, 0xbb, 0x44, 0xb0, 0xfc, 0x78, 0xd7, 0xef, 0x34, 0x98, 0x49,
0xbb, 0x96, 0x59, 0x25, 0x37, 0x26, 0x04, 0x86, 0x97, 0x0c, 0x0f, 0xd4, 0x20, 0xb1, 0x80, 0x23,
0xd2, 0x33, 0x98, 0xad, 0x1d, 0xb5, 0xc4, 0x7d, 0x74, 0x69, 0xa8, 0x73, 0xba, 0xb5, 0x71, 0xfe,
0xd9, 0x5c, 0xfe, 0xd2, 0x4b, 0x6a, 0xa9, 0x0d, 0xfc, 0x19, 0x2f, 0x7c, 0x6e, 0x73, 0xab, 0xa9,
0xbb, 0x1e, 0xe4, 0x50, 0xc0, 0x58, 0xab, 0xef, 0xf6, 0xe8, 0x48, 0x04, 0x8a, 0x97, 0xbb, 0x0d,
0x8c, 0x10, 0x9c, 0x68, 0xed, 0xe7, 0x18, 0x8b, 0xcd, 0x6d, 0xcb, 0x14, 0x5b, 0xba, 0x08, 0x61,
0x0d, 0xbb, 0x4a, 0xe1, 0x13, 0x67, 0xca, 0x68, 0x4d, 0x36, 0x69, 0xe3, 0xab, 0x01, 0x00, 0x97,
0x1e, 0x7e, 0xb0, 0x09, 0x24, 0x13, 0xf2, 0xce, 0xda, 0x34, 0xdf, 0x91, 0x60, 0x2b, 0xdc, 0x58,
0xe2, 0xf1, 0x39, 0xe0, 0x6c, 0x7d, 0x38, 0xd0, 0x6a, 0xeb, 0xa7, 0xb1, 0x6e, 0xa6, 0x2a, 0x62,
0x25, 0x41, 0xb3, 0x30, 0x96, 0x34, 0xb0, 0x46, 0x0d, 0x37, 0x4c, 0x28, 0x66, 0x49, 0x5a, 0x5e,
0x86, 0x3b, 0x3d, 0x02, 0xa3, 0x4a, 0x08, 0xd8, 0xb1, 0xdd, 0x64, 0x61, 0xaa, 0xb9, 0x41, 0xdb,
0x60, 0xe7, 0xc1, 0x40, 0x90, 0xe1, 0xce, 0x48, 0x5a, 0x13, 0x58, 0xd2, 0x55, 0x07, 0x08, 0xa4,
0xeb, 0x7c, 0x43, 0x17, 0x31, 0x5c, 0xb2, 0x28, 0x76, 0x37, 0x81, 0x50, 0x94, 0xf8, 0xa3, 0x3a,
0x0f, 0xe1, 0x36, 0x01, 0x68, 0xe5, 0x0d, 0x27, 0x88, 0xeb, 0xec, 0x56, 0x69, 0x31, 0xd7, 0x18,
0xb9, 0x02, 0x95, 0xb0, 0xe9, 0xca, 0x32, 0x69, 0xd1, 0x27, 0x3a, 0x9b, 0x07, 0xdc, 0x2f, 0xc4,
0x70, 0x68, 0x5d, 0xbd, 0x11, 0x83, 0x4c, 0x71, 0x1a, 0x5d, 0x0a, 0xde, 0xc2, 0x14, 0x52, 0xc6,
0x7a, 0xa5, 0x73, 0x3e, 0x78, 0x16, 0xaa, 0x76, 0x77, 0xeb, 0x99, 0x13, 0xfe, 0x9b, 0x2b, 0x7b,
0x4d, 0x86, 0xc7, 0x1e, 0x4e, 0x05, 0x10, 0x6a, 0xc9, 0x29, 0xb0, 0xa9, 0xbe, 0x20, 0x01, 0x87,
0x21, 0x70, 0xf8, 0xe1, 0x69, 0xe9, 0xd0, 0x96, 0x4f, 0x03, 0xd3, 0x76, 0xa8, 0x0b, 0x71, 0x6d,
0x9b, 0x5e, 0x9f, 0xd0, 0x50, 0x19, 0x8a, 0x39, 0x71, 0x78, 0xab, 0x7f, 0xbf, 0x3d, 0xae, 0x8a,
0xb7, 0xfe, 0xe8, 0x38, 0x53, 0xab, 0xfb, 0x2f, 0x04, 0xc5, 0x2e, 0x72, 0xde, 0x74, 0x7f, 0x01,
0x50, 0x01, 0xf9, 0x8f, 0x8b, 0x34, 0x41, 0xe6, 0x6f, 0x9f, 0x98, 0xa4, 0xb1, 0x7d, 0x2e, 0x78,
0xbc, 0x8e, 0xce, 0x8f, 0xe2, 0x28, 0xbd, 0x24, 0x8b, 0x3e, 0x6b, 0x9c, 0xad, 0x16, 0x85, 0x48,
0x34, 0x52, 0xeb, 0x5e, 0x32, 0x79, 0x42, 0xaa, 0x97, 0xd8, 0x32, 0x46, 0x38, 0x22, 0x69, 0x81,
0x11, 0xdc, 0xf3, 0x65, 0x03, 0xa7, 0x98, 0xdf, 0xd3, 0x1b, 0xfd, 0x89, 0x45, 0x89, 0x60, 0xb4,
0x53, 0xd4, 0xb8, 0xec, 0xae, 0x33, 0x41, 0x56, 0x62, 0x57, 0x7c, 0x55, 0x2f, 0x2b, 0x31, 0x20,
0xef, 0xc1, 0x23, 0x55, 0x01, 0xc5, 0xf3, 0x99, 0x41, 0x05, 0xc1, 0x12, 0x02, 0x02, 0x27, 0xcb,
0x63, 0x41, 0x5f, 0x66, 0x3c, 0xce, 0x2a, 0x1f, 0xe8, 0xc4, 0x82, 0x8e, 0xf7, 0x06, 0xa8, 0x17,
0xc6, 0xf7, 0x13, 0xca, 0xf0, 0x10, 0x92, 0xec, 0xa9, 0xf3, 0x74, 0x9d, 0xf7, 0xdb, 0x71, 0xb5,
0x51, 0x9d, 0xe0, 0xfd, 0x76, 0x90, 0x3f, 0x05, 0x22, 0xf4, 0xf2, 0x21, 0x81, 0x75, 0xdb, 0x5c,
0x2b, 0xd1, 0x08, 0xbe, 0x9c, 0x5b, 0x7b, 0x28, 0xc5, 0xf9, 0xe9, 0xb2, 0xd2, 0x12, 0xaa, 0x74,
0xad, 0xde, 0xfb, 0xbe, 0xc0, 0x1c, 0x96, 0xce, 0x7d, 0xef, 0xf4, 0xf8, 0x5f, 0xf6, 0x75, 0xa9,
0x2f, 0x5d, 0xa4, 0x7d, 0xb0, 0xb3, 0xbc, 0x95, 0x23, 0xd4, 0x19, 0xfd, 0x00, 0xed, 0xf7, 0x05,
0x0a, 0x66, 0x36, 0x58, 0x0f, 0x83, 0xdb, 0x9e, 0x33, 0x35, 0x52, 0x7d, 0x7f, 0xe5, 0xa9, 0x76,
0xe2, 0x6b, 0x67, 0x41, 0xf9, 0x1f, 0x37, 0x8e, 0xd2, 0x16, 0x08, 0x64, 0x3f, 0xff, 0xd5, 0x09,
0x21, 0xa9, 0xf5, 0xcc, 0xd6, 0x33, 0x97, 0x17, 0xfd, 0x01, 0x2b, 0xf8, 0xf6, 0xe7, 0xd6, 0xfd,
0xa6, 0xcc, 0x7a, 0xcc, 0xac, 0x69, 0x6e, 0x03, 0x02, 0x32, 0xd1, 0x24, 0xfa, 0x6e, 0xd5, 0xbc,
0x0b, 0x38, 0x9b, 0x46, 0xdc, 0x88, 0x84, 0x55, 0x5c, 0x44, 0x4d, 0x87, 0xac, 0xb4, 0xc4, 0x23,
0xda, 0x69, 0x74, 0x85, 0xb6, 0xca, 0xce, 0xec, 0x0a, 0x0e, 0x74, 0x2d, 0xff, 0x87, 0x6f, 0xa6,
0xf3, 0xc2, 0xcb, 0x64, 0x5e, 0x5c, 0x4f, 0xde, 0xb0, 0x2b, 0xb7, 0x16, 0x0f, 0x4c, 0xea, 0x5f,
0x45, 0x6f, 0x50, 0x9c, 0xc8, 0x3c, 0x4e, 0xb4, 0x0a, 0xb2, 0xbb, 0xf7, 0xf4, 0xa3, 0x28, 0x72,
0xe3, 0x0b, 0xed, 0x4e, 0x9d, 0x06, 0x95, 0xbd, 0xc5, 0x14, 0x29, 0x0a, 0x34, 0x97, 0xdb, 0x2e,
0xa7, 0x85, 0xcd, 0xa5, 0x95, 0xdc, 0x05, 0x0d, 0xea, 0xaa, 0x2f, 0x25, 0x48, 0xca, 0x69, 0xa4,
0xaa, 0xec, 0x34, 0xae, 0x68, 0x1a, 0x93, 0x2f, 0x84, 0x96, 0xa8, 0x50, 0x48, 0x89, 0x44, 0x62,
0xa9, 0xcf, 0x20, 0x8d, 0xfa, 0x38, 0x41, 0x56, 0xf4, 0xb8, 0x86, 0xce, 0x15, 0xcc, 0x25, 0xfb,
0xe1, 0xa2, 0x1a, 0x4b, 0x49, 0x80, 0x64, 0x37, 0x60, 0x3c, 0xb3, 0x67, 0xee, 0x48, 0xf0, 0xfd,
0x0e, 0x92, 0x57, 0x68, 0xf4, 0xf1, 0x57, 0x9c, 0x73, 0x9c, 0xe7, 0xc8, 0x1d, 0xa0, 0x10, 0xf4,
0x0d, 0x38, 0x06, 0x41, 0x7a, 0x60, 0x6e, 0x37, 0xc5, 0x50, 0x62, 0xbe, 0x4e, 0x59, 0x3a, 0xba,
0x70, 0x43, 0xc5, 0x51, 0xec, 0x7b, 0xb5, 0xa2, 0xb8, 0x88, 0x4d, 0xb2, 0xf7, 0x11, 0xe0, 0xa3,
0x04, 0xd0, 0xe7, 0x0b, 0x37, 0xa4, 0xf3, 0xa1, 0xb1, 0x15, 0xa0, 0x1f, 0x03, 0x8f, 0xeb, 0xa2,
0x50, 0x58, 0x93, 0x49, 0xa8, 0x0b, 0x20, 0x23, 0x3c, 0x3f, 0xd7, 0xc3, 0xf1, 0xac, 0x40, 0x46,
0x9e, 0xf6, 0xa7, 0x34, 0x22, 0xd8, 0x39, 0x2e, 0x7b, 0xb2, 0x1d, 0x81, 0x36, 0x63, 0x4b, 0x37,
0x5d, 0x22, 0x6a, 0x74, 0x21, 0x7a, 0x9a, 0xc9, 0x96, 0x2d, 0xaa, 0x6a, 0xa3, 0x42, 0x23, 0x63,
0xfc, 0xe1, 0x2c, 0xba, 0x79, 0x9c, 0x9f, 0xf6, 0x07, 0x04, 0xdd, 0xcc, 0xed, 0xf5, 0x21, 0x54,
0xf9, 0xf4, 0x4d, 0xb6, 0xe7, 0x78, 0xd5, 0x0a, 0xc7, 0x16, 0x93, 0x00, 0x7b, 0x30, 0xc9, 0x33,
0xa6, 0x39, 0xa8, 0x07, 0x32, 0xeb, 0xf9, 0x3c, 0x6a, 0xee, 0x85, 0xbe, 0x6e, 0x27, 0xd2, 0x15,
0xa0, 0xbd, 0x14, 0xac, 0x7a, 0x14, 0xf6, 0xea, 0xcd, 0xda, 0xdd, 0x75, 0xf2, 0x66, 0xbf, 0xef,
0x56, 0x06, 0x09, 0xbc, 0xab, 0x64, 0x6b, 0xf6, 0x7e, 0x14, 0x9f, 0x84, 0x4d, 0x63, 0xd3, 0xc9,
0x85, 0x94, 0x44, 0x84, 0xeb, 0xae, 0x5f, 0xd2, 0xba, 0xfa, 0xd7, 0xf5, 0x60, 0x17, 0x84, 0xd9,
0x15, 0xc8, 0x54, 0x6c, 0x57, 0x69, 0x82, 0xc1, 0xe7, 0xd8, 0xfa, 0xcd, 0x67, 0x2a, 0x3c, 0xbe,
0x5d, 0xd4, 0x4a, 0xfd, 0xa6, 0x0a, 0xa6, 0x8a, 0xfa, 0xbb, 0x2e, 0x3b, 0x05, 0xaa, 0xc2, 0xd9,
0x9a, 0x54, 0x7a, 0xc0, 0x27, 0x15, 0x97, 0xda, 0x59, 0xd7, 0x24, 0x08, 0x6a, 0x92, 0xd4, 0xee,
0x31, 0xf2, 0x6c, 0x1f, 0x19, 0xe6, 0x9d, 0x3e, 0xab, 0xa6, 0x47, 0xb3, 0xab, 0x66, 0x81, 0xa3,
0x2a, 0xda, 0x66, 0xf4, 0x4e, 0x54, 0xe5, 0xcc, 0x58, 0x8c, 0x56, 0x74, 0xc3, 0xb4, 0x96, 0x43,
0x9f, 0x3d, 0x2a, 0x73, 0x97, 0xcb, 0x75, 0xf1, 0x54, 0x75, 0x0b, 0x7a, 0xce, 0x12, 0xb2, 0x3f,
0x22, 0xfe, 0xc3, 0x99, 0x14, 0xd4, 0x8b, 0x52, 0x8d, 0xc2, 0x33, 0xe2, 0xfb, 0x28, 0xfd, 0xc0,
0xec, 0x55, 0x88, 0x09, 0xd8, 0x3a, 0x70, 0xf4, 0x13, 0x46, 0xe6, 0x39, 0x65, 0x25, 0x19, 0xbb,
0x2a, 0xc4, 0x9e, 0x79, 0x11, 0xac, 0x58, 0xd3, 0x43, 0x12, 0x2b, 0x58, 0xe6, 0xad, 0x70, 0x6f,
0x03, 0xfc, 0xf2, 0xd0, 0x13, 0x69, 0xd6, 0xe2, 0x97, 0x49, 0xbd, 0xe9, 0x76, 0x3d, 0x5e, 0xd7,
0xf1, 0xae, 0x3a, 0xab, 0xa3, 0xa9, 0xbe, 0x25, 0x4f, 0xdd, 0xf3, 0xdd, 0x85, 0xd8, 0xad, 0x3c,
0x86, 0xe2, 0x32, 0x1d, 0xd9, 0x42, 0x04, 0x66, 0x48, 0x90, 0xfb, 0x69, 0x3d, 0x84, 0x03, 0xa0,
0xc2, 0x1d, 0x35, 0xcb, 0xd9, 0xf3, 0xc7, 0xa6, 0x4a, 0x49, 0x68, 0x5e, 0x6e, 0xa6, 0x09, 0x89,
0xa6, 0x3f, 0xb5, 0xc4, 0x15, 0x9a, 0xb5, 0x9b, 0xa8, 0x7c, 0xe8, 0x23, 0x8e, 0x1c, 0x9a, 0xaa,
0xf5, 0x2b, 0xf2, 0xfa, 0x74, 0x54, 0x8d, 0xe7, 0xfa, 0x23, 0x70, 0x31, 0x0e, 0x42, 0xfc, 0xad,
0x55, 0x68, 0x97, 0x79, 0xf0, 0xf4, 0xa7, 0xed, 0x91, 0x78, 0xac, 0xe6, 0x84, 0x55, 0xf8, 0x27,
0x22, 0x3d, 0xcb, 0x44, 0xb7, 0x44, 0xe9, 0xa8, 0xe4, 0x68, 0xc2, 0xa1, 0xbd, 0x8d, 0xec, 0x48,
0xa1, 0x07, 0x23, 0x66, 0xbd, 0x2b, 0x4b, 0x32, 0x49, 0xb2, 0x61, 0x84, 0x6b, 0xb3, 0x46, 0xbf,
0xbb, 0x5d, 0x21, 0xe0, 0x84, 0x1c, 0x43, 0x35, 0xb9, 0x45, 0x58, 0x24, 0xa0, 0x83, 0xac, 0xb8,
0x9d, 0xa3, 0x1d, 0xa4, 0xd5, 0x2c, 0x67, 0x2a, 0x6a, 0x44, 0x57, 0xc4, 0x12, 0x64, 0x5f, 0xb2,
0xa6, 0xa9, 0x53, 0x24, 0xa0, 0x19, 0x37, 0x08, 0x33, 0x1e, 0x91, 0x5f, 0x8f, 0x44, 0x55, 0xf2,
0xb8, 0x0b, 0x39, 0xac, 0x26, 0x4a, 0x4e, 0x8d, 0xbc, 0xbf, 0x59, 0x85, 0xa9, 0x5e, 0x04, 0x4f,
0x30, 0x48, 0x7f, 0xac, 0x37, 0x1b, 0x44, 0x2b, 0xac, 0x48, 0xc1, 0x07, 0xec, 0xc8, 0x9d, 0xc6,
0x59, 0x6f, 0x4b, 0xa2, 0x56, 0x0a, 0xba, 0x77, 0xbe, 0x84, 0xba, 0x63, 0x43, 0xb4, 0xd9, 0xa7,
0xa8, 0xaf, 0x17, 0xc9, 0x3e, 0xa1, 0xfc, 0xc9, 0xf1, 0x86, 0x85, 0x25, 0x0e, 0x81, 0x1c, 0x25,
0x1a, 0x6d, 0x36, 0x89, 0x7e, 0xe8, 0x63, 0x46, 0x55, 0x3a, 0x99, 0x50, 0xa6, 0xbf, 0xef, 0x72,
0x5f, 0xb6, 0x48, 0x7d, 0x5e, 0x40, 0x7f, 0x21, 0x81, 0xbc, 0x0d, 0x0b, 0xad, 0x57, 0xdc, 0x4d,
0xbe, 0x7c, 0x7d, 0x54, 0x18, 0x34, 0xf3, 0x40, 0xc2, 0xc9, 0x93, 0xf1, 0x50, 0x23, 0xcd, 0x18,
0x68, 0xf0, 0xad, 0x52, 0x9d, 0x90, 0x07, 0x8d, 0x5f, 0x60, 0xca, 0xb2, 0xb6, 0x35, 0x3a, 0xe5,
0xe7, 0x80, 0x44, 0xd3, 0x62, 0x12, 0x25, 0x0d, 0x0c, 0xc5, 0x8c, 0x39, 0x3e, 0x59, 0x1c, 0x70,
0x76, 0x99, 0x8a, 0x29, 0x4b, 0xbe, 0x09, 0x58, 0x19, 0x99, 0xaa, 0x7f, 0x78, 0x2b, 0xc8, 0x55,
0x9e, 0xd6, 0xef, 0x18, 0xb9, 0xd7, 0xd2, 0x47, 0x8c, 0xdd, 0xbd, 0x80, 0xed, 0x9b, 0x79, 0x80,
0x46, 0x35, 0x1c, 0xbb, 0x4b, 0xbd, 0x14, 0x6f, 0x68, 0x87, 0x26, 0x34, 0xf6, 0x76, 0x3f, 0x47,
0x67, 0xa1, 0x19, 0x4e, 0x46, 0x91, 0xc0, 0x37, 0xa3, 0xd3, 0x4d, 0xdd, 0x54, 0xd4, 0x5a, 0x2b,
0x7d, 0xad, 0x42, 0x0d, 0x35, 0x9a, 0xca, 0xd9, 0x61, 0x9a, 0xf4, 0x52, 0x51, 0x94, 0x4b, 0xa2,
0x08, 0xde, 0xa8, 0x4b, 0xe9, 0xe6, 0x7f, 0x93, 0xa0, 0x7c, 0x7b, 0x39, 0x59, 0xc8, 0xc2, 0xa3,
0xc7, 0x46, 0xf0, 0x99, 0xdb, 0x62, 0x57, 0x01, 0x91, 0x20, 0xe6, 0x8d, 0x14, 0xc1, 0x13, 0xfd,
0xd1, 0x5d, 0x84, 0xb7, 0xf5, 0xd3, 0x56, 0x49, 0x6d, 0x32, 0x24, 0x1a, 0x4e, 0xbd, 0x19, 0xb0,
0x90, 0x12, 0x32, 0x2f, 0x89, 0x72, 0x66, 0xc3, 0x2a, 0x18, 0x44, 0xea, 0x6e, 0x6c, 0x28, 0x20,
0x8e, 0x59, 0x93, 0xc2, 0x9b, 0x94, 0xea, 0x6f, 0x85, 0x32, 0xff, 0x4a, 0xce, 0xd6, 0x20, 0x8d,
0x43, 0x24, 0x8c, 0xf1, 0x48, 0xec, 0x63, 0x95, 0xd3, 0x26, 0xb5, 0xc0, 0xc4, 0xe9, 0xdc, 0x95,
0x66, 0xef, 0xd8, 0xf3, 0x82, 0x1c, 0xf0, 0x5b, 0xb5, 0xf0, 0xd9, 0x8e, 0x8b, 0x62, 0xd8, 0x81,
0xd1, 0xd6, 0x17, 0xca, 0x22, 0x79, 0x11, 0xcd, 0x09, 0x1d, 0x66, 0x80, 0xdf, 0xe4, 0xc3, 0x17,
0x30, 0x27, 0x15, 0x7a, 0x22, 0x42, 0xa2, 0x21, 0x24, 0x6f, 0x63, 0xb3, 0xb1, 0x18, 0x03, 0x30,
0xb1, 0x5e, 0x9d, 0x79, 0xeb, 0xaf, 0x24, 0x3c, 0xc7, 0xaf, 0x3b, 0x5b, 0xac, 0xf1, 0xdf, 0x9f,
0x3d, 0xfa, 0x52, 0xae, 0x91, 0x0b, 0xe0, 0x2e, 0x93, 0x6f, 0x6b, 0xac, 0x5b, 0xe3, 0x3c, 0x0d,
0x2a, 0x95, 0x89, 0x12, 0xa5, 0x6b, 0xb7, 0xdc, 0xc7, 0x22, 0xac, 0xce, 0xe9, 0xf6, 0x08, 0xe9,
0x16, 0xcf, 0x03, 0x4a, 0xdb, 0x43, 0x47, 0x82, 0x4e, 0x55, 0x46, 0x20, 0x4b, 0xeb, 0xc4, 0xd6,
0x0e, 0xc1, 0xff, 0xb7, 0x40, 0x4d, 0xfb, 0x49, 0xc0, 0xbb, 0xdb, 0x4e, 0xa3, 0x64, 0x36, 0x7c,
0x69, 0xe6, 0xf4, 0x1b, 0xad, 0x4f, 0xa5, 0xcf, 0x68, 0xd2, 0xbc, 0x71, 0x18, 0xad, 0xbc, 0x35,
0xab, 0x4e, 0xd2, 0xcd, 0x26, 0xe8, 0x27, 0x82, 0xc5, 0x37, 0xeb, 0x90, 0xa1, 0x4d, 0x2a, 0xf7,
0xf5, 0x40, 0xf9, 0x28, 0xc8, 0x96, 0x9b, 0xa4, 0xff, 0x4f, 0x6f, 0x1e, 0x6b, 0x51, 0xa5, 0xc1,
0xe1, 0x11, 0xba, 0x00, 0xa8, 0x63, 0xc6, 0xd1, 0xaa, 0x97, 0x61, 0x6d, 0xb2, 0xf1, 0x2f, 0x9b,
0x90, 0x32, 0xd8, 0x6b, 0xba, 0x00, 0xa7, 0xcb, 0xe1, 0xcd, 0xb7, 0xb8, 0x80, 0x5b, 0x60, 0x9a,
0x04, 0xb1, 0x59, 0x00, 0x1f, 0x45, 0xc7, 0x2a, 0x08, 0xcb, 0xc1, 0xee, 0x0d, 0xb4, 0x71, 0xdf,
0x7a, 0xdc, 0xa6, 0xbb, 0xfe, 0xa0, 0x4d, 0x49, 0xbb, 0x2c, 0x13, 0x25, 0x2e, 0x9f, 0x55, 0xaa,
0x73, 0x16, 0x39, 0xd5, 0x83, 0x35, 0x2f, 0xb4, 0xef, 0x69, 0x9e, 0x3e, 0x4c, 0x67, 0x00, 0x05,
0x59, 0xc3, 0x38, 0x77, 0x1e, 0x9d, 0x93, 0xfa, 0x3f, 0x49, 0x9f, 0x58, 0x1d, 0xa3, 0x05, 0xec,
0xd7, 0x51, 0x30, 0xe1, 0x34, 0x83, 0xb3, 0xd1, 0x54, 0x84, 0x63, 0xd6, 0xb7, 0x0c, 0x61, 0xa5,
0x36, 0x12, 0xf8, 0x6d, 0xc6, 0xb8, 0xdc, 0x5d, 0x97, 0x9a, 0x7a, 0x81, 0xaa, 0x39, 0xfa, 0xef,
0x46, 0x82, 0x7c, 0xc0, 0x5b, 0xbe, 0x66, 0xd9, 0x06, 0xe5, 0xe1, 0x91, 0xdb, 0xa6, 0x33, 0x80,
0x69, 0x8c, 0xcd, 0x9d, 0x52, 0x59, 0x95, 0x06, 0xa5, 0x26, 0x62, 0x38, 0xa0, 0x20, 0x6b, 0x98,
0x14, 0xed, 0xf2, 0xda, 0x70, 0x10, 0x6c, 0x79, 0x6b, 0x4c, 0x18, 0xa4, 0x72, 0x08, 0x27, 0x8b,
0x42, 0x27, 0x4f, 0x0a, 0x0c, 0xf1, 0xe6, 0x5d, 0x0b, 0xda, 0x6c, 0x2c, 0x18, 0x91, 0xbe, 0x62,
0xfe, 0x2f, 0xee, 0xdf, 0x12, 0xcb, 0x16, 0xcc, 0x73, 0x4a, 0x13, 0xe9, 0x31, 0x3b, 0xbe, 0x68,
0x2d, 0x1c, 0xa0, 0xfc, 0x70, 0x11, 0x45, 0xcd, 0x47, 0x6c, 0x3e, 0x6f, 0xdc, 0xc6, 0xa3, 0x25,
0x0e, 0xa5, 0xff, 0xff, 0x3d, 0x55, 0x04, 0xbc, 0xfe, 0x60, 0x3d, 0xbd, 0x31, 0x95, 0xa5, 0x02,
0xdc, 0x42, 0x26, 0x15, 0x6f, 0x33, 0x77, 0x67, 0xb2, 0x36, 0x46, 0x1d, 0x1c, 0x3e, 0x2b, 0x80,
0x59, 0xac, 0x12, 0xa8, 0x0f, 0x64, 0xb3, 0xa9, 0x8b, 0x58, 0xef, 0x27, 0x43, 0xcc, 0x99, 0x7e,
0x38, 0x61, 0xcb, 0x47, 0xbe, 0x1f, 0x00, 0xe5, 0x2a, 0xb2, 0x1b, 0x56, 0x56, 0x7c, 0xfe, 0xcb,
0x0a, 0x89, 0xf6, 0xfc, 0x83, 0xe8, 0x82, 0xf2, 0xbe, 0xc8, 0xca, 0x32, 0xf0, 0x9c, 0x7a, 0x84,
0x4f, 0xef, 0xc0, 0xdf, 0x99, 0xf5, 0x7b, 0x51, 0xd6, 0x4f, 0x9d, 0xac, 0xb0, 0x28, 0x6b, 0x0c,
0x47, 0x12, 0xc0, 0xf8, 0x79, 0xec, 0x6f, 0x7a, 0x7c, 0xa6, 0x37, 0xd2, 0xe2, 0x8a, 0x74, 0x45,
0x5a, 0x49, 0x7b, 0xb2, 0x74, 0x96, 0xb4, 0x9f, 0xeb, 0x3d, 0x45, 0x8e, 0x4d, 0x7e, 0x67, 0x97,
0x06, 0x9a, 0x8c, 0xac, 0x43, 0x55, 0xa1, 0x9a, 0x60, 0xb9, 0xa1, 0x79, 0xcd, 0xa2, 0xef, 0x72,
0x45, 0xe3, 0x79, 0xab, 0x6f, 0x7a, 0xa1, 0x9e, 0x11, 0x88, 0x14, 0xe8, 0xce, 0xd1, 0xce, 0x52,
0x5c, 0x4d, 0xa6, 0xf8, 0x78, 0x71, 0x26, 0xb0, 0x56, 0xcf, 0xdc, 0x87, 0xb9, 0xc1, 0xf0, 0xdf,
0x71, 0x4b, 0xfb, 0x9c, 0x9e, 0xce, 0x2d, 0x32, 0x85, 0xd4, 0x89, 0x1f, 0x1e, 0x42, 0x3f, 0xd4,
0x75, 0xfa, 0x41, 0x1d, 0x9f, 0x47, 0x9e, 0x4b, 0x3a, 0x71, 0xdf, 0x8d, 0x5a, 0x9a, 0x3a, 0x94,
0x46, 0xe0, 0xe6, 0x10, 0xcf, 0x6b, 0xe1, 0x37, 0x94, 0x2b, 0x18, 0xbd, 0x41, 0x18, 0x06, 0xdd,
0x1d, 0x3c, 0x57, 0x9f, 0x42, 0xcc, 0x1b, 0xfa, 0x0b, 0x2b, 0xc8, 0xb4, 0x14, 0x3c, 0x2d, 0x4b,
0x90, 0x23, 0xf3, 0xcf, 0xca, 0x8d, 0x14, 0x2d, 0xcd, 0x3a, 0x5d, 0x4e, 0x30, 0x72, 0x87, 0x4b,
0xd7, 0xe0, 0xf1, 0x2d, 0x0c, 0x20, 0xd4, 0x9d, 0x58, 0xa2, 0xf2, 0x1b, 0x7b, 0xa5, 0x99, 0x55,
0x4a, 0x1a, 0xe8, 0x56, 0xf6, 0xa8, 0x2a, 0x79, 0xc9, 0xb5, 0x6a, 0x35, 0x41, 0x0a, 0x74, 0x84,
0xca, 0x13, 0xdc, 0x9d, 0x6f, 0xae, 0x69, 0x4a, 0x11, 0xa2, 0x51, 0x65, 0x26, 0x80, 0x8f, 0x7a,
0x24, 0xd4, 0x4f, 0x51, 0xe1, 0x4e, 0xa9, 0x1c, 0xe5, 0x2a, 0x5e, 0x64, 0x0e, 0x8b, 0x8d, 0xf9,
0xa9, 0x8b, 0x5d, 0x65, 0x05, 0xe1, 0xf6, 0xc4, 0x8d, 0x47, 0x3d, 0x9a, 0xc8, 0xdc, 0x58, 0xb6,
0x8a, 0x68, 0x30, 0x9b, 0x03, 0x8d, 0x21, 0x3c, 0xa8, 0x40, 0x7b, 0x57, 0x69, 0xec, 0xbc, 0xcf,
0x5e, 0x20, 0x3d, 0x30, 0xd7, 0x55, 0x5c, 0x51, 0xd4, 0x39, 0x4e, 0xf0, 0x01, 0xca, 0x68, 0x20,
0xec, 0x78, 0x8a, 0xf0, 0x54, 0x56, 0xe3, 0xa7, 0x87, 0x58, 0xcc, 0x1d, 0x15, 0xe5, 0x3d, 0x0b,
0x76, 0x21, 0x05, 0xd8, 0xcd, 0x60, 0x38, 0x3f, 0x6c, 0x20, 0xc7, 0x56, 0xe8, 0x3c, 0x9c, 0x54,
0xc4, 0xd1, 0x17, 0x36, 0xce, 0xaa, 0x69, 0xbc, 0x4d, 0x43, 0x90, 0x80, 0x7d, 0xf9, 0xd3, 0x2c,
0x46, 0x0c, 0x9e, 0x02, 0x91, 0xbb, 0x51, 0x9b, 0x45, 0x3f, 0xe2, 0xc0, 0x8c, 0x35, 0xc7, 0x98,
0xb9, 0xe1, 0xc6, 0x5f, 0x26, 0x40, 0xa7, 0x4e, 0x01, 0xa9, 0xae, 0x28, 0xd1, 0x05, 0xaa, 0xe9,
0x8e, 0xc4, 0x68, 0xb6, 0xe4, 0x01, 0x9a, 0x3c, 0x6c, 0x55, 0x3e, 0x39, 0x2c, 0x7e, 0xee, 0x48,
0xda, 0x2d, 0x4e, 0xb1, 0xd6, 0x3e, 0xb9, 0xfc, 0x91, 0x36, 0x77, 0xb1, 0xaf, 0x8d, 0x92, 0xca,
0xb3, 0xbc, 0xc6, 0x88, 0xfc, 0xe8, 0x2e, 0xa5, 0x6b, 0x63, 0xc3, 0xe4, 0xd3, 0xbf, 0xd0, 0xe9,
0x55, 0x3d, 0x97, 0x69, 0x7a, 0xf7, 0xa6, 0x4d, 0x96, 0xb7, 0x37, 0x22, 0x86, 0x39, 0x72, 0x2a,
0x4f, 0x96, 0xf7, 0x9e, 0x99, 0xf6, 0x8f, 0x71, 0xec, 0xee, 0x0e, 0xe7, 0x85, 0x04, 0xd3, 0x06,
0xd5, 0xe8, 0x13, 0xe0, 0x9c, 0x2a, 0xef, 0x3e, 0x2d, 0xdd, 0x08, 0x89, 0x43, 0x3e, 0x93, 0xe2,
0x9e, 0x17, 0xbc, 0xd6, 0x0f, 0xbd, 0x72, 0x93, 0xd0, 0x79, 0xcf, 0xd8, 0xce, 0x3c, 0x28, 0x45,
0x73, 0x49, 0x1c, 0x89, 0x76, 0xeb, 0x1c, 0xc9, 0x1f, 0xb9, 0x4c, 0xf2, 0x2b, 0x22, 0x40, 0xef,
0xe1, 0x03, 0xd0, 0x5b, 0xb4, 0x60, 0xb4, 0x39, 0x7b, 0x63, 0x24, 0xba, 0x1a, 0x32, 0xc8, 0x50,
0xbb, 0x39, 0x10, 0xe6, 0x26, 0x36, 0x82, 0x37, 0x04, 0xd1, 0x33, 0x32, 0x4e, 0x01, 0x02, 0x1e,
0x6b, 0x15, 0xc9, 0x6a, 0xf9, 0x59, 0x28, 0x90, 0x3b, 0xa9, 0xb0, 0xf8, 0x31, 0x00, 0xbd, 0xa8,
0xe3, 0x26, 0x42, 0x89, 0xfe, 0x84, 0xfb, 0xab, 0xb9, 0xc1, 0x31, 0xca, 0x04, 0xcf, 0x72, 0x9b,
0x44, 0xa7, 0xd5, 0x5b, 0x43, 0x93, 0x51, 0x17, 0x73, 0x02, 0x64, 0x98, 0xd0, 0xfd, 0x23, 0x0f,
0x6d, 0x50, 0x30, 0x9f, 0xaa, 0xaf, 0xc7, 0x7b, 0x7c, 0x4b, 0xa1, 0x94, 0xd4, 0x0e, 0xa3, 0x8f,
0xe5, 0x1c, 0xf9, 0x2a, 0xf8, 0xe4, 0x7f, 0xd2, 0x75, 0x31, 0xfa, 0x7d, 0x50, 0x4d, 0x1c, 0x47,
0x8d, 0x50, 0x31, 0xd4, 0x97, 0x08, 0xb2, 0x57, 0x83, 0xaf, 0x99, 0x6c, 0x54, 0xb0, 0x6a, 0x91,
0xf1, 0x3d, 0xf3, 0x99, 0x7e, 0x6d, 0x35, 0xc7, 0xee, 0x09, 0xa2, 0xf7, 0x5e, 0xba, 0x4a, 0x50,
0x8c, 0xbe, 0xd0, 0x74, 0x66, 0x18, 0xcb, 0x94, 0x44, 0xbf, 0x48, 0x9f, 0x35, 0xde, 0xe8, 0x68,
0x2b, 0x4c, 0x1e, 0x2a, 0x27, 0x33, 0x0c, 0x1c, 0x12, 0x27, 0xd3, 0x54, 0x77, 0xc3, 0xba, 0x51,
0xfe, 0xf9, 0x22, 0xcb, 0x11, 0x6d, 0x03, 0xbe, 0xad, 0x35, 0x3d, 0x8c, 0x8a, 0x9a, 0x18, 0x0a,
0xbb, 0x97, 0xf5, 0xa3, 0x77, 0x10, 0xa1, 0x8a, 0x65, 0x9c, 0x50, 0x41, 0xdf, 0xcf, 0x41, 0xf0,
0x26, 0xb5, 0x40, 0xa7, 0x87, 0xbe, 0xdb, 0x61, 0xce, 0x19, 0x75, 0x8d, 0xa3, 0x25, 0x14, 0x70,
0x40, 0x2a, 0x51, 0x7c, 0x4b, 0x40, 0x05, 0x48, 0x90, 0x65, 0xcc, 0x52, 0x40, 0x9f, 0xe6, 0x66,
0x0c, 0xa7, 0x35, 0xe3, 0xc3, 0x74, 0x10, 0x60, 0x45, 0x9e, 0xef, 0x1b, 0x10, 0xf0, 0x00, 0x76,
0x8f, 0xf0, 0x4d, 0x7e, 0x11, 0x49, 0x1b, 0x6a, 0x4e, 0xcf, 0xc9, 0xde, 0x0e, 0x53, 0x99, 0x24,
0x26, 0x77, 0xaf, 0x74, 0x0d, 0x9c, 0x22, 0xd8, 0x49, 0x8c, 0x7b, 0x8b, 0x99, 0x45, 0xfe, 0x03,
0xf4, 0x63, 0xe0, 0xf0, 0x15, 0xf9, 0x94, 0xd4, 0x4a, 0xc0, 0xcd, 0x06, 0xaf, 0xee, 0x6d, 0x27,
0xae, 0xcc, 0xa7, 0x30, 0xae, 0x04, 0x63, 0xca, 0x32, 0x35, 0x92, 0x4c, 0xed, 0xcb, 0x61, 0x9b,
0xfe, 0x3e, 0x6d, 0x05, 0x33, 0x26, 0xee, 0xaa, 0x90, 0xb1, 0x43, 0x70, 0x38, 0x98, 0x94, 0x46,
0xfd, 0x10, 0x1e, 0xdf, 0xe8, 0x8e, 0x25, 0x63, 0x90, 0x6f, 0x73, 0xc3, 0xc8, 0x91, 0x17, 0xad,
0x75, 0xf4, 0x0e, 0x98, 0x81, 0x40, 0x63, 0xb8, 0x30, 0xae, 0x1b, 0xc4, 0x07, 0xe6, 0x61, 0x23,
0xc1, 0x99, 0x18, 0x73, 0xd6, 0xa8, 0xee, 0x69, 0xa3, 0xec, 0x03, 0x8a, 0x46, 0x44, 0x52, 0x9a,
0x24, 0xe2, 0xc7, 0x50, 0xe4, 0xf4, 0xe2, 0xbd, 0x35, 0x41, 0xd7, 0x52, 0x6d, 0xb3, 0x49, 0xcf,
0x14, 0xc0, 0x73, 0xc8, 0x8e, 0xf6, 0x49, 0xf3, 0x35, 0xf9, 0x76, 0x20, 0x27, 0x82, 0x77, 0xae,
0xba, 0x6e, 0xc6, 0xba, 0x9d, 0xe1, 0x1e, 0xee, 0x87, 0x50, 0x56, 0x6a, 0x38, 0xfb, 0xc6, 0x0b,
0xd2, 0x8a, 0x17, 0x48, 0x28, 0x51, 0x5a, 0xa4, 0xbb, 0x7f, 0x4e, 0xb8, 0xc3, 0x26, 0x07, 0x24,
0xa6, 0x4a, 0x41, 0xf2, 0x5f, 0x75, 0xa1, 0x2b, 0x86, 0xc7, 0x29, 0xba, 0xac, 0x5f, 0x02, 0xec,
0xac, 0x9b, 0xa9, 0x7f, 0x89, 0xea, 0x53, 0xc1, 0x12, 0xe1, 0x34, 0xde, 0xe5, 0xd3, 0x7f, 0x5d,
0x16, 0x51, 0xba, 0xed, 0xda, 0xf8, 0x3a, 0xe8, 0x84, 0xfe, 0xde, 0xf0, 0x83, 0xbd, 0x10, 0xa3,
0xcf, 0xdc, 0x2f, 0x25, 0xe0, 0x94, 0x0a, 0x30, 0xda, 0x62, 0x31, 0xd5, 0x7e, 0xa3, 0xfb, 0xe0,
0xe0, 0x2d, 0x26, 0xe9, 0x14, 0xa2, 0x6f, 0x4e, 0x19, 0xf5, 0x09, 0xba, 0x67, 0x89, 0x79, 0x6f,
0x14, 0xe0, 0xd6, 0xac, 0x94, 0x2d, 0x65, 0x10, 0x76, 0x62, 0xb9, 0xa3, 0xcd, 0x20, 0xfe, 0xeb,
0x10, 0x5c, 0xe0, 0x75, 0xd3, 0x5d, 0xad, 0x39, 0x07, 0xd9, 0x1d, 0x6e, 0xb0, 0xe5, 0xa5, 0x79,
0x0d, 0xc3, 0xb9, 0xdd, 0xca, 0xbb, 0xa0, 0x5d, 0xa0, 0x16, 0xb6, 0xb9, 0xd6, 0x4c, 0xdb, 0x6f,
0xb2, 0x5a, 0xa9, 0x55, 0x00, 0x96, 0x14, 0xec, 0x31, 0xe6, 0x79, 0x0f, 0xd1, 0x9d, 0xde, 0xbb,
0x27, 0x8d, 0x44, 0xee, 0xec, 0xf2, 0xa3, 0x80, 0xbb, 0x21, 0xd3, 0xe7, 0xd3, 0xbe, 0xb3, 0x86,
0x6c, 0xa8, 0x7a, 0xab, 0xbf, 0xa7, 0x22, 0xcd, 0x4c, 0x25, 0x36, 0x03, 0x02, 0xe4, 0x11, 0xbf,
0xed, 0x06, 0x90, 0x0c, 0xf0, 0x30, 0xc7, 0x86, 0x7e, 0xaa, 0xc5, 0x84, 0x14, 0x54, 0xf7, 0x56,
0x17, 0x02, 0x88, 0xf5, 0xe1, 0xe7, 0xa7, 0xef, 0xe6, 0x71, 0xbc, 0x65, 0x65, 0x1e, 0x40, 0x97,
0x86, 0x5f, 0x8c, 0x44, 0xda, 0xa1, 0x38, 0x54, 0x1e, 0xdd, 0x39, 0xaa, 0x9e, 0x9e, 0xa6, 0x41,
0x4a, 0xf3, 0xb6, 0xde, 0x19, 0x74, 0x00, 0xfc, 0x2f, 0xf6, 0x0c, 0x00, 0x95, 0xfb, 0x50, 0x66,
0xa9, 0xc2, 0x3f, 0xaa, 0x48, 0x00, 0xa1, 0x4d, 0x6a, 0x80, 0x03, 0x00, 0x96, 0xcf, 0x1b, 0x9a,
0xb8, 0x9f, 0xde, 0x10, 0x98, 0x3e, 0x37, 0xf4, 0xc3, 0x30, 0xe6, 0xed, 0x7c, 0x2e, 0x53, 0x0e,
0xf4, 0xbe, 0xe2, 0x7e, 0xf6, 0x7d, 0xa7, 0x50, 0x43, 0xd7, 0x33, 0x15, 0xc5, 0x62, 0xae, 0xe5,
0xe2, 0xc5, 0x40, 0xe6, 0xa3, 0x63, 0x0f, 0x85, 0xd2, 0x33, 0xe6, 0x8d, 0xdc, 0x80, 0x3d, 0x79,
0x27, 0x21, 0x9c, 0x4f, 0xae, 0x14, 0x36, 0x4d, 0x36, 0x30, 0xa1, 0x1e, 0xf5, 0x8e, 0xb5, 0xbd,
0xa8, 0xc5, 0xe4, 0xb7, 0x96, 0xed, 0x10, 0x5b, 0x8c, 0xee, 0xc6, 0x8c, 0x93, 0xe9, 0xd9, 0x72,
0xb3, 0x10, 0xd1, 0x3e, 0x5b, 0x31, 0xc1, 0x27, 0xa4, 0x84, 0xe3, 0xc0, 0xf0, 0x1f, 0x27, 0xb7,
0x1f, 0x05, 0xed, 0x7c, 0xcd, 0x65, 0x01, 0xbf, 0x8d, 0x56, 0xe9, 0xfe, 0x9e, 0x53, 0x71, 0x93,
0x6c, 0xe0, 0x9c, 0x6e, 0x99, 0x56, 0xbb, 0x45, 0x87, 0x1f, 0x6a, 0x96, 0xac, 0x24, 0xf9, 0x7f,
0xbf, 0x10, 0x8c, 0x5e, 0x08, 0x12, 0x07, 0xcf, 0x8b, 0x4b, 0xcb, 0xd1, 0x6a, 0xce, 0x3d, 0x92,
0x81, 0x5d, 0x1d, 0x96, 0x72, 0xa8, 0xef, 0xdd, 0xb2, 0x13, 0xa8, 0xc6, 0xea, 0x07, 0x64, 0x8b,
0xd2, 0xe1, 0x79, 0x24, 0x0a, 0xf2, 0x92, 0xa8, 0x37, 0xe2, 0x5c, 0x89, 0xd3, 0x09, 0x60, 0x7d,
0xbf, 0xac, 0xff, 0xde, 0xe6, 0x8b, 0x1b, 0x38, 0x33, 0xd7, 0xa1, 0x9d, 0x05, 0xe8, 0x69, 0x27,
0xd9, 0xb7, 0xae, 0x72, 0xbb, 0x05, 0xee, 0x77, 0x96, 0x48, 0xa2, 0x02, 0x0d, 0x88, 0x1c, 0x4f,
0x22, 0xf9, 0xcd, 0xd3, 0xe1, 0x50, 0x08, 0xb6, 0xea, 0x2a, 0x96, 0x43, 0xf3, 0x8a, 0x92, 0x3b,
0x2b, 0x5e, 0xbc, 0xa0, 0x4f, 0xd3, 0xf1, 0xcc, 0x1c, 0xde, 0xc4, 0x91, 0x35, 0x33, 0x51, 0xe5,
0xe0, 0xa9, 0x75, 0xfe, 0x0a, 0x5d, 0xc8, 0x8b, 0x63, 0x33, 0xd9, 0xe0, 0x73, 0xcb, 0xdb, 0x70,
0x0a, 0x82, 0xb7, 0x7a, 0x5c, 0x27, 0xbf, 0xd1, 0xdc, 0x62, 0xa3, 0x20, 0x63, 0x5f, 0x54, 0x4a,
0xaf, 0xa3, 0xe0, 0x77, 0xbb, 0xcd, 0xab, 0x62, 0x73, 0x31, 0x72, 0x2a, 0x1d, 0x02, 0x87, 0x88,
0x02, 0x24, 0x10, 0x9c, 0x35, 0x5c, 0x72, 0x04, 0x1c, 0x1a, 0xea, 0x44, 0xf4, 0x41, 0xc6, 0x20,
0xde, 0x91, 0xf7, 0x0c, 0x4a, 0xae, 0xca, 0xb7, 0x73, 0x59, 0xf6, 0xdd, 0x8e, 0x58, 0xae, 0x8a,
0xcd, 0x62, 0xa6, 0x22, 0xef, 0x79, 0xbb, 0xf9, 0x4b, 0xf9, 0x71, 0x6b, 0xab, 0xe5, 0x02, 0x13,
0xe3, 0x35, 0xd9, 0xea, 0x95, 0x33, 0x1a, 0x22, 0x1c, 0x45, 0xe6, 0x9b, 0xfb, 0x61, 0xaf, 0x3d,
0xbe, 0xbe, 0x9f, 0xb8, 0x83, 0x33, 0x31, 0x5b, 0x14, 0x38, 0x2d, 0xcf, 0xe7, 0xce, 0xd3, 0xab,
0xca, 0xbc, 0xec, 0x30, 0x17, 0x36, 0x1d, 0x1a, 0xb7, 0x2b, 0xee, 0x53, 0x34, 0xfc, 0x63, 0x9f,
0x95, 0xe1, 0xf0, 0x8b, 0xdb, 0x74, 0x0c, 0x44, 0xd3, 0x04, 0x76, 0x3a, 0x41, 0xdf, 0xd0, 0x8f,
0xa9, 0x93, 0xd6, 0x14, 0x73, 0xc7, 0x7f, 0x2b, 0xa6, 0xb2, 0x79, 0xe4, 0x4a, 0xc8, 0xb0, 0x5e,
0x9a, 0xce, 0xc4, 0xf6, 0x8a, 0xeb, 0x8c, 0xa7, 0x86, 0xa6, 0x4f, 0x5f, 0x48, 0xff, 0xb4, 0x05,
0xf3, 0xc8, 0x81, 0x75, 0x37, 0xd5, 0x8b, 0x40, 0xdf, 0x3e, 0x20, 0x37, 0xf5, 0x5a, 0xcf, 0xbe,
0x6f, 0x7e, 0x22, 0xc4, 0xf7, 0xfa, 0x34, 0x4a, 0x81, 0x0a, 0x44, 0x3d, 0x1d, 0xe9, 0x6c, 0xb1,
0xe1, 0xd6, 0x81, 0xd4, 0x98, 0x7c, 0x65, 0xa2, 0x26, 0x97, 0x84, 0x80, 0x76, 0x58, 0x53, 0x0b,
0x94, 0x82, 0x08, 0x66, 0x80, 0x63, 0xf9, 0x01, 0x4a, 0xee, 0xb5, 0xe2, 0x8a, 0xfa, 0xce, 0xee,
0x7c, 0x97, 0xb6, 0x91, 0xe9, 0xb3, 0x5e, 0x14, 0x50, 0xd5, 0xf1, 0xdf, 0x8f, 0x5d, 0x0e, 0x78,
0x2f, 0xdd, 0xb2, 0x82, 0x98, 0x73, 0xc5, 0xf4, 0x32, 0x1c, 0x65, 0x6d, 0xa4, 0xe3, 0xba, 0xdb,
0xfa, 0x65, 0x37, 0xee, 0x57, 0x2b, 0xfa, 0x38, 0x2f, 0x14, 0x2d, 0xf6, 0x19, 0x0b, 0xe0, 0x59,
0xb9, 0x95, 0x02, 0xfa, 0x2f, 0x84, 0x56, 0x41, 0x76, 0xa3, 0xca, 0x30, 0xf5, 0x4b, 0x97, 0x2d,
0x33, 0x3b, 0x71, 0x09, 0x49, 0x48, 0x46, 0xa0, 0x79, 0xd3, 0xce, 0x32, 0x35, 0xa4, 0xb2, 0x05,
0x5d, 0xaf, 0x1f, 0x22, 0x48, 0xcb, 0xca, 0x5b, 0xaa, 0x69, 0x6e, 0x6f, 0x23, 0x6f, 0xcd, 0x67,
0x06, 0x71, 0xf1, 0x6a, 0x5f, 0x65, 0xbe, 0xb0, 0x5f, 0x7b, 0xec, 0x9e, 0x1d, 0xa4, 0xf2, 0x4b,
0xbc, 0xde, 0xc0, 0x84, 0x87, 0xa3, 0x2f, 0x97, 0x12, 0xc5, 0xf9, 0x34, 0x54, 0x0a, 0xf1, 0x7c,
0x95, 0x16, 0xe7, 0xf9, 0x83, 0x40, 0xcf, 0x42, 0xc9, 0x5b, 0xff, 0x0e, 0x01, 0xf0, 0x1b, 0xe5,
0x75, 0xee, 0x7c, 0x33, 0x1f, 0x00, 0x03, 0x2f, 0x92, 0xa7, 0x3d, 0x51, 0xac, 0x43, 0x67, 0xb8,
0x45, 0x4f, 0xde, 0x10, 0xee, 0xeb, 0x5b, 0x62, 0x65, 0x6b, 0x70, 0xc3, 0x3d, 0x46, 0x1f, 0x00,
0x0f, 0x08, 0xeb, 0xca, 0x33, 0xd5, 0x7d, 0x97, 0x84, 0x88, 0x8a, 0x24, 0x4d, 0x02, 0xcd, 0xee,
0xa0, 0x11, 0xb1, 0x2d, 0xb6, 0xf5, 0x18, 0x68, 0xb5, 0x79, 0x15, 0x5b, 0x44, 0xb3, 0xba, 0x8b,
0x78, 0x28, 0x08, 0x32, 0xf1, 0x25, 0x4f, 0xde, 0x48, 0x80, 0x5e, 0x9f, 0x1b, 0xc9, 0x39, 0xd3,
0x87, 0x9f, 0xae, 0x66, 0xf2, 0x12, 0x92, 0x17, 0xec, 0xaa, 0xbd, 0x00, 0x93, 0x00, 0x09, 0x76,
0xab, 0xfb, 0x2a, 0xda, 0x34, 0xe5, 0xa6, 0x2a, 0xfa, 0x9a, 0x88, 0x39, 0x66, 0xa2, 0x47, 0x2f,
0x71, 0x40, 0xa6, 0x7e, 0x7d, 0x52, 0x1d, 0x12, 0x21, 0x5f, 0xca, 0xe8, 0xba, 0x5a, 0x80, 0x88,
0x5f, 0xb0, 0x1f, 0xc1, 0x12, 0x58, 0xbd, 0x35, 0x13, 0xfb, 0x7d, 0x38, 0xea, 0x5a, 0x79, 0x4f,
0x37, 0x87, 0xd0, 0xbe, 0x92, 0xe1, 0x5b, 0xbe, 0x84, 0x2a, 0x40, 0x13, 0xd1, 0xe1, 0xdf, 0x39,
0x0b, 0x11, 0x45, 0xe9, 0x0e, 0x09, 0x9d, 0xfc, 0xeb, 0xc4, 0xc3, 0xf8, 0x26, 0xbd, 0x80, 0x38,
0xf7, 0x04, 0x13, 0x4f, 0x3c, 0x3d, 0x7e, 0xa3, 0xbe, 0x54, 0x1b, 0x1f, 0xf6, 0xc2, 0x11, 0x93,
0xd9, 0x41, 0x0f, 0x64, 0x3a, 0x1c, 0x6e, 0x19, 0x6e, 0xbf, 0x79, 0x3b, 0xbd, 0xa8, 0x03, 0xae,
0xf2, 0x62, 0x7f, 0xda, 0xf6, 0xe8, 0x84, 0xd9, 0xd9, 0xdb, 0xfd, 0xa2, 0x6a, 0x38, 0x60, 0x2a,
0x30, 0xf2, 0x1f, 0x1f, 0x63, 0xb1, 0x46, 0x7e, 0x78, 0x3e, 0x2c, 0xd9, 0xf4, 0x56, 0xdb, 0xa7,
0x5e, 0x67, 0x8a, 0x16, 0x9b, 0xc8, 0xea, 0x78, 0x35, 0xc2, 0xef, 0x1a, 0xb5, 0x17, 0x4e, 0xba,
0x17, 0x04, 0xb8, 0xd7, 0x70, 0x30, 0xb4, 0x4f, 0xb0, 0x91, 0x92, 0x73, 0x2f, 0x0a, 0xff, 0xd7,
0x8b, 0xcf, 0x43, 0x7d, 0xfe, 0x9e, 0xca, 0xfa, 0x69, 0x12, 0x0f, 0x51, 0xe9, 0xa4, 0x13, 0x6a,
0x2a, 0x4f, 0xaa, 0x5f, 0x13, 0xef, 0x45, 0x05, 0xd9, 0xaa, 0xc8, 0x28, 0x84, 0x7e, 0xc9, 0xca,
0xba, 0x3d, 0x93, 0xb1, 0x38, 0x16, 0x3f, 0xf1, 0x18, 0x1b, 0x32, 0xa8, 0xc2, 0xdf, 0xe3, 0x21,
0x8e, 0x8b, 0x70, 0x6e, 0x58, 0x65, 0x70, 0x93, 0xa5, 0xcc, 0x15, 0x2a, 0xd6, 0xb0, 0xc3, 0xcf,
0x6b, 0xf5, 0x09, 0xa4, 0x6c, 0x29, 0xc7, 0xcd, 0x19, 0xf6, 0x4d, 0x15, 0xb1, 0x77, 0x65, 0xdb,
0x7e, 0x55, 0x24, 0x05, 0x39, 0xa7, 0xf8, 0xdc, 0x16, 0x44, 0xf5, 0xf2, 0x69, 0x9f, 0x6f, 0x8e,
0xaf, 0x6e, 0xfc, 0x9a, 0x75, 0x57, 0x22, 0x2f, 0x33, 0xf8, 0xaa, 0x3d, 0x4e, 0x70, 0x2d, 0x74,
0x33, 0xbc, 0xea, 0xcf, 0x48, 0xe7, 0xb8, 0xd0, 0xf5, 0xda, 0xd3, 0xe3, 0xa7, 0x43, 0x4f, 0xdd,
0x7c, 0x80, 0x07, 0x69, 0xc9, 0x2d, 0x2c, 0x58, 0xa1, 0x4d, 0x9c, 0xd7, 0x20, 0xb6, 0xaf, 0xb0,
0x5f, 0x3d, 0x5b, 0x35, 0x3f, 0xf4, 0x51, 0x52, 0x47, 0xc5, 0xaa, 0x9c, 0x4d, 0x9c, 0xa4, 0x73,
0x35, 0xd9, 0xa0, 0xa4, 0x52, 0x0a, 0x7b, 0xcb, 0x6c, 0xef, 0xb4, 0x65, 0x06, 0xc4, 0x95, 0x3b,
0x59, 0xf2, 0xd1, 0x09, 0x0b, 0x22, 0x9c, 0x72, 0xac, 0x4d, 0xb1, 0xb6, 0x3b, 0x72, 0xcd, 0xad,
0x91, 0x95, 0x49, 0x30, 0x43, 0x54, 0x0e, 0xf3, 0x53, 0x89, 0xd2, 0x13, 0x40, 0xca, 0x44, 0x90,
0x37, 0x11, 0xf8, 0x9a, 0xbf, 0xf5, 0x6f, 0x0b, 0xa4, 0x47, 0x03, 0x59, 0x6a, 0x48, 0xdc, 0x11,
0xeb, 0x51, 0x1b, 0x56, 0x42, 0x03, 0xc9, 0x4e, 0xbc, 0x4c, 0x3f, 0x05, 0x48, 0x32, 0x48, 0x7d,
0x5b, 0x77, 0x4b, 0x75, 0xbf, 0x14, 0x72, 0x31, 0x86, 0x10, 0x99, 0x87, 0x33, 0x4c, 0x3c, 0xc2,
0x8a, 0x76, 0x36, 0xfc, 0x44, 0x19, 0xe4, 0xd1, 0x9d, 0x29, 0x7c, 0x17, 0xea, 0xa6, 0x3a, 0x90,
0x4b, 0x01, 0x5b, 0x37, 0x45, 0xc6, 0x4f, 0x59, 0xb0, 0x6a, 0xeb, 0xe4, 0x2c, 0x0c, 0x87, 0x91,
0x06, 0x6d, 0xeb, 0xea, 0x3b, 0x3d, 0xbc, 0x1a, 0x0a, 0xd8, 0x1b, 0xd6, 0x71, 0xa5, 0x6c, 0x4c,
0x1c, 0xde, 0x46, 0xb4, 0x2c, 0x15, 0xc3, 0xe8, 0x7d, 0x70, 0x96, 0x85, 0x1d, 0xc3, 0x53, 0x3c,
0xdc, 0x1b, 0x4f, 0xe2, 0x79, 0x39, 0x74, 0xe5, 0x49, 0x8e, 0xd4, 0xb5, 0x59, 0x19, 0xc1, 0xe9,
0x37, 0xbd, 0xad, 0x90, 0x33, 0x9f, 0xaf, 0x46, 0xfe, 0xd8, 0xcd, 0x30, 0x04, 0x1d, 0x96, 0xf8,
0x2d, 0xe6, 0xc4, 0xfb, 0xac, 0x56, 0xb1, 0x26, 0x33, 0xc0, 0x38, 0x19, 0x3b, 0xe3, 0xf4, 0xaf,
0x4f, 0x77, 0x5c, 0xe3, 0xc0, 0x0b, 0x81, 0x29, 0x7f, 0xd4, 0x43, 0x4d, 0x7b, 0x87, 0xd4, 0x28,
0x37, 0x22, 0xbb, 0x16, 0x54, 0xe6, 0xe2, 0x55, 0x11, 0xda, 0xf4, 0xc5, 0xe1, 0xbb, 0xdb, 0xf9,
0xb4, 0xd7, 0x25, 0x27, 0x09, 0x4d, 0x37, 0x82, 0x9b, 0x64, 0x31, 0xbc, 0x3d, 0x2c, 0x66, 0xcd,
0x60, 0x3a, 0x74, 0x7d, 0xfd, 0xdb, 0x74, 0x31, 0x4e, 0x35, 0x98, 0x76, 0x84, 0x87, 0x49, 0x2d,
0xce, 0x50, 0x57, 0xbd, 0x12, 0x65, 0xfb, 0xa4, 0x7b, 0x4e, 0xb6, 0x8a, 0x4d, 0x73, 0xf2, 0xfb,
0xc0, 0x35, 0xcf, 0xf7, 0x79, 0xb2, 0x5d, 0x8d, 0xbc, 0xd3, 0x7d, 0x0c, 0xa7, 0xd1, 0xf1, 0xdb,
0x10, 0xa3, 0x91, 0xae, 0x99, 0xc5, 0xed, 0x80, 0x15, 0xb7, 0x5e, 0xea, 0x11, 0xa7, 0xb1, 0x64,
0x7c, 0x3b, 0x08, 0xfd, 0xf0, 0xa1, 0x2a, 0x9f, 0xaf, 0xf0, 0x9b, 0x43, 0x43, 0x4f, 0xc1, 0xd5,
0x39, 0xba, 0xda, 0x3f, 0x49, 0x5d, 0x13, 0x53, 0xa1, 0x3d, 0x34, 0xc4, 0xd2, 0xdb, 0xf5, 0x76,
0x42, 0x37, 0x07, 0x2e, 0xd6, 0x0a, 0x3d, 0x12, 0xe4, 0x6f, 0x68, 0x4e, 0x70, 0x0d, 0x29, 0x9e,
0x54, 0x07, 0x48, 0xba, 0xc7, 0xfa, 0xfd, 0x73, 0x7d, 0x6d, 0x0d, 0x07, 0x98, 0xeb, 0x5e, 0x67,
0xa5, 0x6a, 0x6a, 0x91, 0x87, 0x23, 0x59, 0xf6, 0x9c, 0x90, 0xa2, 0xd7, 0x07, 0x93, 0xb6, 0xed,
0xe2, 0x38, 0x2b, 0xc0, 0x2d, 0x08, 0x98, 0x6c, 0x11, 0x45, 0x05, 0x8d, 0xa8, 0x17, 0xf1, 0x10,
0xcb, 0xca, 0xf5, 0x90, 0x41, 0x15, 0x75, 0x22, 0x62, 0xd2, 0x0c, 0xc2, 0xf7, 0x5a, 0xb0, 0x64,
0xbe, 0xf7, 0x6d, 0x57, 0xa6, 0x64, 0x28, 0x12, 0x1d, 0x98, 0x93, 0x2b, 0xf5, 0xd7, 0xa2, 0x3f,
0x35, 0x1b, 0xd4, 0x49, 0x68, 0x15, 0xa9, 0x19, 0xa1, 0x8c, 0x03, 0xe7, 0x83, 0x4d, 0x2d, 0xf3,
0xe8, 0xc3, 0xbd, 0xec, 0x1d, 0x7e, 0x3f, 0x68, 0x3a, 0x66, 0xac, 0xbe, 0xb5, 0xcc, 0xd3, 0x57,
0xf7, 0x84, 0xac, 0xd4, 0x32, 0x21, 0xed, 0xb1, 0x2b, 0xe7, 0x4c, 0x8d, 0x5a, 0xeb, 0xf6, 0x06,
0xcd, 0xa7, 0xad, 0x7e, 0x78, 0xc5, 0x1f, 0xce, 0x35, 0x02, 0x47, 0xd3, 0x20, 0x73, 0x0f, 0x26,
0xfc, 0x23, 0xa8, 0x84, 0xf5, 0x58, 0xc0, 0xc1, 0x43, 0x60, 0x47, 0x61, 0x1f, 0x8a, 0xe7, 0xe9,
0x9a, 0x6e, 0x7f, 0xba, 0xb4, 0x06, 0xc3, 0x9b, 0x1e, 0x5b, 0x98, 0xbc, 0x0e, 0x52, 0x3f, 0x4c,
0x40, 0xd9, 0xbc, 0x7b, 0x85, 0x9e, 0x39, 0x36, 0xba, 0x2a, 0x63, 0xa5, 0xe4, 0x97, 0xad, 0xfc,
0xbd, 0xa2, 0xd1, 0x80, 0x3b, 0x0c, 0xe6, 0xc8, 0x08, 0x62, 0xe1, 0x24, 0x9a, 0x90, 0x7e, 0xb2,
0x6f, 0x09, 0xac, 0xbc, 0x89, 0xc2, 0x8b, 0xc5, 0x07, 0xc7, 0x4e, 0x20, 0xf1, 0xe8, 0x81, 0x61,
0x67, 0xf1, 0x7d, 0x93, 0xdb, 0xb8, 0x31, 0xde, 0xd4, 0x90, 0x8e, 0x49, 0x30, 0xeb, 0xc1, 0xff,
0x9f, 0x73, 0xd6, 0x75, 0x0e, 0x2f, 0x38, 0xe5, 0x86, 0xb6, 0x5f, 0x35, 0x35, 0x0e, 0xd9, 0xea,
0x73, 0xe8, 0xf3, 0xe2, 0x7a, 0x08, 0xe0, 0x9c, 0x9a, 0xbd, 0xc8, 0x5d, 0xd3, 0xda, 0x4c, 0x7b,
0x13, 0xac, 0x71, 0x28, 0xf6, 0x8f, 0xcf, 0xcb, 0x4d, 0x70, 0x7e, 0x8f, 0x02, 0x44, 0xfa, 0xdf,
0x41, 0x18, 0x02, 0xa4, 0x3f, 0xed, 0xdc, 0x0a, 0x5c, 0x84, 0x45, 0xaa, 0x2c, 0x35, 0x97, 0x4d,
0x29, 0x7d, 0x78, 0xc8, 0x04, 0xe4, 0x8c, 0xb5, 0xa9, 0xed, 0xd9, 0x54, 0x25, 0xca, 0x9a, 0x91,
0xb4, 0x98, 0xd9, 0x5e, 0xba, 0x54, 0x3b, 0x8b, 0xec, 0x3c, 0xa3, 0xcc, 0xfa, 0x08, 0xa0, 0x2e,
0xe3, 0x0d, 0xa3, 0x21, 0xaa, 0x9a, 0x3d, 0x7f, 0xdd, 0x09, 0xfc, 0xae, 0xa8, 0x4f, 0xd1, 0x4d,
0xd2, 0xc6, 0x8b, 0x17, 0xae, 0x3c, 0xb7, 0x38, 0xcc, 0xd0, 0xa1, 0x21, 0x98, 0x20, 0xbd, 0xbb,
0x03, 0xa4, 0x47, 0x24, 0x37, 0x7f, 0xd5, 0xdb, 0xdf, 0x84, 0x5d, 0xd9, 0x19, 0x17, 0xde, 0xb8,
0x51, 0x09, 0xed, 0x02, 0xc6, 0x72, 0x9a, 0xd2, 0xfa, 0x01, 0x81, 0xe6, 0xbd, 0x7a, 0x58, 0x17,
0xed, 0x88, 0xb1, 0x83, 0x16, 0x82, 0x73, 0xf0, 0xa7, 0xc2, 0xe6, 0x67, 0x8e, 0x4a, 0xb1, 0xac,
0x76, 0x66, 0xa8, 0xe2, 0x35, 0xcc, 0x13, 0xfe, 0x5b, 0xed, 0x9d, 0x60, 0x24, 0x5b, 0x74, 0x3c,
0x81, 0xd6, 0x1c, 0x31, 0xdf, 0xc8, 0xd5, 0x74, 0xbf, 0xcb, 0x4f, 0x53, 0x68, 0x05, 0x90, 0xa5,
0xba, 0xd5, 0x4f, 0x80, 0x43, 0x50, 0x65, 0x29, 0x42, 0xf2, 0x1a, 0x88, 0xb8, 0x61, 0xbf, 0x65,
0x59, 0xad, 0x2f, 0x2e, 0xf1, 0x4f, 0xef, 0xe4, 0xc0, 0xde, 0x37, 0xb5, 0xfb, 0xd9, 0x2e, 0x50,
0x2a, 0x3e, 0xac, 0xe4, 0x45, 0xa4, 0xd5, 0x2f, 0xac, 0x9a, 0xc1, 0x7c, 0xd4, 0x95, 0xe1, 0x86,
0x4d, 0xae, 0x2b, 0x5e, 0x11, 0x7b, 0xe7, 0x38, 0x5e, 0x93, 0x53, 0x95, 0x9c, 0x65, 0xcc, 0x8b,
0x78, 0x6a, 0x0e, 0x28, 0x68, 0xba, 0x50, 0xd0, 0x74, 0x5d, 0x7c, 0x62, 0x2b, 0xa3, 0xb4, 0xe0,
0x96, 0x8e, 0x2b, 0x0b, 0xcc, 0xbc, 0x0c, 0x4f, 0xcb, 0xe6, 0x89, 0x4e, 0xd0, 0x2e, 0x17, 0x9a,
0x37, 0x13, 0x55, 0x68, 0x2c, 0x67, 0xf2, 0x12, 0x92, 0x35, 0x08, 0x93, 0x17, 0xaf, 0x70, 0x8b,
0x08, 0x8e, 0x4e, 0x5e, 0x91, 0x1d, 0x8e, 0x8e, 0x5a, 0xb3, 0xf8, 0xa0, 0x11, 0x1f, 0xe0, 0xfb,
0xf3, 0xf1, 0xb2, 0x1c, 0x56, 0x97, 0x6d, 0xd4, 0x6d, 0xa3, 0x19, 0x50, 0x00, 0xf4, 0xef, 0x7c,
0x90, 0xe8, 0x89, 0x33, 0x6d, 0xf9, 0x90, 0x44, 0xa0, 0x7d, 0xa2, 0x6e, 0xab, 0x87, 0xe5, 0xc9,
0xe8, 0xc5, 0x28, 0x64, 0xf6, 0x29, 0x95, 0xf4, 0x69, 0xb3, 0xa1, 0xbc, 0x14, 0xc2, 0x2f, 0x30,
0x50, 0x80, 0x08, 0x58, 0xae, 0x0d, 0x72, 0x66, 0x2c, 0x30, 0x43, 0xfe, 0x07, 0x0d, 0xa3, 0x1d,
0x58, 0x1c, 0x16, 0x5e, 0x1d, 0x80, 0xf6, 0x99, 0x53, 0x92, 0xd6, 0x57, 0x6c, 0x83, 0xae, 0x80,
0x83, 0x69, 0xa9, 0x22, 0x7b, 0xbc, 0x6f, 0x11, 0x94, 0x8c, 0xab, 0xa5, 0x25, 0x8d, 0x52, 0x66,
0x33, 0x09, 0xb6, 0x67, 0x93, 0x9d, 0x44, 0x09, 0xf8, 0xf0, 0xdc, 0x06, 0x5d, 0xb3, 0x49, 0x50,
0xcc, 0x9a, 0xf8, 0x85, 0xc1, 0x5f, 0xf7, 0x43, 0xa4, 0x72, 0xb9, 0x05, 0xad, 0xcd, 0x5e, 0x29,
0x1c, 0x37, 0xd2, 0x0b, 0xac, 0x73, 0xd4, 0x75, 0x4f, 0x26, 0x06, 0x1e, 0x4b, 0x9f, 0xef, 0xea,
0xb0, 0xee, 0x3f, 0xd9, 0xb4, 0x11, 0xd0, 0x25, 0x18, 0x00, 0x09, 0x21, 0xe2, 0x60, 0x67, 0x18,
0x7e, 0x87, 0x87, 0xb0, 0x14, 0xaf, 0x4d, 0xa2, 0x88, 0x81, 0x77, 0x71, 0x33, 0x5c, 0xb8, 0x0d,
0x12, 0x3c, 0x5e, 0xb0, 0x52, 0xb0, 0x29, 0x39, 0xf2, 0xed, 0x6a, 0xe0, 0x94, 0x58, 0xd7, 0x23,
0x4b, 0xa7, 0x3d, 0x93, 0xc9, 0x05, 0x06, 0xba, 0x32, 0x73, 0x00, 0x1e, 0xeb, 0x6f, 0x64, 0xd5,
0x89, 0x17, 0x45, 0xcd, 0x91, 0x13, 0x42, 0xb5, 0xd3, 0x6f, 0x9d, 0xa2, 0xde, 0xbc, 0x07, 0x23,
0x4f, 0x1d, 0xf9, 0x89, 0x99, 0x8c, 0x9e, 0xde, 0xa4, 0x7f, 0xab, 0xfc, 0x54, 0x04, 0x0f, 0x11,
0x5c, 0xbc, 0xd6, 0xd3, 0x54, 0x13, 0xe9, 0x7a, 0x99, 0x04, 0x57, 0xf2, 0xf0, 0x7c, 0xb7, 0x56,
0x5c, 0x9c, 0x37, 0xbd, 0xfc, 0xa5, 0xb0, 0x8d, 0x3d, 0x02, 0x0e, 0x61, 0xdd, 0x20, 0xd6, 0x44,
0x8a, 0x0b, 0x58, 0xd8, 0x33, 0x17, 0x2d, 0x85, 0x0c, 0xb1, 0x7f, 0x6a, 0xb1, 0xca, 0x37, 0xb8,
0xba, 0x10, 0x09, 0x12, 0x28, 0xac, 0x00, 0x2b, 0x3e, 0x5e, 0x0e, 0x92, 0xe3, 0x6b, 0xef, 0xe6,
0xc6, 0x8e, 0x28, 0xfa, 0xc2, 0x58, 0x55, 0x09, 0x94, 0xe9, 0xaa, 0xad, 0x4e, 0x2d, 0x93, 0xd7,
0x2d, 0xdb, 0xfb, 0xce, 0x3b, 0x7d, 0x47, 0x4c, 0xa7, 0x1f, 0x07, 0x8d, 0x6b, 0x09, 0x81, 0xf8,
0x72, 0x76, 0x84, 0xc8, 0xc1, 0xf9, 0x95, 0x4b, 0x8e, 0xb0, 0xaa, 0xe6, 0x37, 0xad, 0xcd, 0x21,
0x92, 0xd8, 0x45, 0x2d, 0xda, 0xda, 0xa1, 0x2f, 0x85, 0x89, 0x16, 0x68, 0x5d, 0x41, 0x8a, 0x98,
0x09, 0x8c, 0xcc, 0x32, 0xa2, 0xc8, 0xfc, 0xea, 0x3d, 0x55, 0xda, 0x4d, 0x53, 0x17, 0x93, 0xbc,
0x5b, 0x59, 0x9f, 0x50, 0x5c, 0xcf, 0x03, 0x6b, 0x94, 0x5d, 0xbc, 0x6d, 0xe7, 0x9c, 0x6d, 0x62,
0x95, 0xaa, 0x35, 0xa3, 0x23, 0x42, 0x9f, 0xfb, 0x5e, 0xc1, 0xd7, 0x49, 0x89, 0xbd, 0xc4, 0xe8,
0xcf, 0x22, 0xd3, 0xcf, 0x3d, 0x2f, 0x6d, 0x08, 0x0c, 0x4c, 0x17, 0x5b, 0x87, 0x44, 0x9f, 0x8b,
0x73, 0xe0, 0xe9, 0x36, 0xb7, 0x92, 0x5b, 0xfd, 0x62, 0x76, 0x7b, 0x67, 0xc0, 0x47, 0xff, 0x68,
0x01, 0x91, 0x85, 0x3a, 0x95, 0xc7, 0x19, 0xf7, 0xb0, 0x72, 0x83, 0x88, 0x5a, 0xdc, 0x58, 0x14,
0xe8, 0xa7, 0x53, 0x9e, 0x69, 0xe4, 0x6c, 0x39, 0x3d, 0xbe, 0x5f, 0x72, 0x6b, 0xb4, 0xd5, 0x80,
0xfb, 0x44, 0x24, 0x88, 0x08, 0x14, 0xf6, 0xe8, 0xd8, 0x2c, 0x1a, 0x5c, 0xf0, 0x86, 0x79, 0xc4,
0x40, 0x5c, 0xc8, 0xab, 0x53, 0x27, 0xd3, 0xce, 0x00, 0x99, 0x7f, 0x6a, 0x91, 0x35, 0x81, 0x90,
0x8a, 0x5f, 0x2d, 0xf6, 0x12, 0x06, 0xa5, 0x75, 0x04, 0x85, 0x35, 0x66, 0x23, 0x5f, 0xc6, 0x00,
0x69, 0x67, 0xf6, 0x5e, 0x7b, 0x18, 0x92, 0x80, 0x26, 0x03, 0xb0, 0x73, 0xcb, 0x8e, 0xba, 0xf7,
0xda, 0x6f, 0xee, 0x8f, 0x6c, 0x3f, 0xcd, 0xc6, 0x73, 0x51, 0x5d, 0xdc, 0x55, 0x69, 0xcd, 0x02,
0x24, 0x52, 0x62, 0x83, 0xba, 0x27, 0xaa, 0x73, 0x15, 0xe7, 0xd4, 0x7a, 0xc1, 0xd5, 0x8e, 0xad,
0xb4, 0x68, 0xb9, 0x40, 0xcb, 0x5d, 0x9e, 0x67, 0x84, 0x2b, 0x14, 0x78, 0xcd, 0xa5, 0xc2, 0x81,
0x91, 0x3b, 0x0f, 0x70, 0x43, 0x26, 0xba, 0x24, 0x3d, 0x14, 0x08, 0x13, 0xba, 0xf9, 0x7c, 0x38,
0x55, 0x51, 0x57, 0x6e, 0xef, 0xf0, 0x92, 0xd1, 0x06, 0xb4, 0x06, 0xd5, 0xf1, 0xf5, 0xb4, 0xda,
0x1b, 0xad, 0x52, 0xc2, 0x6d, 0x1e, 0x82, 0xb0, 0x04, 0x5f, 0x5d, 0x92, 0x8d, 0x98, 0x9d, 0x30,
0x24, 0x5f, 0x47, 0x9f, 0x34, 0x02, 0x9a, 0x83, 0x82, 0x5e, 0xcd, 0xeb, 0x13, 0x40, 0x15, 0xa5,
0x13, 0xd3, 0xff, 0x19, 0x1c, 0x67, 0x74, 0xf5, 0xf3, 0x50, 0xb9, 0xbf, 0xa9, 0x64, 0x8a, 0x90,
0x69, 0xc2, 0x93, 0xf9, 0xfc, 0xca, 0xa5, 0x2a, 0xb7, 0x99, 0x70, 0x93, 0x2a, 0x4b, 0x57, 0x77,
0x8f, 0xc9, 0x58, 0xc5, 0x18, 0xff, 0x8d, 0xdc, 0x02, 0x41, 0xac, 0x93, 0xee, 0x5b, 0x14, 0xd8,
0xfe, 0x92, 0x49, 0x61, 0xc3, 0xda, 0xfe, 0xf9, 0x70, 0x17, 0x87, 0xe2, 0x34, 0xd6, 0xac, 0x96,
0x49, 0xfc, 0x61, 0xf0, 0x72, 0x44, 0x95, 0x88, 0x34, 0x2c, 0x68, 0x0d, 0x42, 0x62, 0xb2, 0x0a,
0x53, 0x58, 0xb1, 0x56, 0x14, 0x08, 0x66, 0x86, 0x39, 0x0a, 0xd5, 0x41, 0xb6, 0x24, 0x52, 0xd2,
0xfb, 0x68, 0x77, 0xac, 0x63, 0xfb, 0x60, 0xe4, 0x31, 0x24, 0xdd, 0x5d, 0x35, 0xc2, 0x64, 0x8a,
0xd2, 0x2f, 0xe8, 0xd4, 0x22, 0xc2, 0xcc, 0x7e, 0x7d, 0x83, 0x05, 0x58, 0x62, 0xe6, 0xc9, 0x9b,
0xf9, 0xd4, 0x60, 0xa2, 0x38, 0x4b, 0x6c, 0x3b, 0x50, 0xe3, 0x02, 0x4e, 0xa3, 0x7c, 0x2c, 0x7f,
0x50, 0xd8, 0x53, 0xa5, 0x88, 0x42, 0x4a, 0x67, 0x76, 0x94, 0x44, 0x08, 0x89, 0x23, 0x1f, 0x99,
0x5d, 0x53, 0xec, 0x25, 0x38, 0x73, 0x85, 0xd2, 0xe2, 0x15, 0x6a, 0xd6, 0x5d, 0x93, 0xf2, 0xca,
0x9d, 0x2a, 0x51, 0x39, 0xae, 0xad, 0xe4, 0xb7, 0xf2, 0x44, 0x1c, 0x1f, 0xcf, 0x98, 0xb5, 0x13,
0x7d, 0xa5, 0x2f, 0xf7, 0x4b, 0x14, 0xab, 0x4d, 0xa7, 0x0c, 0x6c, 0x32, 0x13, 0x86, 0xcf, 0x04,
0x26, 0x2d, 0xe6, 0x35, 0xef, 0x50, 0xc5, 0x48, 0x7d, 0x72, 0x08, 0x46, 0xc5, 0xa8, 0xdf, 0x0e,
0x54, 0xe7, 0x19, 0xd2, 0xbc, 0xbf, 0x45, 0x3b, 0x23, 0xed, 0xbb, 0xdd, 0x0d, 0x33, 0x2c, 0x92,
0x4d, 0x55, 0x80, 0x13, 0xaa, 0xf7, 0x0c, 0xd0, 0x2d, 0xf7, 0x65, 0xaa, 0xac, 0xa5, 0x32, 0xc1,
0xaa, 0xf4, 0xae, 0x79, 0xc7, 0x57, 0x32, 0xa0, 0x5e, 0xf0, 0x75, 0x87, 0x54, 0xb9, 0x42, 0x6a,
0xe3, 0x27, 0x52, 0xd9, 0x40, 0x01, 0x0e, 0x86, 0x70, 0x43, 0xd9, 0x47, 0x0a, 0xd4, 0x4a, 0x8a,
0xd4, 0xd8, 0x57, 0x65, 0x6c, 0x19, 0x5d, 0x4b, 0x87, 0x7e, 0xb3, 0x6e, 0x7c, 0xc6, 0xd6, 0x05,
0x56, 0xef, 0x34, 0x2c, 0x38, 0xa5, 0x4d, 0xec, 0x30, 0x8f, 0x46, 0x7b, 0x07, 0x7a, 0x6e, 0xdf,
0x05, 0xfe, 0xeb, 0x1d, 0xe1, 0xae, 0x9e, 0xa4, 0xbd, 0x9d, 0x51, 0x08, 0xd3, 0xf2, 0xa7, 0x3e,
0x68, 0x33, 0x63, 0xd6, 0x0f, 0xf0, 0xd8, 0x07, 0x4f, 0x52, 0x98, 0x43, 0xb0, 0x2e, 0x95, 0x50,
0x89, 0x1c, 0x1e, 0x2f, 0xb2, 0xcd, 0xbd, 0x4c, 0xbb, 0x67, 0x35, 0x86, 0x38, 0xa9, 0xd7, 0x38,
0xa0, 0x19, 0x9c, 0x1f, 0xfd, 0x7d, 0xde, 0x03, 0xab, 0x46, 0xec, 0xf5, 0x62, 0x22, 0xc5, 0xaa,
0x87, 0xd4, 0x59, 0x57, 0x1a, 0xdb, 0xd4, 0xfa, 0xe3, 0x24, 0xa7, 0x35, 0xa3, 0xf0, 0x35, 0xe6,
0x8b, 0x95, 0xc2, 0x84, 0xe5, 0x9a, 0x01, 0xc1, 0x1b, 0x31, 0x63, 0x32, 0xa7, 0x6b, 0xeb, 0x89,
0x1f, 0xab, 0xdd, 0x3f, 0xb9, 0x34, 0xda, 0x2d, 0x3b, 0x5b, 0xb4, 0xf8, 0x04, 0xc8, 0xed, 0x60,
0xc3, 0x2e, 0x11, 0x38, 0x8b, 0x7a, 0xcd, 0x28, 0xab, 0xee, 0x6b, 0x0c, 0xd0, 0x13, 0x2a, 0x65,
0xee, 0xc8, 0xfb, 0x6b, 0x87, 0xd3, 0xe5, 0x39, 0x8b, 0xf7, 0xef, 0xab, 0x46, 0xac, 0x56, 0xf9,
0x4d, 0xc9, 0x2d, 0xa7, 0x69, 0x8b, 0x5f, 0x8e, 0x4d, 0xa4, 0xda, 0xeb, 0x57, 0x44, 0xb2, 0xef,
0x97, 0xd8, 0xea, 0xed, 0x86, 0x8b, 0xdc, 0x44, 0x83, 0xcc, 0xa3, 0xdf, 0xea, 0xd8, 0xdc, 0x74,
0xf2, 0x8e, 0xe6, 0x65, 0x26, 0x74, 0x0a, 0x2a, 0x17, 0x11, 0xee, 0x21, 0xc5, 0x0a, 0x06, 0xbb,
0xc9, 0xaa, 0xee, 0x40, 0x01, 0x12, 0x86, 0x93, 0xdb, 0x90, 0x24, 0x10, 0xad, 0xbf, 0x8d, 0x19,
0x34, 0x0f, 0xf9, 0xe9, 0xb7, 0x7f, 0xb9, 0xab, 0x9a, 0xf3, 0x71, 0x13, 0x1d, 0x79, 0xcf, 0xe8,
0xe7, 0x69, 0x67, 0x0f, 0xfe, 0xea, 0x69, 0x4e, 0xb6, 0x2d, 0x36, 0x49, 0x75, 0x45, 0x7e, 0x85,
0xd2, 0x4c, 0x4f, 0xb3, 0xc9, 0x21, 0xed, 0xb3, 0x17, 0x33, 0xba, 0x40, 0x6f, 0x14, 0x36, 0x49,
0x84, 0x4b, 0xa7, 0x21, 0x2e, 0x40, 0xd4, 0xb8, 0x05, 0x3a, 0x2e, 0x4f, 0x43, 0xa5, 0x69, 0xdf,
0xc3, 0x2d, 0x62, 0x41, 0xec, 0x86, 0xcc, 0xd1, 0x81, 0x93, 0x03, 0xb4, 0x5e, 0x2a, 0xed, 0xfa,
0x77, 0xa4, 0x4e, 0xdd, 0x71, 0xce, 0x7a, 0xe4, 0x45, 0x56, 0x48, 0x08, 0x1b, 0x13, 0xef, 0xc2,
0x19, 0x53, 0x69, 0xb4, 0xf6, 0xd8, 0x95, 0x9b, 0x46, 0x9d, 0x04, 0x23, 0xbd, 0x9a, 0xf0, 0xe9,
0x31, 0xe2, 0xa4, 0x93, 0x6b, 0xed, 0xe2, 0x22, 0x81, 0x6e, 0xdb, 0x5e, 0x1a, 0xe9, 0x9a, 0x58,
0xcb, 0xa7, 0x86, 0x73, 0x3d, 0x5b, 0xed, 0xc4, 0x44, 0x83, 0x4c, 0x0e, 0x9b, 0x8e, 0x82, 0x5d,
0x5e, 0xae, 0x2a, 0xf5, 0x5b, 0xe5, 0x91, 0xef, 0x53, 0xd9, 0x7e, 0x93, 0xe5, 0x66, 0x9a, 0x63,
0x78, 0x78, 0x58, 0x8a, 0x63, 0x5f, 0x8c, 0xf6, 0x8a, 0xd9, 0x2d, 0xaa, 0xbe, 0x67, 0x56, 0x67,
0x20, 0x9d, 0x39, 0xfd, 0x4c, 0xae, 0xd3, 0x70, 0x86, 0x7e, 0x20, 0x78, 0x6d, 0xe2, 0x44, 0x13,
0x90, 0x62, 0x7f, 0x02, 0xcc, 0xde, 0x97, 0xf4, 0x4e, 0x76, 0xb5, 0xd2, 0xb4, 0x4d, 0x9b, 0x74,
0x8a, 0xb4, 0x80, 0x83, 0x40, 0xc2, 0x94, 0x02, 0x9a, 0x71, 0xe0, 0x79, 0x3d, 0x77, 0xb5, 0x3d,
0xb2, 0xea, 0x12, 0x98, 0x05, 0x47, 0x1d, 0x5c, 0x79, 0x94, 0xdc, 0x55, 0xa7, 0x6f, 0x30, 0x7f,
0x83, 0x50, 0xd1, 0x95, 0x21, 0x87, 0x0b, 0x89, 0x86, 0x15, 0x25, 0x35, 0x74, 0xcd, 0x1d, 0x38,
0x48, 0x2a, 0xcf, 0xb3, 0x97, 0xbc, 0x2b, 0xb7, 0xab, 0x10, 0x8d, 0x17, 0x5d, 0xef, 0xad, 0xf2,
0xe3, 0x1b, 0x56, 0x23, 0x8d, 0x2c, 0x33, 0x59, 0x3a, 0x99, 0x86, 0x6e, 0xd6, 0xcb, 0xc5, 0x8c,
0x43, 0x1b, 0x5e, 0x26, 0x88, 0xf1, 0x3e, 0xf8, 0x3e, 0xa7, 0xb9, 0xc6, 0xb5, 0xac, 0x3b, 0xb7,
0x38, 0x0d, 0xb2, 0xc5, 0x15, 0xb4, 0x55, 0x97, 0xc3, 0x14, 0x0c, 0x19, 0x93, 0x21, 0xba, 0xb9,
0xd6, 0x1f, 0x28, 0x8b, 0x87, 0xfe, 0x20, 0x21, 0x08, 0xfb, 0x32, 0x16, 0xf7, 0xa4, 0xa7, 0x30,
0x6a, 0x02, 0xd5, 0x67, 0xf6, 0xff, 0x37, 0xee, 0xd7, 0x1b, 0x34, 0x6f, 0x0b, 0xc2, 0x94, 0x91,
0xa6, 0x78, 0x50, 0xf2, 0x9e, 0x58, 0x44, 0x11, 0xe4, 0x8b, 0x23, 0x3c, 0xe6, 0xa2, 0x8c, 0x1e,
0x96, 0xdf, 0x41, 0x11, 0x47, 0x89, 0x2a, 0x2a, 0xe4, 0xc8, 0xd2, 0x12, 0x98, 0xb0, 0x37, 0x02,
0xf6, 0xa6, 0x3b, 0xa1, 0xf3, 0x30, 0x9c, 0xda, 0x35, 0x0c, 0xef, 0xc2, 0x36, 0xaf, 0xb7, 0x2c,
0xe9, 0xf6, 0x64, 0x0d, 0x05, 0x84, 0xf6, 0x8d, 0x61, 0xeb, 0xda, 0x36, 0x05, 0x42, 0x56, 0xde,
0xfe, 0x36, 0x7c, 0x42, 0x1c, 0x5e, 0xfb, 0x9b, 0xe2, 0x22, 0xcc, 0x42, 0xff, 0xb1, 0xe6, 0xfd,
0x02, 0x4a, 0x1c, 0x44, 0xa8, 0x78, 0x87, 0xc5, 0x58, 0xed, 0x55, 0x0f, 0x29, 0x3b, 0x50, 0xf8,
0x93, 0x05, 0xa5, 0x3c, 0x1a, 0xd5, 0x7c, 0xcd, 0x5f, 0xab, 0x8a, 0x95, 0xb0, 0x65, 0x86, 0x86,
0x3d, 0x8c, 0x05, 0x21, 0x46, 0xfa, 0xf7, 0x7a, 0x2a, 0xa6, 0x09, 0x0f, 0xf4, 0xaa, 0x2d, 0x3d,
0xf9, 0x63, 0x66, 0x22, 0x9b, 0xc7, 0x74, 0x3f, 0xbc, 0x97, 0x58, 0xbb, 0x41, 0x02, 0x60, 0xd1,
0xe2, 0xfe, 0x26, 0x22, 0x91, 0x76, 0x44, 0xce, 0x94, 0x2c, 0xd1, 0x13, 0x56, 0x06, 0xc0, 0xa4,
0xc4, 0x36, 0xe9, 0x84, 0x78, 0xa0, 0xc6, 0x02, 0x97, 0xa5, 0x27, 0xd4, 0x9e, 0x78, 0x51, 0xca,
0x7e, 0x55, 0x94, 0xcd, 0xf3, 0x64, 0xe9, 0x0f, 0xf5, 0x37, 0xe6, 0x15, 0x09, 0xed, 0x72, 0xd2,
0x25, 0xd6, 0xf2, 0xde, 0x93, 0xbc, 0xc3, 0x7c, 0x27, 0x63, 0x5e, 0x50, 0x2b, 0xf4, 0x17, 0xd0,
0x09, 0x3a, 0xca, 0xb5, 0xad, 0x92, 0xf8, 0x9a, 0x52, 0x5d, 0x74, 0x24, 0x6a, 0x3b, 0x59, 0x2a,
0x88, 0x17, 0xc7, 0xee, 0x78, 0xfb, 0x78, 0x06, 0x16, 0x6a, 0xad, 0x0b, 0xa5, 0x9c, 0xab, 0x5c,
0x78, 0x3a, 0xc5, 0x7d, 0x9e, 0x1e, 0xb7, 0x82, 0x57, 0x6f, 0xe5, 0xd0, 0x43, 0x2d, 0x71, 0x20,
0xd7, 0x16, 0x54, 0x59, 0x75, 0x15, 0x8f, 0x47, 0x90, 0x31, 0xb9, 0x9a, 0x0d, 0x85, 0x7d, 0x01,
0x58, 0x67, 0x40, 0x07, 0xec, 0x72, 0xaf, 0x41, 0x01, 0x3e, 0x61, 0x0c, 0xe4, 0x12, 0x1c, 0x30,
0xd3, 0x37, 0xf7, 0xdf, 0xf4, 0x2e, 0xa0, 0x62, 0xd5, 0xba, 0x1c, 0xc9, 0x70, 0x31, 0x2e, 0x10,
0xa9, 0xf0, 0x31, 0x53, 0x69, 0xea, 0x2b, 0xbc, 0xbe, 0x5d, 0xbb, 0xa7, 0xdf, 0x62, 0xf0, 0x28,
0x18, 0x66, 0xa6, 0xd3, 0x74, 0x86, 0x11, 0x4c, 0x6e, 0x57, 0xdd, 0x0c, 0x86, 0xc2, 0xa5, 0x3b,
0x0f, 0x92, 0x19, 0x24, 0x90, 0x82, 0xdd, 0xc5, 0x48, 0xdb, 0x72, 0xb8, 0xda, 0x38, 0x95, 0xa8,
0xa0, 0x80, 0xe2, 0x4e, 0x93, 0x44, 0xb8, 0x4f, 0xe9, 0xc1, 0xd9, 0x2c, 0x90, 0x4e, 0xed, 0x6f,
0x9d, 0x3e, 0x7b, 0x66, 0x53, 0xa9, 0xd3, 0xc5, 0x18, 0x95, 0x05, 0xbe, 0xfe, 0xbd, 0xee, 0xb6,
0x2a, 0x1e, 0x29, 0x23, 0xff, 0x44, 0x6b, 0x02, 0x3c, 0xbe, 0xac, 0x12, 0x1f, 0xed, 0x0d, 0x3b,
0x3b, 0xc9, 0x3e, 0x84, 0xa7, 0x3c, 0x00, 0x0d, 0x15, 0x07, 0x83, 0xa1, 0x7f, 0x4f, 0xc1, 0x13,
0x51, 0x67, 0x1e, 0x7c, 0xf8, 0xe2, 0xac, 0xb4, 0xd1, 0x49, 0x78, 0xd4, 0x01, 0xb1, 0x55, 0xba,
0xa5, 0xa4, 0xf8, 0x85, 0x95, 0x7f, 0xf6, 0x4d, 0xda, 0xd3, 0x44, 0x46, 0xfd, 0xac, 0xa5, 0xc1,
0xd5, 0xfc, 0x87, 0xea, 0x9e, 0xdd, 0xbe, 0xf5, 0x52, 0x58, 0xed, 0xfd, 0xde, 0x80, 0x3a, 0x07,
0x77, 0x05, 0xcd, 0xd8, 0x29, 0x4e, 0x28, 0x22, 0x66, 0x39, 0x17, 0xcd, 0x56, 0x6b, 0x52, 0x6c,
0x1c, 0xe8, 0x22, 0x74, 0xa2, 0xcf, 0xc8, 0x72, 0x11, 0x36, 0x4f, 0xe1, 0xf6, 0x52, 0x31, 0xfb,
0x8b, 0x06, 0x11, 0xf7, 0x89, 0xb9, 0x96, 0x9b, 0x1c, 0x99, 0x7a, 0xd4, 0xa0, 0x8f, 0x2c, 0x26,
0x62, 0xe7, 0x4e, 0xaf, 0x0e, 0xbd, 0xc3, 0xce, 0x2e, 0x67, 0xd1, 0x86, 0x3b, 0xe9, 0xc4, 0x39,
0x75, 0x5e, 0xbd, 0x0a, 0x06, 0xac, 0xd9, 0x0d, 0xe4, 0xb0, 0x86, 0xaa, 0x1f, 0xb7, 0x9a, 0x26,
0x7a, 0xac, 0x5b, 0x38, 0x30, 0x6e, 0x4e, 0xb9, 0xe3, 0xa6, 0x23, 0xe1, 0xa4, 0x73, 0x1d, 0x50,
0xcc, 0x1c, 0xef, 0xe6, 0x73, 0xf7, 0x8b, 0xeb, 0xbe, 0x69, 0x81, 0xeb, 0x74, 0x87, 0x68, 0x4e,
0x4a, 0x2b, 0xfc, 0xa0, 0x0b, 0x30, 0x6d, 0x5e, 0x81, 0xe2, 0xd9, 0xa6, 0xba, 0x1e, 0x5b, 0x09,
0x2e, 0xe3, 0x67, 0x0d, 0x75, 0x65, 0x76, 0x5c, 0x61, 0xf4, 0x19, 0xd8, 0x6d, 0xfa, 0xfe, 0xa6,
0x11, 0x1a, 0xaf, 0xca, 0x1c, 0xff, 0x74, 0xe7, 0x85, 0xb3, 0x3d, 0xb9, 0x67, 0x7c, 0xf7, 0x16,
0xf8, 0xf6, 0x6b, 0xac, 0xb8, 0x85, 0x7c, 0x1e, 0x02, 0x53, 0x67, 0xac, 0x29, 0xd2, 0x72, 0x97,
0x91, 0x43, 0x81, 0xc2, 0xde, 0xc6, 0x41, 0x3c, 0x96, 0xd6, 0xdf, 0x19, 0x3e, 0x18, 0x2e, 0xbf,
0xcb, 0xb4, 0xec, 0x20, 0xd8, 0xa7, 0x48, 0x46, 0x62, 0x9d, 0x44, 0x23, 0x0e, 0x72, 0x3b, 0xec,
0x4e, 0x7d, 0x2e, 0x92, 0x71, 0xd7, 0xa8, 0x4b, 0x3c, 0x6c, 0x39, 0x72, 0xb0, 0xc2, 0x97, 0x67,
0xde, 0x80, 0x30, 0x0a, 0x36, 0x49, 0xe2, 0x31, 0xa3, 0x70, 0x7d, 0xe3, 0x28, 0xf7, 0xa5, 0xe6,
0xb0, 0xe4, 0xc6, 0x65, 0x43, 0xd3, 0x12, 0x77, 0xa4, 0x1a, 0x92, 0xa6, 0x1c, 0xd7, 0x7d, 0x6d,
0xc9, 0x49, 0xdb, 0x55, 0x45, 0xf4, 0xae, 0x67, 0x69, 0xc1, 0xf0, 0xe4, 0xa4, 0x3e, 0x18, 0xae,
0x08, 0x18, 0xc0, 0xf8, 0xa6, 0x87, 0xa8, 0x71, 0xa9, 0xd2, 0x12, 0x3c, 0xa3, 0xd8, 0x9f, 0xe2,
0x28, 0x30, 0x46, 0xb7, 0x92, 0x33, 0x2d, 0x4b, 0x1a, 0xc7, 0x3e, 0x1f, 0x19, 0x66, 0xd8, 0xd5,
0x03, 0x34, 0x39, 0x6b, 0xe5, 0x0e, 0xea, 0x0d, 0x90, 0xba, 0x26, 0xbd, 0x53, 0xc3, 0x44, 0xe7,
0x6c, 0x51, 0x38, 0xc4, 0x73, 0x85, 0xa6, 0x10, 0xa8, 0x36, 0xbe, 0x75, 0x26, 0xe2, 0xfd, 0xd0,
0x59, 0x8d, 0xf7, 0xb5, 0x81, 0xcd, 0x2b, 0x25, 0x16, 0x7c, 0x0b, 0x5f, 0x24, 0x07, 0x9b, 0x77,
0x45, 0x63, 0x5a, 0x15, 0x62, 0xaa, 0xa1, 0x44, 0x66, 0x72, 0xda, 0x35, 0x94, 0x6a, 0xe6, 0xa8,
0x69, 0xcd, 0xe0, 0x64, 0x6b, 0xde, 0xbb, 0xde, 0xae, 0x82, 0x89, 0x36, 0x16, 0xf0, 0x13, 0x41,
0xa7, 0x42, 0x2e, 0xaf, 0x8a, 0xed, 0x22, 0xd2, 0xc6, 0x91, 0x5f, 0x2a, 0x25, 0x06, 0x52, 0x03,
0xc5, 0xcb, 0x78, 0xe4, 0x7a, 0xef, 0x1c, 0xb3, 0x3f, 0xbc, 0xfa, 0x29, 0xfc, 0xc6, 0x73, 0x68,
0x9e, 0x80, 0x0c, 0xc2, 0xfa, 0x11, 0xdc, 0xde, 0xa0, 0x8f, 0x5b, 0x53, 0x80, 0xcd, 0x4e, 0x4c,
0xd2, 0x15, 0x40, 0xa4, 0x18, 0x4e, 0x70, 0xf7, 0x0c, 0xc5, 0xe8, 0xc4, 0xbd, 0x6f, 0xc4, 0x46,
0x12, 0x45, 0xfe, 0xa8, 0x11, 0xd0, 0xd1, 0x4c, 0x1a, 0x99, 0x99, 0xf1, 0x3c, 0xdc, 0xb5, 0x8a,
0xef, 0xa6, 0x22, 0xd4, 0x9e, 0x75, 0x3f, 0x37, 0x73, 0x3c, 0x62, 0xb3, 0xc3, 0xa5, 0x87, 0xdd,
0xc2, 0x96, 0x8b, 0x02, 0xf1, 0x10, 0xf8, 0xed, 0x8b, 0x56, 0x29, 0x5b, 0xdc, 0x67, 0xbf, 0x39,
0x8d, 0x01, 0xc8, 0x8a, 0x89, 0x2e, 0xf2, 0x05, 0x43, 0xf6, 0x2b, 0x9b, 0x4e, 0xca, 0xd4, 0xca,
0x4c, 0xf8, 0xc1, 0xf7, 0xc2, 0x4a, 0x55, 0x87, 0xc0, 0xb4, 0xd4, 0xc6, 0xdf, 0xc5, 0xaf, 0xc0,
0x23, 0x90, 0x6f, 0x93, 0x25, 0x17, 0x52, 0xa2, 0xed, 0x90, 0x14, 0x8f, 0xdc, 0x74, 0xb1, 0x71,
0x3c, 0xaa, 0xfb, 0x60, 0x76, 0xd6, 0xc8, 0x17, 0x15, 0x5e, 0xae, 0xa3, 0xb7, 0xdd, 0x2e, 0x10,
0xe9, 0x3d, 0x33, 0x00, 0x7a, 0xd4, 0x8f, 0xda, 0x3a, 0x03, 0xeb, 0x2e, 0x01, 0x7c, 0xf8, 0xed,
0x50, 0x01, 0x65, 0x29, 0x94, 0x77, 0xf8, 0x97, 0x20, 0xca, 0xa2, 0xa9, 0x6a, 0xee, 0xbf, 0x4e,
0x74, 0x52, 0x5f, 0x5f, 0xc4, 0xc1, 0xb7, 0x43, 0x4c, 0x06, 0xd0, 0x2b, 0x77, 0x9a, 0x82, 0x01,
0x3b, 0x5a, 0x15, 0x6a, 0x40, 0x99, 0x50, 0xdb, 0x0c, 0x95, 0xa4, 0x97, 0xbf, 0x8a, 0x63, 0xd2,
0xd8, 0x06, 0xf1, 0x2c, 0xe0, 0x5a, 0xe2, 0x0e, 0x9a, 0xca, 0x1a, 0x9f, 0x71, 0xe1, 0x41, 0x86,
0x92, 0xd2, 0x0d, 0x6c, 0x40, 0xa9, 0x0b, 0xd9, 0x33, 0x0d, 0xaf, 0x6c, 0xdb, 0x69, 0xeb, 0x26,
0x8e, 0x29, 0xb3, 0xd0, 0x9f, 0x9c, 0xce, 0xb8, 0x95, 0x2f, 0xd0, 0x2b, 0x56, 0x94, 0xf1, 0xe7,
0x46, 0xff, 0x88, 0xd1, 0x93, 0x65, 0x79, 0x92, 0x57, 0x62, 0x12, 0x1d, 0x82, 0x4f, 0x80, 0xef,
0x98, 0x45, 0x09, 0xea, 0x7d, 0x04, 0xf1, 0xce, 0x03, 0xe3, 0x6a, 0x22, 0xdd, 0x3b, 0x80, 0x95,
0x87, 0x7e, 0x8b, 0xfc, 0xd8, 0xf6, 0x32, 0xeb, 0x45, 0xd8, 0x7d, 0xeb, 0x81, 0x11, 0xcb, 0x5d,
0x10, 0x35, 0x6b, 0xbe, 0x9c, 0x01, 0x7c, 0xfb, 0xb5, 0xc6, 0xb5, 0x9c, 0x87, 0x1b, 0xd9, 0xe0,
0xe4, 0x45, 0x67, 0xca, 0xd8, 0xf9, 0x18, 0x05, 0xea, 0x48, 0x8b, 0x45, 0x19, 0x03, 0xda, 0x5b,
0x68, 0x45, 0x23, 0xaf, 0xf7, 0xce, 0xae, 0x4e, 0xd8, 0xf8, 0xd3, 0x7c, 0xde, 0x41, 0x61, 0x01,
0xbe, 0xcf, 0x2b, 0x11, 0x6c, 0x40, 0xb3, 0x50, 0x0e, 0x77, 0xf5, 0xd8, 0x59, 0xac, 0x18, 0x95,
0xb5, 0x92, 0xa1, 0xce, 0x5c, 0x4b, 0xe5, 0xd2, 0x95, 0xef, 0xf4, 0x31, 0x6d, 0x45, 0x50, 0xe1,
0xbf, 0x43, 0x24, 0xbb, 0xe5, 0xb7, 0x1e, 0x92, 0x25, 0x7b, 0x39, 0x1d, 0x34, 0xd1, 0xdd, 0xf5,
0x25, 0xb8, 0x4b, 0x4e, 0x1e, 0xe5, 0xce, 0xb1, 0xb2, 0x5b, 0x8e, 0x7e, 0xbf, 0xad, 0xae, 0x61,
0xf9, 0xdc, 0xc1, 0xc7, 0x92, 0x86, 0xea, 0x2d, 0x2a, 0x1c, 0x07, 0xad, 0x94, 0xf2, 0x15, 0x6d,
0x61, 0xb0, 0xf1, 0xe8, 0x23, 0xdf, 0x0b, 0x79, 0x7b, 0x43, 0xda, 0x88, 0x74, 0xd4, 0xaf, 0x37,
0x16, 0xdb, 0x81, 0x1b, 0xf8, 0x0f, 0x3b, 0x7b, 0x2a, 0x0b, 0xbe, 0x7c, 0xd0, 0x92, 0x8c, 0x43,
0xc8, 0x95, 0xf8, 0x7f, 0xc0, 0x2a, 0x6d, 0xf5, 0xbc, 0xaf, 0x2e, 0x7f, 0xdb, 0xa2, 0xfe, 0x37,
0xc6, 0xe1, 0x6b, 0x8a, 0x38, 0xea, 0x60, 0x94, 0x2f, 0xb7, 0xdd, 0x14, 0x5a, 0x9a, 0xf6, 0x21,
0xda, 0x30, 0xbe, 0x1f, 0xe4, 0xa2, 0xc1, 0x3b, 0xfa, 0x5d, 0x98, 0xf3, 0x56, 0x7f, 0xe8, 0xb2,
0x33, 0x25, 0xce, 0xff, 0x64, 0xeb, 0xd8, 0x4c, 0xb9, 0x0c, 0x5d, 0xae, 0xc8, 0x43, 0x8e, 0x4c,
0x4c, 0x09, 0x7a, 0x42, 0x06, 0xe0, 0x04, 0xcc, 0x09, 0xe5, 0x68, 0x1a, 0x55, 0x5c, 0xfc, 0x15,
0x86, 0xe3, 0xe7, 0xf2, 0xb6, 0x15, 0x31, 0x56, 0xaf, 0xa7, 0x13, 0x35, 0x90, 0xe7, 0xec, 0xfa,
0x82, 0xea, 0x54, 0x22, 0xfc, 0x08, 0x1a, 0xb0, 0x55, 0xf3, 0x75, 0x08, 0x94, 0x33, 0x08, 0x6f,
0xfd, 0x1d, 0x69, 0x8c, 0x63, 0xb3, 0x4a, 0xd5, 0x50, 0xe9, 0xca, 0xeb, 0x42, 0xf1, 0x7c, 0x39,
0x1c, 0xcd, 0x95, 0x0a, 0xd3, 0xa0, 0xcd, 0xed, 0x43, 0x35, 0x05, 0x3e, 0x35, 0x21, 0x01, 0x6d,
0x23, 0x11, 0xd7, 0x49, 0xdb, 0xf2, 0xb7, 0xbe, 0x33, 0x38, 0x85, 0x74, 0xa6, 0x2c, 0x0b, 0x17,
0x4e, 0xd4, 0x12, 0x0d, 0xcb, 0xd7, 0x91, 0xad, 0x4f, 0xab, 0x53, 0x43, 0x50, 0x10, 0xf7, 0xc3,
0x02, 0x4e, 0xe8, 0x72, 0xef, 0x00, 0xd2, 0x9a, 0xd7, 0x9e, 0x3f, 0x2b, 0x33, 0x6a, 0x71, 0xc4,
0x6b, 0x21, 0x10, 0x1a, 0x0b, 0x8e, 0xe8, 0xcb, 0x34, 0x07, 0xa9, 0xf4, 0xb2, 0x55, 0x0b, 0x44,
0x35, 0x08, 0xbd, 0x21, 0xe6, 0x7a, 0x6f, 0xd2, 0xda, 0xc0, 0x09, 0x04, 0xda, 0xeb, 0x99, 0x35,
0x0c, 0xd4, 0x5f, 0xca, 0x32, 0x4f, 0xad, 0x5c, 0xe3, 0x1c, 0x4b, 0x10, 0x48, 0xf7, 0xa7, 0x1d,
0x30, 0xa2, 0x5b, 0xba, 0x2c, 0x36, 0x77, 0x99, 0x15, 0x18, 0xe2, 0xe0, 0x14, 0x30, 0x77, 0xb1,
0xed, 0xee, 0x1f, 0x28, 0x91, 0xf8, 0x55, 0xbe, 0xd7, 0xe4, 0x76, 0x04, 0x5f, 0x6b, 0xbb, 0xbf,
0xfe, 0xfe, 0xec, 0x70, 0x54, 0xaf, 0xf2, 0x8f, 0x69, 0x93, 0x1a, 0x5d, 0x0e, 0xf0, 0xd6, 0x30,
0x71, 0xa6, 0xdd, 0x20, 0x3b, 0x9f, 0xa7, 0xac, 0xe7, 0x83, 0xe9, 0x7b, 0x41, 0x9f, 0x82, 0xd9,
0xe2, 0x50, 0x65, 0xe1, 0x2a, 0x1c, 0xee, 0x8d, 0x84, 0xc9, 0xe8, 0x08, 0x0e, 0x0a, 0x33, 0x01,
0xd3, 0x76, 0x54, 0x99, 0x16, 0x2d, 0x72, 0xfd, 0x69, 0xf4, 0xe1, 0xd3, 0xd6, 0xf3, 0xa4, 0x8f,
0xc7, 0xb7, 0x2b, 0x59, 0x23, 0xcb, 0xf3, 0x1a, 0xe1, 0xad, 0x8b, 0x48, 0xc0, 0x39, 0x38, 0xae,
0x84, 0xc6, 0x75, 0xa6, 0x04, 0x2b, 0x29, 0xc1, 0xc3, 0x2a, 0x4f, 0x05, 0x1f, 0xb0, 0xa7, 0x0c,
0x6a, 0xe2, 0xec, 0x44, 0x44, 0x35, 0x39, 0xbc, 0x16, 0x82, 0x52, 0xcc, 0x92, 0xe9, 0x4b, 0x16,
0x23, 0x6a, 0xcc, 0x1d, 0xfe, 0xd1, 0xc4, 0xd7, 0xe6, 0x26, 0xd1, 0xa8, 0x4d, 0x3c, 0x8f, 0x9d,
0x6c, 0xab, 0xb3, 0x79, 0x09, 0xd6, 0xd4, 0x31, 0xc4, 0x1c, 0xd7, 0x4a, 0xda, 0x46, 0x43, 0xa4,
0x16, 0x21, 0xff, 0xc9, 0x43, 0xe5, 0x27, 0x4f, 0x32, 0x05, 0x0b, 0x03, 0x76, 0x36, 0x7a, 0xf6,
0x8a, 0x90, 0x20, 0xfa, 0xaa, 0x69, 0x2d, 0x0a, 0x49, 0x87, 0xfc, 0xf1, 0xb2, 0x2c, 0xf2, 0xba,
0xeb, 0xaa, 0x61, 0xed, 0x35, 0x18, 0xa4, 0x41, 0x4a, 0xf7, 0x89, 0x45, 0xc2, 0xdf, 0x80, 0x44,
0x8a, 0xcb, 0x49, 0xef, 0x61, 0x5e, 0xa6, 0x22, 0x2c, 0x55, 0x77, 0x0e, 0xe0, 0xfc, 0x35, 0xc3,
0x56, 0xdb, 0xe0, 0x19, 0xe2, 0xe1, 0xb0, 0xe3, 0x39, 0xa1, 0xc4, 0xcc, 0xa4, 0xdf, 0xca, 0xd2,
0x75, 0x9d, 0x99, 0x41, 0xc3, 0x98, 0xfd, 0xd8, 0x19, 0x20, 0x51, 0x37, 0xec, 0x8d, 0x74, 0x13,
0x0f, 0x42, 0x11, 0x75, 0x68, 0x58, 0x65, 0xcd, 0xbf, 0xfc, 0x16, 0xea, 0x37, 0xd6, 0x56, 0x59,
0xc3, 0x69, 0x4d, 0x49, 0x4d, 0x7c, 0x98, 0xaf, 0x85, 0x93, 0x8e, 0x2a, 0xea, 0x86, 0x19, 0x0c,
0x64, 0x2d, 0xc5, 0x79, 0xd8, 0xbd, 0xdc, 0x91, 0x53, 0x3c, 0x48, 0x41, 0xad, 0xd8, 0xdd, 0x09,
0x2e, 0xfd, 0x32, 0x71, 0xe3, 0xd7, 0x81, 0x26, 0x34, 0xeb, 0xc8, 0x5c, 0x68, 0x67, 0xd4, 0x5e,
0x1f, 0x47, 0xbc, 0xd5, 0x96, 0x72, 0x6a, 0xfb, 0x23, 0x3a, 0xbd, 0xdc, 0x32, 0x09, 0x61, 0x0a,
0xb1, 0xbf, 0x02, 0x51, 0x1b, 0x24, 0xe7, 0x4d, 0x27, 0xd3, 0x38, 0x1e, 0x7a, 0x76, 0x2c, 0xbe,
0xdc, 0x11, 0x8f, 0x6a, 0x82, 0x6e, 0xf5, 0x55, 0xf7, 0xf7, 0x8e, 0x2c, 0x5d, 0xa1, 0x52, 0xe5,
0xb0, 0x3e, 0xaa, 0x39, 0xa1, 0x04, 0xf1, 0x09, 0xec, 0xa6, 0x34, 0x1c, 0xaa, 0xaa, 0x3a, 0xdf,
0xad, 0x65, 0xce, 0x2f, 0x19, 0x30, 0x34, 0x38, 0x44, 0x7c, 0xd6, 0x4d, 0x46, 0x8a, 0xd6, 0xcd,
0xd0, 0xcd, 0x36, 0xb2, 0x28, 0xa2, 0x44, 0xe9, 0xda, 0x1c, 0xa5, 0xd5, 0xa6, 0x90, 0x48, 0xf6,
0xf4, 0xad, 0x4b, 0x02, 0x89, 0x81, 0xcc, 0x90, 0x57, 0x0c, 0x0c, 0xf5, 0x28, 0xf5, 0xfc, 0xca,
0x66, 0x5b, 0x61, 0x2c, 0x7c, 0x3e, 0x3d, 0x2e, 0x35, 0x9f, 0xc2, 0xb1, 0x72, 0x77, 0x7b, 0x3b,
0x00, 0x15, 0x51, 0x59, 0xd5, 0xc8, 0x21, 0x5c, 0x36, 0xf0, 0xa2, 0x9d, 0xdb, 0xd9, 0x8b, 0xef,
0x95, 0xbd, 0x9b, 0x0e, 0x4a, 0xb7, 0xfd, 0x27, 0xe1, 0x36, 0xab, 0x02, 0x07, 0x5e, 0xba, 0x55,
0x26, 0x02, 0xc3, 0xd6, 0xde, 0xfd, 0x15, 0x5f, 0xef, 0x10, 0x5a, 0x93, 0x3e, 0x68, 0x5f, 0x19,
0xbd, 0x8e, 0x6a, 0x4b, 0x7f, 0x82, 0x93, 0x62, 0x42, 0x8d, 0x0e, 0x7c, 0x42, 0x98, 0x2d, 0x48,
0x8e, 0x02, 0x40, 0xa7, 0xa1, 0xc0, 0x0b, 0x7a, 0xe0, 0x79, 0x65, 0x8c, 0x02, 0xa7, 0x3e, 0x4e,
0x1d, 0xca, 0x14, 0x8d, 0x1b, 0xde, 0x0a, 0x80, 0xc4, 0x0c, 0xef, 0xeb, 0x05, 0xa0, 0x18, 0x05,
0x83, 0xa5, 0x3d, 0xd8, 0x19, 0xd3, 0x36, 0xa3, 0x8d, 0x96, 0xbe, 0x2a, 0xa4, 0x6e, 0x7a, 0x78,
0xa1, 0xb9, 0x1c, 0x44, 0xaf, 0x62, 0x7d, 0x1b, 0x32, 0xd0, 0x81, 0x06, 0x9c, 0x98, 0x3c, 0x4f,
0x87, 0x34, 0x05, 0x11, 0xb4, 0x86, 0x6e, 0x73, 0x63, 0xb1, 0xe0, 0x8c, 0x2a, 0x4d, 0xb0, 0xec,
0x7b, 0xba, 0x19, 0x0b, 0x61, 0x1d, 0xa4, 0xa6, 0xd8, 0x53, 0xcf, 0x0b, 0x97, 0xf4, 0x55, 0xca,
0x02, 0xbf, 0x8a, 0x3d, 0xb7, 0x4d, 0x32, 0x61, 0xbc, 0xee, 0x2b, 0x86, 0x67, 0xc1, 0x15, 0x10,
0xcf, 0xbd, 0x62, 0x69, 0xca, 0x9f, 0xe5, 0xcb, 0x18, 0xd4, 0x2d, 0xd5, 0xd9, 0x03, 0x44, 0x1f,
0xa3, 0xdb, 0x71, 0x2c, 0x74, 0x14, 0x06, 0x52, 0x9e, 0xf8, 0x4b, 0x35, 0x78, 0xe4, 0x27, 0xf2,
0x60, 0x22, 0x31, 0x80, 0x3b, 0xd7, 0x95, 0xa2, 0xc4, 0x89, 0xfb, 0x0b, 0x23, 0xf0, 0x4c, 0x48,
0x5e, 0x19, 0x92, 0x35, 0x3c, 0x58, 0x47, 0x55, 0x35, 0x31, 0x31, 0x2f, 0x96, 0x6f, 0xa8, 0xe9,
0x66, 0x78, 0x8b, 0x0f, 0x7e, 0x7e, 0xcd, 0x75, 0x85, 0x34, 0x67, 0xb1, 0xcf, 0x47, 0x3d, 0x39,
0x2a, 0x3f, 0x40, 0x6c, 0x40, 0x03, 0xa8, 0xd9, 0x73, 0xc0, 0xc9, 0xa9, 0x06, 0xb0, 0x57, 0x98,
0xd7, 0xab, 0xaf, 0x4c, 0xa0, 0x28, 0x4a, 0x09, 0xe3, 0x21, 0xd6, 0xa3, 0x7b, 0x9e, 0xae, 0x69,
0x72, 0x42, 0xd8, 0xac, 0xe7, 0x20, 0x57, 0x82, 0x42, 0xd0, 0xb8, 0x05, 0x7d, 0xb3, 0xb1, 0x57,
0x0a, 0x60, 0xa2, 0xa0, 0x42, 0x2e, 0x18, 0x84, 0x29, 0xc7, 0xdc, 0xfb, 0x34, 0x7f, 0x41, 0xc8,
0x29, 0x31, 0xe5, 0x00, 0x1c, 0x11, 0x23, 0x30, 0x84, 0xd4, 0x8e, 0xf4, 0x24, 0xfb, 0x51, 0xb6,
0x33, 0xac, 0x37, 0x4d, 0x42, 0xa5, 0x18, 0x05, 0x79, 0x61, 0x19, 0xeb, 0xc0, 0x1f, 0x62, 0x79,
0x7e, 0x1c, 0xf0, 0xa2, 0x72, 0x5a, 0xaf, 0x90, 0xe5, 0x14, 0x90, 0xb3, 0xe7, 0x6a, 0x29, 0xde,
0xe3, 0x0a, 0xc3, 0x8e, 0x3d, 0x5d, 0x7a, 0xab, 0x5e, 0x04, 0xa1, 0xda, 0x73, 0xde, 0x24, 0x04,
0xe0, 0x92, 0xe5, 0x40, 0x46, 0x6e, 0x0c, 0xec, 0xd0, 0x1d, 0xf9, 0x45, 0x12, 0xb5, 0xf3, 0x23,
0x0c, 0xd7, 0x3a, 0x5c, 0xbb, 0x72, 0x57, 0x32, 0x7c, 0x3b, 0x94, 0x67, 0x80, 0x2e, 0x5b, 0xbc,
0x61, 0x15, 0x6f, 0xa0, 0x5b, 0xcb, 0xef, 0x91, 0x46, 0xcf, 0xd5, 0x35, 0xf0, 0x2e, 0x9e, 0xc6,
0x9b, 0x93, 0x6d, 0x52, 0xf3, 0xa1, 0xf6, 0x70, 0x04, 0xd7, 0x9d, 0x81, 0xad, 0xb6, 0x9c, 0x67,
0x26, 0x28, 0x4e, 0x79, 0x12, 0xac, 0x72, 0x2f, 0x38, 0xe8, 0xe2, 0x9e, 0xcb, 0xca, 0x47, 0xc5,
0x0f, 0xc5, 0x5e, 0x7e, 0x67, 0xd9, 0x0a, 0xa8, 0xda, 0x3b, 0xaf, 0xed, 0x2d, 0x77, 0xf5, 0x48,
0xc6, 0x32, 0x96, 0x2a, 0xf2, 0x71, 0x65, 0x90, 0x82, 0xae, 0xe6, 0xf3, 0x2b, 0x72, 0x96, 0x88,
0xe8, 0x14, 0x5b, 0x42, 0x92, 0xcb, 0xf8, 0x86, 0x22, 0xab, 0x38, 0x1c, 0x13, 0x8b, 0xf8, 0xe3,
0xd2, 0xe0, 0xe7, 0x5a, 0xea, 0xb0, 0x48, 0xda, 0x2e, 0xe5, 0x2e, 0x3f, 0x71, 0xe8, 0x7d, 0x5a,
0x1d, 0x7d, 0xea, 0x98, 0x77, 0xe1, 0x38, 0xa7, 0x3b, 0xa4, 0xb4, 0xb1, 0xa7, 0x19, 0xa0, 0x08,
0x5a, 0x9a, 0xb9, 0x6d, 0x60, 0xb0, 0xf2, 0x8c, 0xb8, 0x5e, 0x69, 0x6a, 0x8d, 0xdd, 0xcb, 0x5f,
0xe2, 0x6b, 0x28, 0x13, 0xd3, 0xcb, 0xb2, 0x64, 0xa0, 0x98, 0x38, 0x91, 0x4c, 0x87, 0x52, 0xad,
0x35, 0x25, 0x12, 0x4f, 0x85, 0xb1, 0x10, 0x4f, 0x2f, 0x26, 0xfc, 0x20, 0xc4, 0x6f, 0xd2, 0xf0,
0x19, 0x54, 0xb4, 0xa0, 0xbc, 0xb3, 0x8d, 0xaa, 0xbf, 0xb4, 0xec, 0x1e, 0x53, 0x03, 0x1b, 0xcb,
0xd0, 0xa0, 0xb7, 0xbd, 0xf7, 0x79, 0x07, 0xc2, 0x0c, 0xde, 0x77, 0x78, 0xa3, 0x3a, 0x90, 0x72,
0x15, 0x74, 0x8f, 0xeb, 0x3e, 0x75, 0xa9, 0x4d, 0x09, 0x1b, 0xb7, 0xd0, 0xcf, 0x3e, 0x2d, 0x41,
0x74, 0x66, 0x6f, 0xb2, 0x48, 0x9f, 0xf3, 0xe7, 0x32, 0x2d, 0x60, 0xde, 0x84, 0x35, 0xd3, 0xbf,
0xd6, 0xd3, 0x03, 0x7b, 0xbc, 0xa0, 0x6d, 0x0b, 0xf9, 0xd9, 0x20, 0x06, 0xad, 0xac, 0x8a, 0x8d,
0xaa, 0x10, 0xdb, 0xe9, 0x12, 0x4a, 0xc4, 0xc0, 0xa4, 0xee, 0x69, 0x83, 0xd6, 0xf8, 0x10, 0x1d,
0xf6, 0x2f, 0xc1, 0xd2, 0x50, 0x8a, 0x18, 0xc9, 0xca, 0x76, 0x98, 0x98, 0x92, 0xbe, 0xb2, 0xf2,
0x44, 0x6d, 0x6e, 0xf1, 0xf6, 0xe0, 0x1b, 0x44, 0x7f, 0xe9, 0x7e, 0x2b, 0x10, 0x96, 0xb6, 0x2b,
0xd5, 0x55, 0xd4, 0x68, 0x3a, 0x7b, 0xb4, 0x94, 0xda, 0xbe, 0xec, 0xb0, 0xbd, 0x5a, 0xab, 0x15,
0xcf, 0x7d, 0x3b, 0x8c, 0x15, 0x89, 0xb2, 0x0c, 0x0c, 0xa7, 0x3b, 0xba, 0x32, 0x47, 0x25, 0x69,
0x55, 0xbb, 0xf7, 0x59, 0x2a, 0xfb, 0x77, 0x80, 0xf8, 0x16, 0xe4, 0xd6, 0xa7, 0x3e, 0x61, 0xc7,
0xce, 0xd2, 0x9c, 0x76, 0x85, 0x4f, 0x41, 0x66, 0x4b, 0x21, 0xf1, 0x69, 0x41, 0x4a, 0x79, 0x3a,
0x84, 0x96, 0x3d, 0x92, 0xa2, 0x1b, 0x08, 0x26, 0x29, 0x63, 0x42, 0x98, 0x1a, 0xdc, 0xa7, 0x84,
0x74, 0xc9, 0x65, 0xf2, 0x2f, 0x74, 0xab, 0xa6, 0xfc, 0x86, 0xcd, 0x61, 0xba, 0xcd, 0x1a, 0x4e,
0xdf, 0xfb, 0x79, 0x2c, 0x5c, 0x9e, 0x40, 0x36, 0x07, 0x5f, 0xc6, 0x08, 0x32, 0x36, 0x7a, 0x82,
0xa9, 0x42, 0x8b, 0x8b, 0x9e, 0xe2, 0xfc, 0xaf, 0x59, 0x53, 0xeb, 0x73, 0xbe, 0xc2, 0x9b, 0xc2,
0xa8, 0x36, 0x79, 0xcb, 0xd7, 0x2d, 0x95, 0xcd, 0xf3, 0x32, 0xa1, 0xde, 0x37, 0x2d, 0x4b, 0x31,
0x6f, 0x6b, 0x72, 0x23, 0x92, 0xe9, 0x8c, 0x7b, 0xc5, 0x0b, 0x66, 0x43, 0xaf, 0xa4, 0x4b, 0xc0,
0x58, 0xe4, 0xc4, 0x3d, 0x70, 0x4b, 0x44, 0x39, 0xc3, 0xcd, 0x63, 0xbb, 0x9d, 0xe6, 0xf9, 0xfb,
0x31, 0x38, 0x18, 0x94, 0xb0, 0xaa, 0x5a, 0x76, 0xf1, 0xd2, 0xe1, 0xac, 0x71, 0x31, 0xb7, 0x6e,
0xf8, 0x4e, 0x78, 0x50, 0xc1, 0x13, 0x6e, 0xac, 0x59, 0x66, 0x62, 0xbc, 0xf4, 0x30, 0x3f, 0xda,
0xb2, 0xff, 0x8d, 0x6c, 0x93, 0xb9, 0xd8, 0x54, 0x2c, 0x21, 0xd2, 0x34, 0xd2, 0x65, 0xd3, 0xd2,
0x30, 0x3f, 0x36, 0x20, 0x28, 0x65, 0xb9, 0xa4, 0x68, 0x4c, 0x1f, 0x4f, 0xe3, 0xca, 0xa5, 0xbe,
0x0f, 0x28, 0x9a, 0xf8, 0xf8, 0xe3, 0xdf, 0xa6, 0xc9, 0x9d, 0x95, 0x09, 0x6f, 0xc6, 0x37, 0xf8,
0x20, 0xd2, 0x51, 0xf2, 0xc0, 0x6d, 0x33, 0x75, 0xd3, 0x00, 0xea, 0x3d, 0xf7, 0x1e, 0xc0, 0x5b,
0xf0, 0x17, 0xff, 0x14, 0x8c, 0xa8, 0xf0, 0xb5, 0xfe, 0xc9, 0x53, 0x08, 0xca, 0x48, 0xa4, 0x6c,
0xc7, 0x7e, 0x4a, 0x5c, 0x31, 0x01, 0xce, 0xa6, 0x68, 0x97, 0x9b, 0xc6, 0x1f, 0xe2, 0x20, 0x54,
0x3d, 0xde, 0xc8, 0x80, 0x86, 0xe9, 0xc5, 0x0a, 0x2c, 0xb6, 0x2e, 0xb3, 0xb6, 0x1d, 0xbf, 0x79,
0x12, 0x27, 0x69, 0x1f, 0xc2, 0x1f, 0xa3, 0xd5, 0x22, 0xab, 0x4f, 0x1c, 0x9f, 0x35, 0xc1, 0xe3,
0x0d, 0xd5, 0x5b, 0xd5, 0xa4, 0x72, 0x8c, 0x7c, 0x5c, 0x8b, 0xd0, 0x1c, 0xfc, 0x8f, 0x2e, 0x95,
0x59, 0x0f, 0x2e, 0xc5, 0xd7, 0x7b, 0x58, 0xbe, 0x27, 0x91, 0x2b, 0x09, 0x4a, 0x7c, 0x3b, 0x21,
0x19, 0x07, 0x32, 0xc5, 0x37, 0xc2, 0x69, 0x7f, 0x10, 0x53, 0xa7, 0xcf, 0x2e, 0x0b, 0x87, 0xb4,
0x39, 0x6e, 0x49, 0xb7, 0xfb, 0x1d, 0x29, 0xf1, 0x9e, 0x70, 0xdd, 0x61, 0x70, 0xe1, 0x63, 0x23,
0xcd, 0x7f, 0x7e, 0x33, 0xf0, 0x29, 0x5a, 0x5e, 0x19, 0xe4, 0xc7, 0xed, 0xf1, 0x80, 0x9e, 0xaa,
0xe9, 0xa8, 0xd8, 0x07, 0x4a, 0x03, 0xab, 0x13, 0x50, 0x72, 0x59, 0x26, 0x62, 0x0e, 0xff, 0xa4,
0xaf, 0x05, 0x73, 0x0e, 0xf6, 0xdc, 0x06, 0xa2, 0xb8, 0xd3, 0x64, 0x22, 0xa8, 0x58, 0x6b, 0x44,
0xa7, 0x9e, 0x14, 0xde, 0x79, 0x87, 0xed, 0x13, 0xee, 0xad, 0xbd, 0x87, 0xed, 0xe8, 0x82, 0xa7,
0x20, 0x8c, 0x81, 0xd4, 0x7b, 0x45, 0xe1, 0x19, 0xda, 0x17, 0x4a, 0xdb, 0xc6, 0xb3, 0xf7, 0x6b,
0xc9, 0x17, 0x53, 0x96, 0x58, 0x00, 0x21, 0x5a, 0x52, 0xdd, 0xf7, 0xb7, 0xf3, 0x64, 0x8b, 0xfd,
0x40, 0x70, 0x10, 0xd7, 0xd3, 0x7e, 0xa7, 0x6b, 0xb2, 0xb5, 0xbf, 0x02, 0x0a, 0x63, 0xb8, 0x6c,
0xa9, 0xb0, 0x6d, 0x84, 0x1e, 0x81, 0x1d, 0x69, 0xe5, 0x02, 0xd2, 0x81, 0x63, 0x28, 0x9e, 0x58,
0xfc, 0x20, 0xcc, 0xaa, 0xbc, 0x3e, 0x0b, 0x61, 0x24, 0xea, 0x41, 0x6c, 0xf5, 0x24, 0x64, 0x4e,
0xee, 0x3a, 0xaf, 0xb3, 0xec, 0xf3, 0xe2, 0x73, 0x66, 0x7f, 0x1d, 0x1e, 0xd3, 0x5d, 0xfc, 0x0c,
0x20, 0xb9, 0xca, 0xe8, 0x61, 0x8a, 0x82, 0xb7, 0xc3, 0x80, 0x3c, 0x5e, 0x09, 0x08, 0x88, 0x5a,
0x92, 0xdd, 0xfc, 0x42, 0xa0, 0xb1, 0x42, 0x6d, 0xbf, 0xd8, 0x06, 0x6b, 0x5a, 0xa3, 0x9a, 0x1b,
0xf7, 0x97, 0x35, 0xef, 0x31, 0xb0, 0x05, 0x95, 0x89, 0x5a, 0x37, 0xd2, 0x4c, 0x77, 0xe2, 0x51,
0xc9, 0x54, 0x6e, 0xab, 0x0d, 0x69, 0xa6, 0xa0, 0xa0, 0x20, 0xa7, 0xfc, 0xa9, 0x6c, 0x1b, 0x19,
0x97, 0x8d, 0xa6, 0xac, 0xed, 0x6f, 0x25, 0xbc, 0xac, 0x5d, 0x2c, 0x95, 0xc3, 0xaa, 0xca, 0x9b,
0x7d, 0x4b, 0x88, 0x72, 0x6a, 0x2f, 0xe8, 0x50, 0x70, 0x45, 0xf3, 0x09, 0xfe, 0x5e, 0xb8, 0xe5,
0xe8, 0x4b, 0xc8, 0xc1, 0xc8, 0x07, 0x5c, 0x94, 0xe2, 0xc6, 0x8e, 0xdd, 0x50, 0xa2, 0xee, 0x67,
0x85, 0xac, 0x0a, 0x91, 0x69, 0x9f, 0xc4, 0x02, 0x66, 0x59, 0xd8, 0x7c, 0x37, 0xb3, 0xab, 0x93,
0xc4, 0x83, 0xfc, 0xa0, 0x72, 0x0e, 0x3d, 0x16, 0x5a, 0x9e, 0xf8, 0xb6, 0x9b, 0xeb, 0x68, 0xa2,
0xa4, 0xd5, 0x93, 0x16, 0x4e, 0x69, 0xd5, 0xca, 0xa5, 0x5b, 0x33, 0xce, 0x91, 0x0f, 0x8a, 0xc3,
0x1c, 0x80, 0xbe, 0x66, 0x1d, 0xc9, 0xec, 0x17, 0x46, 0x51, 0x50, 0x92, 0x1c, 0x31, 0x7d, 0xfc,
0x72, 0x25, 0xb3, 0x38, 0xe6, 0x8a, 0x08, 0xc7, 0x1a, 0x8a, 0x7e, 0x51, 0x35, 0xe7, 0x8b, 0xec,
0xb7, 0x2f, 0xf7, 0x10, 0x10, 0x37, 0x16, 0x5c, 0xfe, 0xc0, 0xf3, 0x68, 0x50, 0x7a, 0x46, 0x5c,
0x5e, 0xbe, 0x97, 0xc3, 0xde, 0x11, 0xfc, 0x9d, 0x0d, 0x3a, 0xd5, 0xfd, 0x76, 0xeb, 0x89, 0xd7,
0x2d, 0xb7, 0x65, 0x3f, 0xd5, 0x23, 0xad, 0xba, 0xb7, 0xca, 0x4a, 0x4f, 0x79, 0x8d, 0x3b, 0x64,
0xf5, 0xf5, 0xfa, 0x80, 0xb0, 0xf3, 0x24, 0x9e, 0x5a, 0x91, 0xb1, 0xb5, 0x20, 0x06, 0x56, 0x70,
0xb4, 0x57, 0x6f, 0x0f, 0xad, 0x06, 0x3b, 0xc0, 0xa5, 0x59, 0xf6, 0x1b, 0x03, 0x4e, 0xe6, 0xb8,
0x9f, 0xff, 0xe8, 0x41, 0x78, 0xd1, 0x98, 0xc1, 0xaa, 0x70, 0xd0, 0xc3, 0x10, 0xcd, 0x49, 0x1b,
0x68, 0x20, 0x89, 0x00, 0x52, 0xf0, 0xa5, 0x5c, 0xfe, 0x75, 0x69, 0x43, 0x29, 0x9e, 0x54, 0xdc,
0xfc, 0x6b, 0xee, 0xe7, 0x9e, 0xba, 0x19, 0xe3, 0x9c, 0x32, 0xbf, 0xde, 0xec, 0xc3, 0x59, 0xdc,
0x2a, 0x76, 0x85, 0x4c, 0x5d, 0x78, 0x28, 0xda, 0xca, 0xd8, 0xa2, 0xf2, 0x2a, 0xc2, 0x0e, 0x88,
0xb5, 0x66, 0x4b, 0x3f, 0xca, 0x43, 0xd0, 0x46, 0x8c, 0xb0, 0xe1, 0x81, 0x64, 0x07, 0x41, 0xa5,
0x21, 0xed, 0x9a, 0x56, 0x5e, 0x36, 0x4a, 0x5c, 0xf5, 0xa7, 0x3f, 0xd9, 0x9a, 0xb8, 0x8a, 0xea,
0x5a, 0x7a, 0x7b, 0x2d, 0x3d, 0xc9, 0x70, 0x43, 0x7f, 0x42, 0xf8, 0xa5, 0xf3, 0x00, 0x32, 0x0e,
0xf8, 0x20, 0x90, 0xc1, 0x72, 0xbc, 0x12, 0xcb, 0x22, 0xa3, 0xf3, 0x97, 0xb8, 0x58, 0xea, 0xeb,
0xea, 0xd0, 0x8c, 0x34, 0xb3, 0x36, 0x37, 0x1c, 0x43, 0xe7, 0x7c, 0x93, 0x65, 0x41, 0x00, 0xf0,
0xb2, 0xe4, 0xae, 0x31, 0x58, 0x06, 0x7a, 0x35, 0x89, 0xdf, 0x6e, 0x38, 0x96, 0x3f, 0xb0, 0xa5,
0x5c, 0xcb, 0x87, 0x96, 0x9b, 0x64, 0xa0, 0x7a, 0xfd, 0x48, 0x8b, 0xd3, 0xf0, 0xa1, 0x67, 0x32,
0x77, 0x0b, 0x24, 0x21, 0x79, 0xb0, 0xef, 0x66, 0x6d, 0x1a, 0x53, 0x11, 0xad, 0x0d, 0xd8, 0x31,
0x8c, 0xc0, 0xb3, 0x2c, 0xf0, 0x44, 0x45, 0x0a, 0xc0, 0x7b, 0xa5, 0xf0, 0x37, 0x3f, 0xea, 0xb3,
0xf5, 0x58, 0x18, 0x51, 0x04, 0x7f, 0x23, 0xf8, 0xbb, 0xcc, 0x6a, 0xdc, 0xf0, 0x30, 0xfa, 0x87,
0x3d, 0xc4, 0x75, 0x04, 0x1e, 0x2d, 0x45, 0xf0, 0xe2, 0x42, 0x67, 0xd2, 0x88, 0xc0, 0x04, 0x44,
0xe7, 0xab, 0x02, 0xf0, 0xbe, 0x86, 0x1a, 0x1d, 0xc0, 0x9b, 0x28, 0x04, 0x05, 0x39, 0x28, 0xf2,
0xfb, 0x3f, 0x2d, 0x79, 0x3e, 0xcf, 0x0a, 0xef, 0x65, 0x23, 0xf4, 0x3c, 0x41, 0xbc, 0xb0, 0x0f,
0xae, 0x26, 0xb8, 0x58, 0xa1, 0x75, 0xdf, 0x27, 0xcd, 0x4a, 0xbd, 0xa3, 0x6a, 0x9e, 0xe7, 0x32,
0x13, 0x65, 0x71, 0x75, 0x21, 0xa6, 0xbe, 0xb3, 0xcd, 0x9c, 0x42, 0xa1, 0x62, 0x6b, 0x9c, 0x79,
0xbf, 0xef, 0x93, 0xc3, 0x7c, 0xf2, 0x57, 0x70, 0x68, 0x14, 0x5d, 0xf1, 0xb7, 0x2a, 0x71, 0x11,
0xfc, 0x7a, 0xdd, 0x0e, 0xdf, 0xa1, 0xef, 0xca, 0x5e, 0xb3, 0x2e, 0x67, 0xf1, 0x82, 0x25, 0x84,
0x20, 0x11, 0x07, 0x6a, 0xe5, 0x4d, 0x63, 0xe9, 0xb0, 0x39, 0xf3, 0x42, 0x13, 0x8e, 0xc3, 0x39,
0x0a, 0x18, 0x8c, 0x15, 0x37, 0x1b, 0xec, 0x2d, 0x9b, 0x4b, 0x97, 0x20, 0x8b, 0x67, 0x34, 0xcb,
0xa2, 0x5b, 0x3d, 0xce, 0xdd, 0xb5, 0xd6, 0xbe, 0xf1, 0x75, 0x3c, 0x15, 0x93, 0xd7, 0x47, 0xd8,
0x0a, 0x97, 0xd1, 0xe4, 0x68, 0xb8, 0x16, 0xa8, 0x64, 0xb7, 0x9e, 0x8e, 0x55, 0x2c, 0x45, 0xab,
0xc4, 0xb8, 0xaa, 0xc7, 0x26, 0x69, 0x92, 0x7d, 0x47, 0x53, 0x11, 0x07, 0x04, 0x18, 0x70, 0x7b,
0xcb, 0xbb, 0x5f, 0x60, 0x55, 0x07, 0xbb, 0x28, 0x2a, 0x74, 0x09, 0x2f, 0x6f, 0x91, 0x19, 0xf3,
0x5c, 0xcb, 0x29, 0x1e, 0xef, 0x87, 0xd4, 0xa4, 0x83, 0x1c, 0xe7, 0x8a, 0x61, 0xb4, 0xfe, 0x7a,
0xa4, 0x2c, 0xc0, 0x63, 0x47, 0x53, 0x93, 0x24, 0xde, 0x1e, 0x46, 0x62, 0x7e, 0xb2, 0x76, 0x58,
0x39, 0x80, 0x3a, 0x54, 0x41, 0xa4, 0xa5, 0xaf, 0xa5, 0x7f, 0x18, 0xcf, 0xca, 0xe6, 0x17, 0x5e,
0xc8, 0x0a, 0x54, 0x9e, 0x24, 0x35, 0xa5, 0x85, 0x1e, 0x4e, 0xe4, 0x00, 0xd4, 0xfc, 0xb2, 0x08,
0x5d, 0xef, 0x99, 0x28, 0xe9, 0xcf, 0x5c, 0xa2, 0x89, 0x4c, 0x10, 0xba, 0x4c, 0xa3, 0x35, 0x35,
0x99, 0xb7, 0x5e, 0xfd, 0x5e, 0x5e, 0x63, 0xd5, 0x3a, 0x6e, 0xf9, 0x2a, 0xf1, 0x0b, 0x34, 0xfc,
0x40, 0x8f, 0xe8, 0x85, 0xc5, 0x82, 0x16, 0xa0, 0xfc, 0x39, 0x94, 0xbb, 0xb0, 0x6a, 0x3d, 0x9a,
0xe0, 0x04, 0xf4, 0x90, 0x04, 0x57, 0x70, 0x99, 0xc3, 0x98, 0x35, 0x37, 0x3f, 0x2e, 0x36, 0x27,
0x81, 0x27, 0xbb, 0x5f, 0x33, 0x32, 0xe3, 0x93, 0xd3, 0x1d, 0x79, 0xa9, 0x0e, 0x43, 0x0b, 0x02,
0xa5, 0x31, 0x2f, 0x96, 0x93, 0x8f, 0xea, 0x2a, 0x84, 0x68, 0x52, 0x2f, 0x89, 0x1a, 0xfe, 0xb4,
0xc6, 0x11, 0xd5, 0x64, 0xe3, 0x44, 0xc5, 0xe9, 0xfe, 0x17, 0x7f, 0x03, 0xd6, 0x9b, 0x62, 0xff,
0xd0, 0xf5, 0xdc, 0x9f, 0x04, 0x0c, 0xe3, 0x0f, 0x41, 0x6f, 0x48, 0x62, 0x79, 0x6d, 0xd2, 0xc1,
0x51, 0x76, 0xc3, 0x4e, 0x6b, 0x54, 0x54, 0x42, 0xb9, 0xa5, 0x82, 0x47, 0x48, 0x8b, 0x91, 0x63,
0xba, 0xcb, 0x34, 0x8c, 0x2e, 0x36, 0x09, 0x85, 0x44, 0x1e, 0x1d, 0x1f, 0x28, 0x90, 0x60, 0xbc,
0x58, 0xb9, 0xd7, 0xfe, 0xe6, 0x12, 0xe8, 0xe2, 0x5f, 0x4b, 0x80, 0x0b, 0x90, 0x10, 0x39, 0xd2,
0x2e, 0x84, 0xd1, 0x99, 0x3d, 0xe6, 0x84, 0xdb, 0x41, 0x17, 0x73, 0x28, 0xfc, 0xc5, 0x15, 0x08,
0xb0, 0x15, 0x61, 0x69, 0x90, 0x29, 0xea, 0xdb, 0xa9, 0xac, 0xe6, 0x4f, 0x26, 0xbb, 0xde, 0x50,
0xa0, 0xcc, 0xd8, 0x3d, 0x4b, 0x5d, 0xe2, 0xb7, 0x87, 0x3f, 0x42, 0x81, 0x67, 0x91, 0xc4, 0x54,
0x18, 0xe7, 0x39, 0x6a, 0x3a, 0xc9, 0xc9, 0x87, 0xd5, 0x55, 0x54, 0x06, 0xab, 0xd1, 0x44, 0xf0,
0x9d, 0x03, 0x78, 0x9b, 0x7a, 0xd0, 0x40, 0x72, 0xd8, 0x37, 0xc5, 0x77, 0x3d, 0xbf, 0x7f, 0x2c,
0xc4, 0xce, 0x96, 0x16, 0x17, 0xe6, 0x12, 0x6b, 0x84, 0x20, 0x82, 0x47, 0xbc, 0xc3, 0x9b, 0x21,
0xed, 0x60, 0x75, 0x37, 0xac, 0x94, 0x71, 0x46, 0xb3, 0xdc, 0x6e, 0x6a, 0x71, 0x84, 0x5d, 0xef,
0x0e, 0x92, 0x87, 0x21, 0xc4, 0x1a, 0x06, 0xad, 0xff, 0x0f, 0x34, 0xfa, 0x75, 0x10, 0xc8, 0x08,
0x3b, 0x7a, 0x8b, 0x0d, 0x16, 0xb6, 0x9c, 0x93, 0xe3, 0x42, 0xc4, 0x65, 0x5d, 0x40, 0x62, 0x7f,
0xc6, 0x3e, 0xd1, 0xd5, 0x3e, 0x39, 0x34, 0xfe, 0xb7, 0x96, 0xd7, 0xaf, 0xc3, 0xa4, 0x1c, 0x8c,
0x11, 0xa8, 0xd9, 0xce, 0x54, 0x03, 0x8c, 0xc9, 0x93, 0xfc, 0xbf, 0x06, 0xe0, 0x66, 0xbf, 0xb7,
0xca, 0x54, 0xf4, 0x9e, 0x98, 0x14, 0x53, 0x78, 0x3b, 0xf8, 0x3a, 0x7f, 0xa2, 0x36, 0xa1, 0x3c,
0xf0, 0x3d, 0x61, 0x20, 0x6c, 0x89, 0x63, 0x83, 0x22, 0xd6, 0xae, 0xef, 0x90, 0x70, 0x88, 0x89,
0xa6, 0xca, 0x38, 0x7f, 0x12, 0x8c, 0x31, 0x6d, 0x0e, 0xc9, 0x73, 0x61, 0xa9, 0x39, 0x4b, 0x14,
0x5b, 0xcc, 0xea, 0xd7, 0xe1, 0xaf, 0x01, 0x9f, 0x89, 0x12, 0xe5, 0x9d, 0xa9, 0x4e, 0xf0, 0xbf,
0x6d, 0xff, 0x97, 0x48, 0x3c, 0xd9, 0x20, 0x61, 0x2c, 0x87, 0x6e, 0x2b, 0xcb, 0x0f, 0x87, 0x36,
0xc0, 0x12, 0x9f, 0xa1, 0xad, 0x33, 0x59, 0x7c, 0x12, 0x5a, 0x8a, 0xe0, 0x54, 0x58, 0xe6, 0x4c,
0x08, 0x01, 0x8d, 0xb9, 0x27, 0x4d, 0x9c, 0xbc, 0xca, 0x14, 0x39, 0x71, 0x43, 0xf1, 0xa7, 0x02,
0x58, 0x85, 0x99, 0x54, 0x41, 0x14, 0xb2, 0xab, 0xdf, 0x7e, 0x89, 0xc2, 0x96, 0x24, 0xeb, 0x67,
0x8b, 0x43, 0xda, 0x27, 0x91, 0xe1, 0x2a, 0x0f, 0xf5, 0xc9, 0x25, 0x21, 0xc8, 0x5c, 0xe3, 0x81,
0x02, 0x3c, 0xa1, 0xbf, 0x99, 0x16, 0x69, 0x63, 0x68, 0xf3, 0xa1, 0xe9, 0x2e, 0xd4, 0xb9, 0xda,
0x28, 0x00, 0x06, 0x8a, 0xc1, 0xbe, 0xaf, 0x89, 0xa2, 0x79, 0x06, 0xb8, 0x64, 0x9f, 0x79, 0xbb,
0xe7, 0x34, 0x69, 0x73, 0x79, 0xc1, 0xac, 0x2f, 0x69, 0x64, 0x90, 0x7a, 0x02, 0x99, 0x4d, 0xe9,
0x7c, 0xab, 0x57, 0x7a, 0x3c, 0x38, 0x0a, 0xd0, 0x57, 0x74, 0x1e, 0x1e, 0x57, 0xdb, 0xe4, 0x8d,
0x44, 0x22, 0x08, 0xc3, 0x55, 0xbf, 0xb9, 0xeb, 0xd9, 0xdf, 0xc3, 0x98, 0x8a, 0x83, 0x62, 0x94,
0x95, 0x61, 0xa2, 0x3b, 0x71, 0x7e, 0x18, 0x5b, 0x92, 0x79, 0x69, 0xc8, 0x4b, 0xea, 0x25, 0x81,
0xb8, 0xfa, 0xcb, 0x42, 0x41, 0xea, 0xb8, 0xe8, 0xb3, 0xf2, 0x34, 0x96, 0x7b, 0xcf, 0x29, 0x15,
0xd4, 0x9f, 0xc1, 0x14, 0xb1, 0x57, 0x59, 0xa1, 0xb0, 0xaa, 0xd6, 0xaf, 0x74, 0xd7, 0xde, 0x34,
0xa5, 0x09, 0x43, 0x88, 0x72, 0x43, 0x6d, 0x13, 0xb3, 0xcb, 0xb9, 0xaf, 0x45, 0xb4, 0x7f, 0xe3,
0xe5, 0x7f, 0xb3, 0x14, 0x06, 0x39, 0xfe, 0x52, 0xdf, 0x6a, 0x0b, 0x40, 0x1a, 0xf4, 0x8e, 0xd2,
0x9b, 0xa6, 0x3d, 0x96, 0x4d, 0xce, 0x54, 0x0c, 0x65, 0x41, 0x8e, 0x56, 0x8f, 0xcb, 0x00, 0x8f,
0xba, 0xdb, 0x17, 0x1b, 0x94, 0xa1, 0xd8, 0x9e, 0xfb, 0x63, 0x8c, 0x01, 0xd4, 0x89, 0xf5, 0x81,
0x16, 0xfa, 0x43, 0xd6, 0xfe, 0x4c, 0x44, 0x3d, 0x16, 0x26, 0x4c, 0x58, 0x07, 0x9f, 0xcd, 0xb5,
0x35, 0xb3, 0xf9, 0xd4, 0xb3, 0x90, 0x43, 0x04, 0x74, 0x20, 0x2a, 0xfe, 0x62, 0xfa, 0x17, 0x97,
0xbe, 0x0a, 0xa3, 0xb7, 0x48, 0xe7, 0x67, 0x32, 0xaa, 0x9c, 0x64, 0x99, 0x8a, 0x1b, 0x07, 0x3a,
0x0e, 0x3c, 0x0f, 0x84, 0x5b, 0x01, 0x10, 0x85, 0x9e, 0x27, 0x09, 0xd4, 0xae, 0x91, 0xdb, 0x65,
0xcd, 0xdd, 0xe2, 0xf1, 0x08, 0x00, 0x3b, 0xe4, 0xe4, 0x2c, 0xf7, 0x5e, 0xfe, 0x45, 0x19, 0x9a,
0x69, 0x7c, 0x61, 0xdb, 0x29, 0xf8, 0x97, 0xd7, 0x49, 0x52, 0xde, 0x80, 0x2c, 0x5e, 0x55, 0x60,
0xc9, 0xbc, 0x9a, 0x56, 0x4d, 0x01, 0x6e, 0x4e, 0x36, 0x85, 0x4a, 0x11, 0x12, 0x5e, 0xb7, 0x7d,
0x96, 0x23, 0x89, 0x3c, 0x14, 0x14, 0x0f, 0xad, 0x40, 0x7f, 0x0c, 0x88, 0xb8, 0x07, 0xa2, 0x70,
0x2c, 0x69, 0xa9, 0xec, 0x87, 0x45, 0x99, 0x33, 0x06, 0xca, 0xad, 0xb4, 0x5c, 0x44, 0x1c, 0x37,
0x7b, 0xfb, 0x6a, 0x3b, 0x23, 0x74, 0x60, 0xc5, 0xa6, 0x69, 0x9c, 0x0c, 0x23, 0x95, 0x69, 0x27,
0x39, 0xb8, 0x29, 0x81, 0x55, 0x59, 0x53, 0xc2, 0xe9, 0xf3, 0x25, 0x63, 0xa0, 0x25, 0xc3, 0x79,
0x78, 0x62, 0x7f, 0x37, 0x0f, 0xe9, 0x8c, 0xec, 0xf1, 0x43, 0x4d, 0x40, 0x6c, 0x4f, 0xa1, 0xff,
0xe7, 0x1c, 0xb2, 0xe4, 0xde, 0x7b, 0x34, 0xb1, 0x4b, 0x16, 0x3d, 0x7f, 0xba, 0xac, 0x99, 0xd8,
0xa8, 0xa1, 0x7f, 0xf5, 0xfc, 0x08, 0x14, 0xb6, 0x5c, 0x62, 0x1a, 0x53, 0x7b, 0x76, 0x00, 0x32,
0xbe, 0xba, 0xbb, 0x50, 0xb9, 0xa2, 0x4c, 0xf2, 0x4a, 0x00, 0xc5, 0xc6, 0x7c, 0x91, 0xb9, 0xa6,
0x86, 0x72, 0x35, 0x2d, 0xe1, 0x7a, 0xb9, 0xd2, 0xd0, 0x62, 0x22, 0xf0, 0x87, 0xe4, 0xbc, 0x89,
0x3b, 0xb8, 0xac, 0xb2, 0x91, 0xa1, 0xdc, 0x4c, 0xdd, 0xab, 0x2b, 0xcd, 0x0e, 0x94, 0xb4, 0x17,
0x4b, 0x01, 0xcf, 0xec, 0x76, 0xe9, 0x2f, 0x0f, 0x56, 0xc4, 0x75, 0x76, 0x9d, 0xfe, 0x44, 0x5c,
0x63, 0x5d, 0x5d, 0xd9, 0x9a, 0x59, 0x6f, 0xba, 0xf4, 0x96, 0xa1, 0x47, 0xee, 0x94, 0xe9, 0xe6,
0x0a, 0x55, 0x00, 0x89, 0x8d, 0x2d, 0x69, 0x1b, 0x34, 0x4a, 0xd2, 0x3f, 0xa8, 0x3c, 0x9c, 0x1a,
0x66, 0x25, 0x68, 0x4b, 0xdc, 0x84, 0xe2, 0xe1, 0xc1, 0xbf, 0xc2, 0xe3, 0x5d, 0xc5, 0xd7, 0x34,
0x03, 0xd1, 0x8f, 0xf0, 0xae, 0x1b, 0x25, 0x13, 0x45, 0xc1, 0x64, 0x18, 0x55, 0x27, 0x2d, 0xac,
0xd3, 0x5d, 0x94, 0xab, 0x66, 0xb4, 0xef, 0x1c, 0xca, 0x95, 0x44, 0xb1, 0x95, 0xd2, 0x73, 0x66,
0x3e, 0x7c, 0xc7, 0x5f, 0x86, 0x0e, 0xb4, 0x81, 0x15, 0xa8, 0x0f, 0xba, 0x0c, 0x0e, 0xf1, 0x1b,
0xec, 0x3f, 0x2f, 0x08, 0x26, 0xef, 0x2b, 0x13, 0x96, 0x98, 0xec, 0x16, 0x88, 0xe8, 0x30, 0x49,
0xe8, 0xa7, 0x69, 0x3c, 0x10, 0x7d, 0x3c, 0x5c, 0x73, 0xd2, 0x9d, 0xf3, 0xd6, 0x3e, 0x8a, 0xcb,
0x05, 0xb0, 0x24, 0x3b, 0x99, 0xa7, 0x2b, 0x05, 0x96, 0x9a, 0x7d, 0x1e, 0xbd, 0x93, 0x0a, 0x2d,
0x79, 0xdf, 0x4f, 0xb3, 0x43, 0xf0, 0x44, 0x4f, 0xe0, 0xac, 0x78, 0x9c, 0x64, 0x85, 0x9b, 0x5e,
0x11, 0x0e, 0xea, 0x78, 0x59, 0xf1, 0xaf, 0x80, 0x10, 0xf4, 0xd9, 0x74, 0x0b, 0x18, 0x56, 0x58,
0xaa, 0xd7, 0xea, 0xc6, 0xd7, 0x8d, 0x72, 0x0b, 0x82, 0x44, 0x1e, 0x41, 0x9a, 0xbe, 0x41, 0x9b,
0xe4, 0x36, 0x27, 0x02, 0x5d, 0xd3, 0x00, 0x60, 0xaa, 0xa1, 0x16, 0x5c, 0xa7, 0x22, 0x2b, 0x2a,
0xcb, 0xe0, 0xed, 0xd2, 0xfb, 0xfd, 0x7a, 0x82, 0x21, 0xc0, 0x5d, 0xa6, 0x68, 0x5c, 0x81, 0xe0,
0xa4, 0xf8, 0xb5, 0x25, 0x7f, 0xfc, 0x72, 0x8a, 0x91, 0x1f, 0xad, 0x86, 0xcc, 0xa9, 0xe8, 0x67,
0x60, 0xfa, 0xdc, 0x07, 0x0e, 0x38, 0x4c, 0x6e, 0x6e, 0x2f, 0xad, 0xcc, 0x43, 0x92, 0x73, 0xe4,
0xa7, 0x05, 0x96, 0x43, 0x44, 0x30, 0x75, 0x8c, 0x18, 0xd0, 0x78, 0x04, 0xcb, 0x03, 0xf3, 0x2c,
0xce, 0x19, 0xc6, 0x15, 0xd1, 0x9c, 0x14, 0xd5, 0xf5, 0x3e, 0x57, 0x16, 0x15, 0xa8, 0xeb, 0xa7,
0xac, 0x18, 0x86, 0x41, 0x16, 0x55, 0x48, 0x3d, 0xa9, 0xb2, 0xdf, 0xc7, 0x6b, 0xef, 0xbf, 0x6c,
0xa1, 0x59, 0x59, 0x2c, 0xa7, 0x57, 0xad, 0x35, 0xe8, 0x75, 0x3e, 0xe3, 0x7b, 0xae, 0x48, 0xf4,
0x41, 0x1b, 0x84, 0xae, 0x7c, 0xeb, 0x85, 0x07, 0x2f, 0x65, 0xef, 0x55, 0x4d, 0x82, 0x9c, 0xef,
0xaa, 0xcc, 0x66, 0x6e, 0xc4, 0xdb, 0x15, 0xf7, 0x7b, 0x62, 0x42, 0x0b, 0x3a, 0x1d, 0xd3, 0x18,
0x12, 0xdb, 0x08, 0x50, 0xb2, 0x37, 0xd8, 0x2c, 0x55, 0x47, 0xb6, 0xf6, 0xc1, 0x3a, 0x9b, 0x59,
0x00, 0xe4, 0x25, 0x6e, 0x40, 0xdf, 0xb4, 0x38, 0x1f, 0x00, 0x17, 0x6c, 0x20, 0x59, 0x97, 0x46,
0xb9, 0xff, 0xea, 0x9e, 0x57, 0x34, 0x19, 0x54, 0xdd, 0x7f, 0xa0, 0x5f, 0x74, 0x72, 0x1b, 0xf2,
0xc1, 0x93, 0xed, 0x91, 0xa8, 0x15, 0x5e, 0x10, 0xfc, 0x24, 0xe1, 0xe6, 0x9b, 0xdb, 0x52, 0x2c,
0x44, 0x5c, 0xef, 0xdb, 0x6e, 0xc4, 0x50, 0x3f, 0x11, 0xd6, 0x7b, 0x36, 0xfc, 0x05, 0xb2, 0x55,
0x53, 0x2e, 0xb5, 0x43, 0x50, 0xd7, 0x56, 0x95, 0xc4, 0x5c, 0xe1, 0x26, 0xe3, 0x82, 0x63, 0x4f,
0xb3, 0x9e, 0x4c, 0x87, 0x3e, 0xab, 0x89, 0x33, 0x77, 0xab, 0xb9, 0xcf, 0xba, 0x1e, 0x7c, 0xc3,
0x41, 0x2f, 0xe2, 0x2b, 0x14, 0xd6, 0xd3, 0x55, 0x7f, 0x68, 0x37, 0x0c, 0x42, 0x2d, 0xbf, 0x9a,
0x51, 0x6c, 0xfe, 0x70, 0x45, 0xc2, 0x4f, 0x5d, 0xf4, 0x0a, 0x08, 0x2a, 0xd8, 0x89, 0xf1, 0x08,
0x2e, 0xbd, 0x70, 0x5b, 0xf5, 0x53, 0xf8, 0x5e, 0xc6, 0xec, 0x5c, 0x7b, 0xdc, 0x81, 0x16, 0xba,
0xc7, 0x52, 0x64, 0x7b, 0x0f, 0x2d, 0x41, 0x22, 0x60, 0x15, 0x58, 0x3d, 0xa0, 0x45, 0x16, 0x7d,
0xdd, 0xcc, 0xe5, 0x00, 0xc5, 0xd8, 0x0e, 0x9b, 0x88, 0x99, 0xde, 0xa4, 0xcd, 0x8b, 0x3c, 0xeb,
0x6c, 0x3f, 0x98, 0xec, 0xf9, 0x9a, 0x21, 0xb0, 0xd4, 0xd1, 0x42, 0x0c, 0xe0, 0x09, 0x79, 0x2a,
0x28, 0xf9, 0x2e, 0x25, 0x6e, 0xf4, 0x5d, 0xc5, 0xd5, 0xba, 0x0d, 0x94, 0xd5, 0x02, 0xfa, 0xa3,
0xab, 0xcf, 0xb6, 0xf5, 0xab, 0x1d, 0x32, 0xc3, 0x98, 0xc8, 0x54, 0x4c, 0xd1, 0xff, 0xfe, 0x4d,
0x5e, 0xc8, 0xeb, 0x18, 0x7e, 0xa7, 0x09, 0x54, 0xf5, 0x20, 0x39, 0x36, 0xee, 0x6c, 0x67, 0x9c,
0x88, 0x08, 0xf4, 0xdf, 0xae, 0x77, 0x4a, 0x14, 0x29, 0x5e, 0x13, 0xc4, 0x18, 0x55, 0x8e, 0xdf,
0x1b, 0x91, 0xb7, 0x6f, 0x43, 0x92, 0x00, 0x0d, 0xd0, 0xcf, 0xdb, 0x32, 0x70, 0xc0, 0xf3, 0x51,
0xea, 0xa8, 0xf8, 0xb9, 0x97, 0x16, 0x68, 0xa6, 0xf3, 0xc1, 0xbf, 0xdb, 0x59, 0x71, 0xb2, 0xb0,
0x94, 0xbc, 0x2f, 0xdf, 0xf9, 0xa3, 0x4d, 0x29, 0x04, 0xfe, 0xf6, 0xf0, 0x2f, 0x51, 0x58, 0xe9,
0xa2, 0x5b, 0x2a, 0xc0, 0xcf, 0x35, 0xba, 0x35, 0x5a, 0x4f, 0x66, 0x7f, 0x4d, 0xa5, 0x25, 0x75,
0x5d, 0xff, 0x53, 0x02, 0x8b, 0x0b, 0x4d, 0x50, 0x7a, 0x9e, 0xf2, 0x94, 0xb8, 0x61, 0x35, 0x87,
0xc5, 0x7f, 0x89, 0x4f, 0xeb, 0xc6, 0x2a, 0x48, 0x22, 0xe4, 0x2f, 0x78, 0x7e, 0xa0, 0x2d, 0x98,
0x21, 0x62, 0xd8, 0xf7, 0xbd, 0x2b, 0xde, 0x77, 0x07, 0xde, 0x55, 0xa2, 0xb2, 0xb9, 0x4a, 0x68,
0x5e, 0x4a, 0x0a, 0x0b, 0xc9, 0x49, 0x8e, 0xce, 0x57, 0x83, 0xb5, 0xca, 0xa0, 0x1c, 0x9b, 0xbb,
0x5f, 0x6a, 0xf1, 0x92, 0xac, 0x04, 0x8c, 0x1b, 0x46, 0x15, 0x99, 0x14, 0xe6, 0x06, 0xd1, 0x46,
0x77, 0x76, 0x3f, 0x2e, 0x37, 0x5b, 0x39, 0xdd, 0x3d, 0x96, 0x95, 0xd9, 0xe5, 0x8c, 0x03, 0x86,
0xc6, 0x02, 0x17, 0x95, 0x9a, 0x1c, 0x8c, 0x77, 0xe4, 0x47, 0xfe, 0xe3, 0x87, 0xe5, 0x28, 0xd5,
0xcf, 0x48, 0xce, 0x1c, 0x2f, 0xda, 0x23, 0x6c, 0xbc, 0xdf, 0xa7, 0x3f, 0x24, 0x82, 0x65, 0xb7,
0xe1, 0x49, 0x07, 0x0f, 0x67, 0x5d, 0x25, 0x05, 0x23, 0xb3, 0x5f, 0xe1, 0xf3, 0xb2, 0x5d, 0xf2,
0x22, 0x0b, 0xa3, 0x16, 0xc3, 0xdc, 0xa0, 0xa8, 0x29, 0xb3, 0xf2, 0xc6, 0xdc, 0x98, 0x98, 0xd0,
0x78, 0x83, 0xda, 0xea, 0x5e, 0x17, 0x37, 0x30, 0xcf, 0xb0, 0x5c, 0xec, 0xa1, 0xee, 0x70, 0xd5,
0x19, 0x0d, 0x86, 0x07, 0x2f, 0x4a, 0x97, 0x5e, 0xa2, 0xf4, 0x53, 0x4b, 0x38, 0x15, 0x53, 0x5b,
0xe5, 0xa1, 0x08, 0x43, 0xf8, 0x44, 0x04, 0x5e, 0xe4, 0xf7, 0x68, 0xcf, 0x85, 0xca, 0x25, 0x10,
0xed, 0xcc, 0xfa, 0x69, 0x1a, 0x39, 0x51, 0x1f, 0x92, 0xbd, 0xbe, 0xc7, 0x90, 0x1e, 0xb8, 0xde,
0x26, 0x2b, 0xc7, 0x5e, 0xb9, 0x2c, 0x36, 0x51, 0xe2, 0x6e, 0x1c, 0xe0, 0xd6, 0x4c, 0x0c, 0x11,
0x0d, 0x8f, 0x47, 0x6d, 0xb5, 0xc2, 0xb1, 0xfb, 0x0a, 0xef, 0xec, 0x0e, 0x2b, 0x00, 0xef, 0x1f,
0x0d, 0x5b, 0xd8, 0x6a, 0xba, 0xdb, 0x09, 0x3c, 0x6c, 0x50, 0x7a, 0x80, 0xda, 0xd1, 0xbc, 0x11,
0x91, 0xd6, 0x6c, 0xf5, 0x04, 0x9b, 0x0c, 0xbc, 0xc9, 0x15, 0x7e, 0x03, 0xbe, 0xe6, 0x6a, 0x31,
0x23, 0xef, 0x02, 0xfb, 0xb6, 0xc4, 0xfa, 0xf7, 0xe0, 0xf7, 0x29, 0x7f, 0x75, 0x71, 0x4d, 0x07,
0xea, 0x81, 0xea, 0x16, 0x70, 0xd6, 0xea, 0xb1, 0x6b, 0x44, 0x7d, 0xe8, 0xeb, 0x14, 0xfb, 0x7e,
0xd8, 0x68, 0xb4, 0x41, 0x60, 0x47, 0xa9, 0x93, 0xc5, 0x78, 0xc2, 0xc7, 0xb5, 0xcd, 0xe7, 0x6f,
0x11, 0x9c, 0x72, 0x6b, 0x99, 0x9f, 0xc0, 0x9c, 0x32, 0x01, 0x64, 0x1b, 0x7f, 0x0d, 0x00, 0xbf,
0x1d, 0xa1, 0x81, 0x51, 0x0f, 0x96, 0x2e, 0x02, 0x80, 0x26, 0xc1, 0x90, 0x70, 0x81, 0xfd, 0x20,
0x79, 0xd1, 0x61, 0x06, 0x0a, 0xab, 0x43, 0x02, 0xc1, 0x80, 0x0e, 0xbb, 0x1a, 0xb1, 0xfa, 0x98,
0x64, 0xcc, 0xbb, 0xe3, 0xf3, 0x58, 0x23, 0x7e, 0xfa, 0x91, 0x22, 0x5e, 0x61, 0x11, 0xe5, 0xff,
0xfa, 0xe5, 0x64, 0xa4
};
fastimage_t bfin_logo = {
DEF_BFIN_LOGO_DATA,
DEF_BFIN_LOGO_WIDTH,
DEF_BFIN_LOGO_HEIGHT,
DEF_BFIN_LOGO_BPP,
DEF_BFIN_LOGO_PIXEL_SIZE,
DEF_BFIN_LOGO_SIZE
};
| 95.502198 | 96 | 0.660321 |
ae9678d48d55648fbb0dc4d6787c22fbdd663222 | 5,770 | c | C | source/platform/KEIL/pdmc_example/RTE/Network/Net_Debug.c | armPelionEdge/workflows-with-secure-device-access-client | bf03d069032a15e3b0e3af6abd7496740f376ca1 | [
"Apache-2.0"
] | 25 | 2018-07-03T11:42:07.000Z | 2020-10-04T11:35:53.000Z | source/platform/KEIL/pdmc_example/RTE/Network/Net_Debug.c | armPelionEdge/workflows-with-secure-device-access-client | bf03d069032a15e3b0e3af6abd7496740f376ca1 | [
"Apache-2.0"
] | 43 | 2018-04-24T15:26:30.000Z | 2020-10-16T11:28:58.000Z | source/platform/KEIL/pdmc_example/RTE/Network/Net_Debug.c | armPelionEdge/workflows-with-secure-device-access-client | bf03d069032a15e3b0e3af6abd7496740f376ca1 | [
"Apache-2.0"
] | 112 | 2018-04-11T17:56:14.000Z | 2020-11-05T12:31:22.000Z | /*------------------------------------------------------------------------------
* MDK Middleware - Component ::Network
* Copyright (c) 2004-2019 Arm Limited (or its affiliates). All rights reserved.
*------------------------------------------------------------------------------
* Name: Net_Debug.c
* Purpose: Network Debug Configuration
* Rev.: V7.1.0
*----------------------------------------------------------------------------*/
//-------- <<< Use Configuration Wizard in Context Menu >>> --------------------
// <q>Print Time Stamps
// <i>Enable printing time stamps in debug messages
#define DBG_TIME 1
// <e>System Debug
// <i>Enable printing system debug messages
#define DBG_SYSTEM_EN 1
// <o>Memory Management <0=>Off <1=>Errors only <2=>Full debug
// <i>Configure Dynamic Memory Management debugging
#define DBG_MEM 2
// <o>ETH Interface <0=>Off <1=>Errors only <2=>Full debug
// <i>Configure Ethernet Interface debugging
#define DBG_ETH 1
// <o>WiFi Interface <0=>Off <1=>Errors only <2=>Full debug
// <i>Configure WiFi Interface debugging
#define DBG_WIFI 2
// <o>PPP Interface <0=>Off <1=>Errors only <2=>Full debug
// <i>Configure Serial PPP Interface debugging
#define DBG_PPP 0
// <o>SLIP Interface <0=>Off <1=>Errors only <2=>Full debug
// <i>Configure Serial SLIP Interface debugging
#define DBG_SLIP 0
// <o>Loopback Interface <0=>Off <1=>Errors only <2=>Full debug
// <i>Configure Local Loopback Interface debugging
#define DBG_LOOP 1
// </e>
// <e>IPv4 Core Debug
// <i>Enable printing IPv4 debug messages
#define DBG_CORE4_EN 0
// <o>IP4 Core <0=>Off <1=>Errors only <2=>Full debug
// <i>Configure IPv4 Core/localhost debugging
#define DBG_IP4 1
// <o>ICMP Control <0=>Off <1=>Errors only <2=>Full debug
// <i>Configure Internet Control Message debugging
#define DBG_ICMP 1
// <o>IGMP Management <0=>Off <1=>Errors only <2=>Full debug
// <i>Configure debugging of Multicast Group Management
#define DBG_IGMP 1
// <o>NBNS Client <0=>Off <1=>Errors only <2=>Full debug
// <i>Configure NetBIOS Name Service Client debugging
#define DBG_NBNS 1
// <o>DHCP Client <0=>Off <1=>Errors only <2=>Full debug
// <i>Configure Dynamic Host Configuration Client debugging
#define DBG_DHCP 1
// <o>ARP Address Resolution <0=>Off <1=>Errors only <2=>Full debug
// <i>Configure Ethernet Address Resolution debugging
#define DBG_ARP 1
// </e>
// <e>IPv6 Core Debug
// <i>Enable printing IPv6 debug messages
#define DBG_CORE6_EN 0
// <o>IP6 Core <0=>Off <1=>Errors only <2=>Full debug
// <i>Configure IPv6 Core/localhost debugging
#define DBG_IP6 1
// <o>ICMP6 Control <0=>Off <1=>Errors only <2=>Full debug
// <i>Configure Internet Control Message ver.6 debugging
#define DBG_ICMP6 1
// <o>DHCP6 Client <0=>Off <1=>Errors only <2=>Full debug
// <i>Configure Dynamic Host Configuration ver.6 Client debugging
#define DBG_DHCP6 1
// <o>NDP Neighbor Discovery <0=>Off <1=>Errors only <2=>Full debug
// <i>Configure Neighbor Discovery in IPv6 debugging
#define DBG_NDP6 1
// </e>
// <e>Socket Debug
// <i>Enable printing socket debug messages
#define DBG_SOCKET_EN 0
// <o>UDP Socket <0=>Off <1=>Errors only <2=>Full debug
// <i>Configure native UDP Socket debugging
#define DBG_UDP_SOCKET 1
// <o>TCP Socket <0=>Off <1=>Errors only <2=>Full debug
// <i>Configure native TCP Socket debugging
#define DBG_TCP_SOCKET 1
// <o>BSD Socket <0=>Off <1=>Errors only <2=>Full debug
// <i>Configure BSD Socket Interface debugging
#define DBG_BSD_SOCKET 1
// </e>
// <e>Service Debug
// <i>Enable printing service debug messages
#define DBG_SERVICE_EN 0
// <o>HTTP Server <0=>Off <1=>Errors only <2=>Full debug
// <i>Configure Web Server debugging
#define DBG_HTTP_SERVER 1
// <o>FTP Server <0=>Off <1=>Errors only <2=>Full debug
// <i>Configure FTP Server debugging
#define DBG_FTP_SERVER 1
// <o>FTP Client <0=>Off <1=>Errors only <2=>Full debug
// <i>Configure FTP Client debugging
#define DBG_FTP_CLIENT 1
// <o>Telnet Server <0=>Off <1=>Errors only <2=>Full debug
// <i>Configure Telnet Server debugging
#define DBG_TELNET_SERVER 1
// <o>TFTP Server <0=>Off <1=>Errors only <2=>Full debug
// <i>Configure TFTP Server debugging
#define DBG_TFTP_SERVER 1
// <o>TFTP Client <0=>Off <1=>Errors only <2=>Full debug
// <i>Configure TFTP Client debugging
#define DBG_TFTP_CLIENT 1
// <o>SMTP Client <0=>Off <1=>Errors only <2=>Full debug
// <i>Configure SMTP Client debugging
#define DBG_SMTP_CLIENT 1
// <o>DNS Client <0=>Off <1=>Errors only <2=>Full debug
// <i>Configure Domain Name Service Client debugging
#define DBG_DNS_CLIENT 1
// <o>SNMP Agent <0=>Off <1=>Errors only <2=>Full debug
// <i>Configure Simple Network Management debugging
#define DBG_SNMP_AGENT 1
// <o>SNTP Client <0=>Off <1=>Errors only <2=>Full debug
// <i>Configure Simple Network Time debugging
#define DBG_SNTP_CLIENT 1
// </e>
//------------- <<< end of configuration section >>> ---------------------------
#include "net_debug.h"
/**
\fn void net_debug_init (void)
\brief Initialize Network Debug Interface.
*/
void net_debug_init (void) {
/* Add your code to initialize the debug output device. */
/* This is usually the serial interface or ITM channel. */
}
| 33.546512 | 80 | 0.603466 |
ae96f6ef16dbb0b2516c7fae7de7925f983529a7 | 2,708 | h | C | inc/dev_spi_slave.h | dimtass/stm32f1-dimtass-lib | 443141be4cd5f075dded66b6490fb6844e15e5a1 | [
"MIT"
] | 1 | 2021-09-05T05:16:26.000Z | 2021-09-05T05:16:26.000Z | inc/dev_spi_slave.h | dimtass/stm32f1-dimtass-lib | 443141be4cd5f075dded66b6490fb6844e15e5a1 | [
"MIT"
] | null | null | null | inc/dev_spi_slave.h | dimtass/stm32f1-dimtass-lib | 443141be4cd5f075dded66b6490fb6844e15e5a1 | [
"MIT"
] | null | null | null | /**
* dev_spi.h
*
* Copyright 2018 Dimitris Tassopoulos <dimtass@gmail.com>
*
* 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.
*
* usage:
* // Create a callback
* void spi_callback(struct spi_device * dev);
* // Create a buffers
* DECLARE_SPI_BUFFER(spi_buffer,uint16_t,1);
* // Create an spi spi_device
* struct spi_device spi_slave;
*
* // Then in main()
* spi_set_options(&spi_slave, 16, SPI_MODE_0);
* spi_init_slave(DEV_SPI2, &spi_buffer, &spi_callback, &spi_slave);
*
* // Example of a callback function:
* void spi_callback(struct spi_device * dev)
* {
* struct spi_buffers * buffers = (struct spi_buffers *) dev->data;
* // uint16_t * rx_buffer = (uint16_t*) buffers->rx_buffer;
* uint16_t * tx_buffer = (uint16_t*) buffers->tx_buffer;
* return;
* }
*/
#ifndef DEV_SPI_SLAVE_H_
#define DEV_SPI_SLAVE_H_
#ifdef __cplusplus
extern "C" {
#endif
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include "dev_spi_common.h"
#define DECLARE_SPI_SLAVE_CHANNEL(NAME, OWNER, CHANNEL) \
struct spi_slave_device NAME = { \
.channel = CHANNEL, \
}
#define DECLARE_SPI_BUFFER(NAME,TYPE,BUFFER_SIZE) \
TYPE NAME##_rx_buffer[BUFFER_SIZE]; \
TYPE NAME##_tx_buffer[BUFFER_SIZE]; \
struct spi_buffers NAME = { \
.rx_buffer = NAME##_rx_buffer, \
.rx_buffer_len = BUFFER_SIZE, \
.tx_buffer = NAME##_tx_buffer, \
.tx_buffer_len = BUFFER_SIZE, \
}
void spi_init_slave(enum en_spi_port port,
struct spi_buffers * buffers,
receive_irq_t callback,
struct spi_device * spi);
#ifdef __cplusplus
}
#endif
#endif //DEV_SPI_SLAVE_H_ | 32.238095 | 86 | 0.705687 |
ae980a094631b74f3f265aa00d3248b68f0d4f61 | 2,055 | h | C | id_theft/functions/node_modules/grpc/ext/server.h | jluisfgarza/Id-Theft-Hack2018 | 101ef7d6d251ee1a4cd1716fb4f8f0edc31f53bf | [
"MIT"
] | null | null | null | id_theft/functions/node_modules/grpc/ext/server.h | jluisfgarza/Id-Theft-Hack2018 | 101ef7d6d251ee1a4cd1716fb4f8f0edc31f53bf | [
"MIT"
] | null | null | null | id_theft/functions/node_modules/grpc/ext/server.h | jluisfgarza/Id-Theft-Hack2018 | 101ef7d6d251ee1a4cd1716fb4f8f0edc31f53bf | [
"MIT"
] | null | null | null | /*
*
* Copyright 2015 gRPC authors.
*
* 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 NET_GRPC_NODE_SERVER_H_
#define NET_GRPC_NODE_SERVER_H_
#include <nan.h>
#include <node.h>
#include "grpc/grpc.h"
namespace grpc {
namespace node {
/* Wraps grpc_server as a JavaScript object. Provides a constructor
and wrapper methods for grpc_server_create, grpc_server_request_call,
grpc_server_add_http2_port, and grpc_server_start. */
class Server : public Nan::ObjectWrap {
public:
/* Initializes the Server class and exposes the constructor and
wrapper methods to JavaScript */
static void Init(v8::Local<v8::Object> exports);
/* Tests whether the given value was constructed by this class's
JavaScript constructor */
static bool HasInstance(v8::Local<v8::Value> val);
void FinishShutdown();
private:
explicit Server(grpc_server *server);
~Server();
// Prevent copying
Server(const Server &);
Server &operator=(const Server &);
void ShutdownServer();
static NAN_METHOD(New);
static NAN_METHOD(RequestCall);
static NAN_METHOD(AddHttp2Port);
static NAN_METHOD(Start);
static NAN_METHOD(TryShutdown);
static NAN_METHOD(ForceShutdown);
static Nan::Callback *constructor;
static Nan::Persistent<v8::FunctionTemplate> fun_tpl;
Nan::Persistent<v8::Value> running_self_ref;
grpc_server *wrapped_server;
bool is_shutdown;
};
} // namespace node
} // namespace grpc
#endif // NET_GRPC_NODE_SERVER_H_
| 28.943662 | 76 | 0.717762 |
ae9b9fd6735567dded73361c8f10a255266d5609 | 2,527 | h | C | geopackage-ios/db/GPKGTableCreator.h | bosborn/geopackage-ios | ee0c65c4aefd1a023c4b0760578b560108f3677b | [
"MIT"
] | 45 | 2015-10-19T20:38:03.000Z | 2022-03-10T04:59:19.000Z | geopackage-ios/db/GPKGTableCreator.h | bosborn/geopackage-ios | ee0c65c4aefd1a023c4b0760578b560108f3677b | [
"MIT"
] | 24 | 2015-11-03T19:22:14.000Z | 2022-03-31T10:58:52.000Z | geopackage-ios/db/GPKGTableCreator.h | bosborn/geopackage-ios | ee0c65c4aefd1a023c4b0760578b560108f3677b | [
"MIT"
] | 24 | 2015-10-20T01:52:39.000Z | 2022-03-11T18:54:07.000Z | //
// GPKGTableCreator.h
// geopackage-ios
//
// Created by Brian Osborn on 5/20/15.
// Copyright (c) 2015 NGA. All rights reserved.
//
#import <Foundation/Foundation.h>
#import "GPKGConnection.h"
#import "GPKGUserTable.h"
extern NSString * const GPKG_RESOURCES_TABLES;
/**
* Executes database scripts to create tables
*/
@interface GPKGTableCreator : NSObject
/**
* Database connection
*/
@property (nonatomic) GPKGConnection *db;
/**
* Initialize
*
* @param db database connection
*
* @return new table creator
*/
-(instancetype) initWithDatabase: (GPKGConnection *) db;
/**
* Get the table creator properties name
*
* @return properties name or nil for base
*/
-(NSString *) properties;
/**
* Create the table
*
* @param tableName table name
*
* @return SQL statements executed
*/
-(int) createTable: (NSString *) tableName;
/**
* Create the table
*
* @param tableName table name
* @param properties properties name
*
* @return SQL statements executed
*/
-(int) createTable: (NSString *) tableName fromProperties: (NSString *) properties;
/**
* Execute the SQL statement for the property name
*
* @param propertyName property name
*
* @return SQL statements executed
*/
-(int) execSQLForProperty: (NSString *) propertyName;
/**
* Execute the SQL statement for the property name
*
* @param propertyName property name
* @param properties properties name
*
* @return SQL statements executed
*/
-(int) execSQLForProperty: (NSString *) propertyName fromProperties: (NSString *) properties;
/**
* Execute the SQL statements
*
* @param statements SQL statements
*/
-(void) execSQLStatements: (NSArray *) statements;
/**
* Read the SQL statements for the property name
*
* @param propertyName
* property name
* @return statements
*/
+(NSArray<NSString *> *) readProperty: (NSString *) propertyName;
/**
* Read the SQL statements for the property name from the properties
*
* @param propertyName
* property name
* @param properties
* properties name
* @return statements
*/
+(NSArray<NSString *> *) readProperty: (NSString *) propertyName fromProperties: (NSString *) properties;
/**
* Read the SQL statements for the property name from the properties file
*
* @param propertyName
* property name
* @param propertiesFile
* properties file
* @return statements
*/
+(NSArray<NSString *> *) readProperty: (NSString *) propertyName fromFile: (NSString *) propertiesFile;
@end
| 21.415254 | 105 | 0.685398 |
ae9bbebe06f5c9a2ec0f03463f9307df67b76117 | 2,891 | c | C | src/math/numbers.c | PayalKshirsagar/sof | 9da1fce2478df1f5b4993228410ecadae35c22bd | [
"BSD-3-Clause"
] | 1 | 2021-01-27T11:39:15.000Z | 2021-01-27T11:39:15.000Z | src/math/numbers.c | PayalKshirsagar/sof | 9da1fce2478df1f5b4993228410ecadae35c22bd | [
"BSD-3-Clause"
] | 2 | 2020-04-14T00:17:41.000Z | 2020-07-31T19:20:31.000Z | src/math/numbers.c | sebcarlucci/sof | 247af133b807dcb9240dbab8f384594ffc0c8f3f | [
"BSD-3-Clause"
] | 1 | 2021-08-02T02:30:27.000Z | 2021-08-02T02:30:27.000Z | // SPDX-License-Identifier: BSD-3-Clause
//
// Copyright(c) 2016 Intel Corporation. All rights reserved.
//
// Author: Seppo Ingalsuo <seppo.ingalsuo@linux.intel.com>
// Liam Girdwood <liam.r.girdwood@linux.intel.com>
// Keyon Jie <yang.jie@linux.intel.com>
/* Euclidean algorithm for greatest common denominator from
* pseudocode in
* https://en.wikipedia.org/wiki/Euclidean_algorithm#Implementations
*/
#include <sof/audio/format.h>
#include <sof/math/numbers.h>
#include <stdint.h>
int gcd(int a, int b)
{
int t;
while (b != 0) {
t = b;
b = a % b;
a = t;
}
return a;
}
/* This function searches from vec[] (of length vec_length) integer values
* of n. The indexes to equal values is returned in idx[]. The function
* returns the number of found matches. The max_results should be set to
* 0 (or negative) or vec_length get all the matches. The max_result can be set
* to 1 to receive only the first match in ascending order. It avoids need
* for an array for idx.
*/
int find_equal_int16(int16_t idx[], int16_t vec[], int n, int vec_length,
int max_results)
{
int nresults = 0;
int i;
for (i = 0; i < vec_length; i++) {
if (vec[i] == n) {
idx[nresults++] = i;
if (nresults == max_results)
break;
}
}
return nresults;
}
/* Return the smallest value found in the vector */
int16_t find_min_int16(int16_t vec[], int vec_length)
{
int i;
int min = vec[0];
for (i = 1; i < vec_length; i++)
min = (vec[i] < min) ? vec[i] : min;
return min;
}
/* Return the largest absolute value found in the vector. Note that
* smallest negative value need to be saturated to preset as int32_t.
*/
int32_t find_max_abs_int32(int32_t vec[], int vec_length)
{
int i;
int64_t amax = (vec[0] > 0) ? vec[0] : -vec[0];
for (i = 1; i < vec_length; i++) {
amax = (vec[i] > amax) ? vec[i] : amax;
amax = (-vec[i] > amax) ? -vec[i] : amax;
}
return SATP_INT32(amax); /* Amax is always a positive value */
}
/* Count the left shift amount to normalize a 32 bit signed integer value
* without causing overflow. Input value 0 will result to 31.
*/
int norm_int32(int32_t val)
{
int s;
int32_t n;
if (!val)
return 31;
if (val > 0) {
n = val << 1;
s = 0;
while (n > 0) {
n = n << 1;
s++;
}
} else {
n = val << 1;
s = 0;
while (n < 0) {
n = n << 1;
s++;
}
}
return s;
}
/**
* Basic CRC-32 implementation, based on pseudo-code from
* https://en.wikipedia.org/wiki/Cyclic_redundancy_check#CRC-32_algorithm
* 0xEDB88320 is the reversed polynomial representation
*/
uint32_t crc32(uint32_t base, const void *data, uint32_t bytes)
{
uint32_t crc = ~base;
uint32_t cur;
int i;
int j;
for (i = 0; i < bytes; ++i) {
cur = (crc ^ ((const uint8_t *)data)[i]) & 0xFF;
for (j = 0; j < 8; ++j)
cur = cur & 1 ? (cur >> 1) ^ 0xEDB88320 : cur >> 1;
crc = cur ^ (crc >> 8);
}
return ~crc;
}
| 21.574627 | 79 | 0.632307 |
ae9e96b8fc41e9b725a5d6fc5c28730b0211c6a8 | 2,757 | h | C | flang/include/flang/Optimizer/Support/TypeCode.h | yuriykoch/llvm | c4ce4f0feb46ec7dd4235fa2709609be06fb2153 | [
"Apache-2.0"
] | 605 | 2019-10-18T01:15:54.000Z | 2022-03-31T14:31:04.000Z | flang/include/flang/Optimizer/Support/TypeCode.h | yuriykoch/llvm | c4ce4f0feb46ec7dd4235fa2709609be06fb2153 | [
"Apache-2.0"
] | 3,180 | 2019-10-18T01:21:21.000Z | 2022-03-31T23:25:41.000Z | flang/include/flang/Optimizer/Support/TypeCode.h | yuriykoch/llvm | c4ce4f0feb46ec7dd4235fa2709609be06fb2153 | [
"Apache-2.0"
] | 275 | 2019-10-18T05:27:22.000Z | 2022-03-30T09:04:21.000Z | //===-- Optimizer/Support/TypeCode.h ----------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
//
//===----------------------------------------------------------------------===//
#ifndef FORTRAN_OPTIMIZER_SUPPORT_TYPECODE_H
#define FORTRAN_OPTIMIZER_SUPPORT_TYPECODE_H
#include "flang/ISO_Fortran_binding.h"
#include "llvm/Support/ErrorHandling.h"
namespace fir {
//===----------------------------------------------------------------------===//
// Translations of category and bitwidths to the type codes defined in flang's
// ISO_Fortran_binding.h.
//===----------------------------------------------------------------------===//
inline int characterBitsToTypeCode(unsigned bitwidth) {
// clang-format off
switch (bitwidth) {
case 8: return CFI_type_char;
case 16: return CFI_type_char16_t;
case 32: return CFI_type_char32_t;
default: llvm_unreachable("unsupported character size");
}
// clang-format on
}
inline int complexBitsToTypeCode(unsigned bitwidth) {
// clang-format off
switch (bitwidth) {
case 32: return CFI_type_float_Complex;
case 64: return CFI_type_double_Complex;
case 80:
case 128: return CFI_type_long_double_Complex;
default: llvm_unreachable("unsupported complex size");
}
// clang-format on
}
inline int integerBitsToTypeCode(unsigned bitwidth) {
// clang-format off
switch (bitwidth) {
case 8: return CFI_type_int8_t;
case 16: return CFI_type_int16_t;
case 32: return CFI_type_int32_t;
case 64: return CFI_type_int64_t;
case 128: return CFI_type_int128_t;
default: llvm_unreachable("unsupported integer size");
}
// clang-format on
}
inline int logicalBitsToTypeCode(unsigned bitwidth) {
// clang-format off
switch (bitwidth) {
case 8: return CFI_type_Bool;
case 16: return CFI_type_int_least16_t;
case 32: return CFI_type_int_least32_t;
case 64: return CFI_type_int_least64_t;
default: llvm_unreachable("unsupported logical size");
}
// clang-format on
}
inline int realBitsToTypeCode(unsigned bitwidth) {
// clang-format off
switch (bitwidth) {
case 32: return CFI_type_float;
case 64: return CFI_type_double;
case 80:
case 128: return CFI_type_long_double;
default: llvm_unreachable("unsupported real size");
}
// clang-format on
}
static constexpr int derivedToTypeCode() { return CFI_type_struct; }
} // namespace fir
#endif // FORTRAN_OPTIMIZER_SUPPORT_TYPECODE_H
| 30.296703 | 80 | 0.653609 |
ae9edfa13f6bb677faed92ff21f4b060aef49e4b | 279 | h | C | include/adc.h | andreasbehnke/lego-ir-sender | 3ea3ef175f4edf668bbb86c89887789969c04375 | [
"Apache-2.0"
] | null | null | null | include/adc.h | andreasbehnke/lego-ir-sender | 3ea3ef175f4edf668bbb86c89887789969c04375 | [
"Apache-2.0"
] | null | null | null | include/adc.h | andreasbehnke/lego-ir-sender | 3ea3ef175f4edf668bbb86c89887789969c04375 | [
"Apache-2.0"
] | null | null | null | /*
* adc.h
*
* Created on: 13.02.2016
* Author: andreasbehnke
*/
#ifndef INCLUDE_ADC_H_
#define INCLUDE_ADC_H_
#include <stdint.h>
#define CHANNEL_DIRECTION 0b00000001
extern void adc_init();
extern uint8_t adc_read(uint8_t channel);
#endif /* INCLUDE_ADC_H_ */
| 13.95 | 41 | 0.713262 |
aea18552da6bfadbcd37d945c4502c62359fbd97 | 2,007 | h | C | include/dxc/DXIL/DxilResourceBinding.h | seanbaxter/DirectXShaderCompiler | 6d02c8d43ff3fdeb9963acaf3af00c62aaa01f44 | [
"NCSA"
] | null | null | null | include/dxc/DXIL/DxilResourceBinding.h | seanbaxter/DirectXShaderCompiler | 6d02c8d43ff3fdeb9963acaf3af00c62aaa01f44 | [
"NCSA"
] | null | null | null | include/dxc/DXIL/DxilResourceBinding.h | seanbaxter/DirectXShaderCompiler | 6d02c8d43ff3fdeb9963acaf3af00c62aaa01f44 | [
"NCSA"
] | null | null | null | ///////////////////////////////////////////////////////////////////////////////
// //
// DxilResourceBinding.h //
// Copyright (C) Microsoft Corporation. All rights reserved. //
// This file is distributed under the University of Illinois Open Source //
// License. See LICENSE.TXT for details. //
// //
// Representation properties for DXIL resource binding. //
// //
///////////////////////////////////////////////////////////////////////////////
#pragma once
#include "DxilConstants.h"
namespace llvm37 {
class Constant;
class Type;
}
namespace hlsl {
struct DxilResourceBinding {
uint32_t rangeLowerBound;
uint32_t rangeUpperBound;
uint32_t spaceID;
uint8_t resourceClass;
uint8_t Reserved1;
uint8_t Reserved2;
uint8_t Reserved3;
bool operator==(const DxilResourceBinding &);
bool operator!=(const DxilResourceBinding &);
};
static_assert(sizeof(DxilResourceBinding) == 4 * sizeof(uint32_t),
"update shader model and functions read/write "
"DxilResourceBinding when size is changed");
class ShaderModel;
class DxilResourceBase;
struct DxilInst_CreateHandleFromBinding;
namespace resource_helper {
llvm37::Constant *getAsConstant(const DxilResourceBinding &, llvm37::Type *Ty,
const ShaderModel &);
DxilResourceBinding loadBindingFromConstant(const llvm37::Constant &C);
DxilResourceBinding
loadBindingFromCreateHandleFromBinding(const DxilInst_CreateHandleFromBinding &createHandle, llvm37::Type *Ty,
const ShaderModel &);
DxilResourceBinding loadBindingFromResourceBase(DxilResourceBase *);
} // namespace resource_helper
} // namespace hlsl
| 36.490909 | 110 | 0.552566 |
aea2960f973f0901a812cbf6514d0587dc941707 | 702 | h | C | src/ConvexTriangleMeshShape.h | yoshinoToylogic/bulletsharp | 79558f9e78b68f1d218d64234645848661a54e01 | [
"MIT"
] | null | null | null | src/ConvexTriangleMeshShape.h | yoshinoToylogic/bulletsharp | 79558f9e78b68f1d218d64234645848661a54e01 | [
"MIT"
] | null | null | null | src/ConvexTriangleMeshShape.h | yoshinoToylogic/bulletsharp | 79558f9e78b68f1d218d64234645848661a54e01 | [
"MIT"
] | null | null | null | #pragma once
#include "PolyhedralConvexShape.h"
namespace BulletSharp
{
ref class StridingMeshInterface;
public ref class ConvexTriangleMeshShape : PolyhedralConvexAabbCachingShape
{
private:
StridingMeshInterface^ _meshInterface;
internal:
ConvexTriangleMeshShape(btConvexTriangleMeshShape* native);
public:
ConvexTriangleMeshShape(StridingMeshInterface^ meshInterface, bool calcAabb);
ConvexTriangleMeshShape(StridingMeshInterface^ meshInterface);
void CalculatePrincipalAxisTransform(Matrix% principal, [Out] Vector3% inertia, [Out] btScalar% volume);
property StridingMeshInterface^ MeshInterface
{
StridingMeshInterface^ get();
}
};
};
| 24.206897 | 107 | 0.773504 |
aea2968d4b1a84d4f7895156fff60f331e7497e2 | 113,009 | h | C | third_party/include/protobuf/google/protobuf/util/internal/testdata/field_mask.pb.h | phiysng/bufferblink | 747e499824ad268c50ab2b45b5034d28439af22b | [
"BSD-3-Clause"
] | null | null | null | third_party/include/protobuf/google/protobuf/util/internal/testdata/field_mask.pb.h | phiysng/bufferblink | 747e499824ad268c50ab2b45b5034d28439af22b | [
"BSD-3-Clause"
] | null | null | null | third_party/include/protobuf/google/protobuf/util/internal/testdata/field_mask.pb.h | phiysng/bufferblink | 747e499824ad268c50ab2b45b5034d28439af22b | [
"BSD-3-Clause"
] | null | null | null | // Generated by the protocol buffer compiler. DO NOT EDIT!
// source: google/protobuf/util/internal/testdata/field_mask.proto
#ifndef GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2futil_2finternal_2ftestdata_2ffield_5fmask_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2futil_2finternal_2ftestdata_2ffield_5fmask_2eproto
#include <limits>
#include <string>
#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3019000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3019003 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif
#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h> // IWYU pragma: export
#include <google/protobuf/extension_set.h> // IWYU pragma: export
#include <google/protobuf/unknown_field_set.h>
#include <google/protobuf/field_mask.pb.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_google_2fprotobuf_2futil_2finternal_2ftestdata_2ffield_5fmask_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
} // namespace internal
PROTOBUF_NAMESPACE_CLOSE
// Internal implementation detail -- do not use these members.
struct TableStruct_google_2fprotobuf_2futil_2finternal_2ftestdata_2ffield_5fmask_2eproto {
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[4]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2futil_2finternal_2ftestdata_2ffield_5fmask_2eproto;
namespace proto_util_converter {
namespace testing {
class FieldMaskTest;
struct FieldMaskTestDefaultTypeInternal;
extern FieldMaskTestDefaultTypeInternal _FieldMaskTest_default_instance_;
class FieldMaskTestCases;
struct FieldMaskTestCasesDefaultTypeInternal;
extern FieldMaskTestCasesDefaultTypeInternal _FieldMaskTestCases_default_instance_;
class FieldMaskWrapper;
struct FieldMaskWrapperDefaultTypeInternal;
extern FieldMaskWrapperDefaultTypeInternal _FieldMaskWrapper_default_instance_;
class NestedFieldMask;
struct NestedFieldMaskDefaultTypeInternal;
extern NestedFieldMaskDefaultTypeInternal _NestedFieldMask_default_instance_;
} // namespace testing
} // namespace proto_util_converter
PROTOBUF_NAMESPACE_OPEN
template<> ::proto_util_converter::testing::FieldMaskTest* Arena::CreateMaybeMessage<::proto_util_converter::testing::FieldMaskTest>(Arena*);
template<> ::proto_util_converter::testing::FieldMaskTestCases* Arena::CreateMaybeMessage<::proto_util_converter::testing::FieldMaskTestCases>(Arena*);
template<> ::proto_util_converter::testing::FieldMaskWrapper* Arena::CreateMaybeMessage<::proto_util_converter::testing::FieldMaskWrapper>(Arena*);
template<> ::proto_util_converter::testing::NestedFieldMask* Arena::CreateMaybeMessage<::proto_util_converter::testing::NestedFieldMask>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace proto_util_converter {
namespace testing {
// ===================================================================
class NestedFieldMask final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto_util_converter.testing.NestedFieldMask) */ {
public:
inline NestedFieldMask() : NestedFieldMask(nullptr) {}
~NestedFieldMask() override;
explicit constexpr NestedFieldMask(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
NestedFieldMask(const NestedFieldMask& from);
NestedFieldMask(NestedFieldMask&& from) noexcept
: NestedFieldMask() {
*this = ::std::move(from);
}
inline NestedFieldMask& operator=(const NestedFieldMask& from) {
CopyFrom(from);
return *this;
}
inline NestedFieldMask& operator=(NestedFieldMask&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const NestedFieldMask& default_instance() {
return *internal_default_instance();
}
static inline const NestedFieldMask* internal_default_instance() {
return reinterpret_cast<const NestedFieldMask*>(
&_NestedFieldMask_default_instance_);
}
static constexpr int kIndexInFileMessages =
0;
friend void swap(NestedFieldMask& a, NestedFieldMask& b) {
a.Swap(&b);
}
inline void Swap(NestedFieldMask* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(NestedFieldMask* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
NestedFieldMask* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<NestedFieldMask>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const NestedFieldMask& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const NestedFieldMask& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(NestedFieldMask* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "proto_util_converter.testing.NestedFieldMask";
}
protected:
explicit NestedFieldMask(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kRepeatedMaskFieldNumber = 3,
kDataFieldNumber = 1,
kSingleMaskFieldNumber = 2,
};
// repeated .google.protobuf.FieldMask repeated_mask = 3;
int repeated_mask_size() const;
private:
int _internal_repeated_mask_size() const;
public:
void clear_repeated_mask();
::PROTOBUF_NAMESPACE_ID::FieldMask* mutable_repeated_mask(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FieldMask >*
mutable_repeated_mask();
private:
const ::PROTOBUF_NAMESPACE_ID::FieldMask& _internal_repeated_mask(int index) const;
::PROTOBUF_NAMESPACE_ID::FieldMask* _internal_add_repeated_mask();
public:
const ::PROTOBUF_NAMESPACE_ID::FieldMask& repeated_mask(int index) const;
::PROTOBUF_NAMESPACE_ID::FieldMask* add_repeated_mask();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FieldMask >&
repeated_mask() const;
// string data = 1;
void clear_data();
const std::string& data() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_data(ArgT0&& arg0, ArgT... args);
std::string* mutable_data();
PROTOBUF_NODISCARD std::string* release_data();
void set_allocated_data(std::string* data);
private:
const std::string& _internal_data() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_data(const std::string& value);
std::string* _internal_mutable_data();
public:
// .google.protobuf.FieldMask single_mask = 2;
bool has_single_mask() const;
private:
bool _internal_has_single_mask() const;
public:
void clear_single_mask();
const ::PROTOBUF_NAMESPACE_ID::FieldMask& single_mask() const;
PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::FieldMask* release_single_mask();
::PROTOBUF_NAMESPACE_ID::FieldMask* mutable_single_mask();
void set_allocated_single_mask(::PROTOBUF_NAMESPACE_ID::FieldMask* single_mask);
private:
const ::PROTOBUF_NAMESPACE_ID::FieldMask& _internal_single_mask() const;
::PROTOBUF_NAMESPACE_ID::FieldMask* _internal_mutable_single_mask();
public:
void unsafe_arena_set_allocated_single_mask(
::PROTOBUF_NAMESPACE_ID::FieldMask* single_mask);
::PROTOBUF_NAMESPACE_ID::FieldMask* unsafe_arena_release_single_mask();
// @@protoc_insertion_point(class_scope:proto_util_converter.testing.NestedFieldMask)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FieldMask > repeated_mask_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
::PROTOBUF_NAMESPACE_ID::FieldMask* single_mask_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_google_2fprotobuf_2futil_2finternal_2ftestdata_2ffield_5fmask_2eproto;
};
// -------------------------------------------------------------------
class FieldMaskTest final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto_util_converter.testing.FieldMaskTest) */ {
public:
inline FieldMaskTest() : FieldMaskTest(nullptr) {}
~FieldMaskTest() override;
explicit constexpr FieldMaskTest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
FieldMaskTest(const FieldMaskTest& from);
FieldMaskTest(FieldMaskTest&& from) noexcept
: FieldMaskTest() {
*this = ::std::move(from);
}
inline FieldMaskTest& operator=(const FieldMaskTest& from) {
CopyFrom(from);
return *this;
}
inline FieldMaskTest& operator=(FieldMaskTest&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const FieldMaskTest& default_instance() {
return *internal_default_instance();
}
static inline const FieldMaskTest* internal_default_instance() {
return reinterpret_cast<const FieldMaskTest*>(
&_FieldMaskTest_default_instance_);
}
static constexpr int kIndexInFileMessages =
1;
friend void swap(FieldMaskTest& a, FieldMaskTest& b) {
a.Swap(&b);
}
inline void Swap(FieldMaskTest* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(FieldMaskTest* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
FieldMaskTest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<FieldMaskTest>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const FieldMaskTest& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const FieldMaskTest& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(FieldMaskTest* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "proto_util_converter.testing.FieldMaskTest";
}
protected:
explicit FieldMaskTest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kRepeatedMaskFieldNumber = 3,
kNestedMaskFieldNumber = 4,
kIdFieldNumber = 1,
kSingleMaskFieldNumber = 2,
};
// repeated .google.protobuf.FieldMask repeated_mask = 3;
int repeated_mask_size() const;
private:
int _internal_repeated_mask_size() const;
public:
void clear_repeated_mask();
::PROTOBUF_NAMESPACE_ID::FieldMask* mutable_repeated_mask(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FieldMask >*
mutable_repeated_mask();
private:
const ::PROTOBUF_NAMESPACE_ID::FieldMask& _internal_repeated_mask(int index) const;
::PROTOBUF_NAMESPACE_ID::FieldMask* _internal_add_repeated_mask();
public:
const ::PROTOBUF_NAMESPACE_ID::FieldMask& repeated_mask(int index) const;
::PROTOBUF_NAMESPACE_ID::FieldMask* add_repeated_mask();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FieldMask >&
repeated_mask() const;
// repeated .proto_util_converter.testing.NestedFieldMask nested_mask = 4;
int nested_mask_size() const;
private:
int _internal_nested_mask_size() const;
public:
void clear_nested_mask();
::proto_util_converter::testing::NestedFieldMask* mutable_nested_mask(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto_util_converter::testing::NestedFieldMask >*
mutable_nested_mask();
private:
const ::proto_util_converter::testing::NestedFieldMask& _internal_nested_mask(int index) const;
::proto_util_converter::testing::NestedFieldMask* _internal_add_nested_mask();
public:
const ::proto_util_converter::testing::NestedFieldMask& nested_mask(int index) const;
::proto_util_converter::testing::NestedFieldMask* add_nested_mask();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto_util_converter::testing::NestedFieldMask >&
nested_mask() const;
// string id = 1;
void clear_id();
const std::string& id() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_id(ArgT0&& arg0, ArgT... args);
std::string* mutable_id();
PROTOBUF_NODISCARD std::string* release_id();
void set_allocated_id(std::string* id);
private:
const std::string& _internal_id() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value);
std::string* _internal_mutable_id();
public:
// .google.protobuf.FieldMask single_mask = 2;
bool has_single_mask() const;
private:
bool _internal_has_single_mask() const;
public:
void clear_single_mask();
const ::PROTOBUF_NAMESPACE_ID::FieldMask& single_mask() const;
PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::FieldMask* release_single_mask();
::PROTOBUF_NAMESPACE_ID::FieldMask* mutable_single_mask();
void set_allocated_single_mask(::PROTOBUF_NAMESPACE_ID::FieldMask* single_mask);
private:
const ::PROTOBUF_NAMESPACE_ID::FieldMask& _internal_single_mask() const;
::PROTOBUF_NAMESPACE_ID::FieldMask* _internal_mutable_single_mask();
public:
void unsafe_arena_set_allocated_single_mask(
::PROTOBUF_NAMESPACE_ID::FieldMask* single_mask);
::PROTOBUF_NAMESPACE_ID::FieldMask* unsafe_arena_release_single_mask();
// @@protoc_insertion_point(class_scope:proto_util_converter.testing.FieldMaskTest)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FieldMask > repeated_mask_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto_util_converter::testing::NestedFieldMask > nested_mask_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_;
::PROTOBUF_NAMESPACE_ID::FieldMask* single_mask_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_google_2fprotobuf_2futil_2finternal_2ftestdata_2ffield_5fmask_2eproto;
};
// -------------------------------------------------------------------
class FieldMaskTestCases final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto_util_converter.testing.FieldMaskTestCases) */ {
public:
inline FieldMaskTestCases() : FieldMaskTestCases(nullptr) {}
~FieldMaskTestCases() override;
explicit constexpr FieldMaskTestCases(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
FieldMaskTestCases(const FieldMaskTestCases& from);
FieldMaskTestCases(FieldMaskTestCases&& from) noexcept
: FieldMaskTestCases() {
*this = ::std::move(from);
}
inline FieldMaskTestCases& operator=(const FieldMaskTestCases& from) {
CopyFrom(from);
return *this;
}
inline FieldMaskTestCases& operator=(FieldMaskTestCases&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const FieldMaskTestCases& default_instance() {
return *internal_default_instance();
}
static inline const FieldMaskTestCases* internal_default_instance() {
return reinterpret_cast<const FieldMaskTestCases*>(
&_FieldMaskTestCases_default_instance_);
}
static constexpr int kIndexInFileMessages =
2;
friend void swap(FieldMaskTestCases& a, FieldMaskTestCases& b) {
a.Swap(&b);
}
inline void Swap(FieldMaskTestCases* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(FieldMaskTestCases* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
FieldMaskTestCases* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<FieldMaskTestCases>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const FieldMaskTestCases& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const FieldMaskTestCases& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(FieldMaskTestCases* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "proto_util_converter.testing.FieldMaskTestCases";
}
protected:
explicit FieldMaskTestCases(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kSingleMaskFieldNumber = 1,
kMultipleMaskFieldNumber = 2,
kSnakeCamelFieldNumber = 3,
kEmptyFieldFieldNumber = 4,
kApiaryFormat1FieldNumber = 5,
kApiaryFormat2FieldNumber = 6,
kApiaryFormat3FieldNumber = 7,
kMapKey1FieldNumber = 8,
kMapKey2FieldNumber = 9,
kMapKey3FieldNumber = 10,
kMapKey4FieldNumber = 11,
kMapKey5FieldNumber = 12,
};
// .proto_util_converter.testing.FieldMaskWrapper single_mask = 1;
bool has_single_mask() const;
private:
bool _internal_has_single_mask() const;
public:
void clear_single_mask();
const ::proto_util_converter::testing::FieldMaskWrapper& single_mask() const;
PROTOBUF_NODISCARD ::proto_util_converter::testing::FieldMaskWrapper* release_single_mask();
::proto_util_converter::testing::FieldMaskWrapper* mutable_single_mask();
void set_allocated_single_mask(::proto_util_converter::testing::FieldMaskWrapper* single_mask);
private:
const ::proto_util_converter::testing::FieldMaskWrapper& _internal_single_mask() const;
::proto_util_converter::testing::FieldMaskWrapper* _internal_mutable_single_mask();
public:
void unsafe_arena_set_allocated_single_mask(
::proto_util_converter::testing::FieldMaskWrapper* single_mask);
::proto_util_converter::testing::FieldMaskWrapper* unsafe_arena_release_single_mask();
// .proto_util_converter.testing.FieldMaskWrapper multiple_mask = 2;
bool has_multiple_mask() const;
private:
bool _internal_has_multiple_mask() const;
public:
void clear_multiple_mask();
const ::proto_util_converter::testing::FieldMaskWrapper& multiple_mask() const;
PROTOBUF_NODISCARD ::proto_util_converter::testing::FieldMaskWrapper* release_multiple_mask();
::proto_util_converter::testing::FieldMaskWrapper* mutable_multiple_mask();
void set_allocated_multiple_mask(::proto_util_converter::testing::FieldMaskWrapper* multiple_mask);
private:
const ::proto_util_converter::testing::FieldMaskWrapper& _internal_multiple_mask() const;
::proto_util_converter::testing::FieldMaskWrapper* _internal_mutable_multiple_mask();
public:
void unsafe_arena_set_allocated_multiple_mask(
::proto_util_converter::testing::FieldMaskWrapper* multiple_mask);
::proto_util_converter::testing::FieldMaskWrapper* unsafe_arena_release_multiple_mask();
// .proto_util_converter.testing.FieldMaskWrapper snake_camel = 3;
bool has_snake_camel() const;
private:
bool _internal_has_snake_camel() const;
public:
void clear_snake_camel();
const ::proto_util_converter::testing::FieldMaskWrapper& snake_camel() const;
PROTOBUF_NODISCARD ::proto_util_converter::testing::FieldMaskWrapper* release_snake_camel();
::proto_util_converter::testing::FieldMaskWrapper* mutable_snake_camel();
void set_allocated_snake_camel(::proto_util_converter::testing::FieldMaskWrapper* snake_camel);
private:
const ::proto_util_converter::testing::FieldMaskWrapper& _internal_snake_camel() const;
::proto_util_converter::testing::FieldMaskWrapper* _internal_mutable_snake_camel();
public:
void unsafe_arena_set_allocated_snake_camel(
::proto_util_converter::testing::FieldMaskWrapper* snake_camel);
::proto_util_converter::testing::FieldMaskWrapper* unsafe_arena_release_snake_camel();
// .proto_util_converter.testing.FieldMaskWrapper empty_field = 4;
bool has_empty_field() const;
private:
bool _internal_has_empty_field() const;
public:
void clear_empty_field();
const ::proto_util_converter::testing::FieldMaskWrapper& empty_field() const;
PROTOBUF_NODISCARD ::proto_util_converter::testing::FieldMaskWrapper* release_empty_field();
::proto_util_converter::testing::FieldMaskWrapper* mutable_empty_field();
void set_allocated_empty_field(::proto_util_converter::testing::FieldMaskWrapper* empty_field);
private:
const ::proto_util_converter::testing::FieldMaskWrapper& _internal_empty_field() const;
::proto_util_converter::testing::FieldMaskWrapper* _internal_mutable_empty_field();
public:
void unsafe_arena_set_allocated_empty_field(
::proto_util_converter::testing::FieldMaskWrapper* empty_field);
::proto_util_converter::testing::FieldMaskWrapper* unsafe_arena_release_empty_field();
// .proto_util_converter.testing.FieldMaskWrapper apiary_format1 = 5;
bool has_apiary_format1() const;
private:
bool _internal_has_apiary_format1() const;
public:
void clear_apiary_format1();
const ::proto_util_converter::testing::FieldMaskWrapper& apiary_format1() const;
PROTOBUF_NODISCARD ::proto_util_converter::testing::FieldMaskWrapper* release_apiary_format1();
::proto_util_converter::testing::FieldMaskWrapper* mutable_apiary_format1();
void set_allocated_apiary_format1(::proto_util_converter::testing::FieldMaskWrapper* apiary_format1);
private:
const ::proto_util_converter::testing::FieldMaskWrapper& _internal_apiary_format1() const;
::proto_util_converter::testing::FieldMaskWrapper* _internal_mutable_apiary_format1();
public:
void unsafe_arena_set_allocated_apiary_format1(
::proto_util_converter::testing::FieldMaskWrapper* apiary_format1);
::proto_util_converter::testing::FieldMaskWrapper* unsafe_arena_release_apiary_format1();
// .proto_util_converter.testing.FieldMaskWrapper apiary_format2 = 6;
bool has_apiary_format2() const;
private:
bool _internal_has_apiary_format2() const;
public:
void clear_apiary_format2();
const ::proto_util_converter::testing::FieldMaskWrapper& apiary_format2() const;
PROTOBUF_NODISCARD ::proto_util_converter::testing::FieldMaskWrapper* release_apiary_format2();
::proto_util_converter::testing::FieldMaskWrapper* mutable_apiary_format2();
void set_allocated_apiary_format2(::proto_util_converter::testing::FieldMaskWrapper* apiary_format2);
private:
const ::proto_util_converter::testing::FieldMaskWrapper& _internal_apiary_format2() const;
::proto_util_converter::testing::FieldMaskWrapper* _internal_mutable_apiary_format2();
public:
void unsafe_arena_set_allocated_apiary_format2(
::proto_util_converter::testing::FieldMaskWrapper* apiary_format2);
::proto_util_converter::testing::FieldMaskWrapper* unsafe_arena_release_apiary_format2();
// .proto_util_converter.testing.FieldMaskWrapper apiary_format3 = 7;
bool has_apiary_format3() const;
private:
bool _internal_has_apiary_format3() const;
public:
void clear_apiary_format3();
const ::proto_util_converter::testing::FieldMaskWrapper& apiary_format3() const;
PROTOBUF_NODISCARD ::proto_util_converter::testing::FieldMaskWrapper* release_apiary_format3();
::proto_util_converter::testing::FieldMaskWrapper* mutable_apiary_format3();
void set_allocated_apiary_format3(::proto_util_converter::testing::FieldMaskWrapper* apiary_format3);
private:
const ::proto_util_converter::testing::FieldMaskWrapper& _internal_apiary_format3() const;
::proto_util_converter::testing::FieldMaskWrapper* _internal_mutable_apiary_format3();
public:
void unsafe_arena_set_allocated_apiary_format3(
::proto_util_converter::testing::FieldMaskWrapper* apiary_format3);
::proto_util_converter::testing::FieldMaskWrapper* unsafe_arena_release_apiary_format3();
// .proto_util_converter.testing.FieldMaskWrapper map_key1 = 8;
bool has_map_key1() const;
private:
bool _internal_has_map_key1() const;
public:
void clear_map_key1();
const ::proto_util_converter::testing::FieldMaskWrapper& map_key1() const;
PROTOBUF_NODISCARD ::proto_util_converter::testing::FieldMaskWrapper* release_map_key1();
::proto_util_converter::testing::FieldMaskWrapper* mutable_map_key1();
void set_allocated_map_key1(::proto_util_converter::testing::FieldMaskWrapper* map_key1);
private:
const ::proto_util_converter::testing::FieldMaskWrapper& _internal_map_key1() const;
::proto_util_converter::testing::FieldMaskWrapper* _internal_mutable_map_key1();
public:
void unsafe_arena_set_allocated_map_key1(
::proto_util_converter::testing::FieldMaskWrapper* map_key1);
::proto_util_converter::testing::FieldMaskWrapper* unsafe_arena_release_map_key1();
// .proto_util_converter.testing.FieldMaskWrapper map_key2 = 9;
bool has_map_key2() const;
private:
bool _internal_has_map_key2() const;
public:
void clear_map_key2();
const ::proto_util_converter::testing::FieldMaskWrapper& map_key2() const;
PROTOBUF_NODISCARD ::proto_util_converter::testing::FieldMaskWrapper* release_map_key2();
::proto_util_converter::testing::FieldMaskWrapper* mutable_map_key2();
void set_allocated_map_key2(::proto_util_converter::testing::FieldMaskWrapper* map_key2);
private:
const ::proto_util_converter::testing::FieldMaskWrapper& _internal_map_key2() const;
::proto_util_converter::testing::FieldMaskWrapper* _internal_mutable_map_key2();
public:
void unsafe_arena_set_allocated_map_key2(
::proto_util_converter::testing::FieldMaskWrapper* map_key2);
::proto_util_converter::testing::FieldMaskWrapper* unsafe_arena_release_map_key2();
// .proto_util_converter.testing.FieldMaskWrapper map_key3 = 10;
bool has_map_key3() const;
private:
bool _internal_has_map_key3() const;
public:
void clear_map_key3();
const ::proto_util_converter::testing::FieldMaskWrapper& map_key3() const;
PROTOBUF_NODISCARD ::proto_util_converter::testing::FieldMaskWrapper* release_map_key3();
::proto_util_converter::testing::FieldMaskWrapper* mutable_map_key3();
void set_allocated_map_key3(::proto_util_converter::testing::FieldMaskWrapper* map_key3);
private:
const ::proto_util_converter::testing::FieldMaskWrapper& _internal_map_key3() const;
::proto_util_converter::testing::FieldMaskWrapper* _internal_mutable_map_key3();
public:
void unsafe_arena_set_allocated_map_key3(
::proto_util_converter::testing::FieldMaskWrapper* map_key3);
::proto_util_converter::testing::FieldMaskWrapper* unsafe_arena_release_map_key3();
// .proto_util_converter.testing.FieldMaskWrapper map_key4 = 11;
bool has_map_key4() const;
private:
bool _internal_has_map_key4() const;
public:
void clear_map_key4();
const ::proto_util_converter::testing::FieldMaskWrapper& map_key4() const;
PROTOBUF_NODISCARD ::proto_util_converter::testing::FieldMaskWrapper* release_map_key4();
::proto_util_converter::testing::FieldMaskWrapper* mutable_map_key4();
void set_allocated_map_key4(::proto_util_converter::testing::FieldMaskWrapper* map_key4);
private:
const ::proto_util_converter::testing::FieldMaskWrapper& _internal_map_key4() const;
::proto_util_converter::testing::FieldMaskWrapper* _internal_mutable_map_key4();
public:
void unsafe_arena_set_allocated_map_key4(
::proto_util_converter::testing::FieldMaskWrapper* map_key4);
::proto_util_converter::testing::FieldMaskWrapper* unsafe_arena_release_map_key4();
// .proto_util_converter.testing.FieldMaskWrapper map_key5 = 12;
bool has_map_key5() const;
private:
bool _internal_has_map_key5() const;
public:
void clear_map_key5();
const ::proto_util_converter::testing::FieldMaskWrapper& map_key5() const;
PROTOBUF_NODISCARD ::proto_util_converter::testing::FieldMaskWrapper* release_map_key5();
::proto_util_converter::testing::FieldMaskWrapper* mutable_map_key5();
void set_allocated_map_key5(::proto_util_converter::testing::FieldMaskWrapper* map_key5);
private:
const ::proto_util_converter::testing::FieldMaskWrapper& _internal_map_key5() const;
::proto_util_converter::testing::FieldMaskWrapper* _internal_mutable_map_key5();
public:
void unsafe_arena_set_allocated_map_key5(
::proto_util_converter::testing::FieldMaskWrapper* map_key5);
::proto_util_converter::testing::FieldMaskWrapper* unsafe_arena_release_map_key5();
// @@protoc_insertion_point(class_scope:proto_util_converter.testing.FieldMaskTestCases)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::proto_util_converter::testing::FieldMaskWrapper* single_mask_;
::proto_util_converter::testing::FieldMaskWrapper* multiple_mask_;
::proto_util_converter::testing::FieldMaskWrapper* snake_camel_;
::proto_util_converter::testing::FieldMaskWrapper* empty_field_;
::proto_util_converter::testing::FieldMaskWrapper* apiary_format1_;
::proto_util_converter::testing::FieldMaskWrapper* apiary_format2_;
::proto_util_converter::testing::FieldMaskWrapper* apiary_format3_;
::proto_util_converter::testing::FieldMaskWrapper* map_key1_;
::proto_util_converter::testing::FieldMaskWrapper* map_key2_;
::proto_util_converter::testing::FieldMaskWrapper* map_key3_;
::proto_util_converter::testing::FieldMaskWrapper* map_key4_;
::proto_util_converter::testing::FieldMaskWrapper* map_key5_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_google_2fprotobuf_2futil_2finternal_2ftestdata_2ffield_5fmask_2eproto;
};
// -------------------------------------------------------------------
class FieldMaskWrapper final :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto_util_converter.testing.FieldMaskWrapper) */ {
public:
inline FieldMaskWrapper() : FieldMaskWrapper(nullptr) {}
~FieldMaskWrapper() override;
explicit constexpr FieldMaskWrapper(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
FieldMaskWrapper(const FieldMaskWrapper& from);
FieldMaskWrapper(FieldMaskWrapper&& from) noexcept
: FieldMaskWrapper() {
*this = ::std::move(from);
}
inline FieldMaskWrapper& operator=(const FieldMaskWrapper& from) {
CopyFrom(from);
return *this;
}
inline FieldMaskWrapper& operator=(FieldMaskWrapper&& from) noexcept {
if (this == &from) return *this;
if (GetOwningArena() == from.GetOwningArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
&& GetOwningArena() != nullptr
#endif // !PROTOBUF_FORCE_COPY_IN_MOVE
) {
InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return default_instance().GetMetadata().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return default_instance().GetMetadata().reflection;
}
static const FieldMaskWrapper& default_instance() {
return *internal_default_instance();
}
static inline const FieldMaskWrapper* internal_default_instance() {
return reinterpret_cast<const FieldMaskWrapper*>(
&_FieldMaskWrapper_default_instance_);
}
static constexpr int kIndexInFileMessages =
3;
friend void swap(FieldMaskWrapper& a, FieldMaskWrapper& b) {
a.Swap(&b);
}
inline void Swap(FieldMaskWrapper* other) {
if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() != nullptr &&
GetOwningArena() == other->GetOwningArena()) {
#else // PROTOBUF_FORCE_COPY_IN_SWAP
if (GetOwningArena() == other->GetOwningArena()) {
#endif // !PROTOBUF_FORCE_COPY_IN_SWAP
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(FieldMaskWrapper* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
FieldMaskWrapper* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<FieldMaskWrapper>(arena);
}
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
void CopyFrom(const FieldMaskWrapper& from);
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
void MergeFrom(const FieldMaskWrapper& from);
private:
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
public:
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
uint8_t* _InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(FieldMaskWrapper* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "proto_util_converter.testing.FieldMaskWrapper";
}
protected:
explicit FieldMaskWrapper(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
static const ClassData _class_data_;
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kMaskFieldNumber = 1,
};
// .google.protobuf.FieldMask mask = 1;
bool has_mask() const;
private:
bool _internal_has_mask() const;
public:
void clear_mask();
const ::PROTOBUF_NAMESPACE_ID::FieldMask& mask() const;
PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::FieldMask* release_mask();
::PROTOBUF_NAMESPACE_ID::FieldMask* mutable_mask();
void set_allocated_mask(::PROTOBUF_NAMESPACE_ID::FieldMask* mask);
private:
const ::PROTOBUF_NAMESPACE_ID::FieldMask& _internal_mask() const;
::PROTOBUF_NAMESPACE_ID::FieldMask* _internal_mutable_mask();
public:
void unsafe_arena_set_allocated_mask(
::PROTOBUF_NAMESPACE_ID::FieldMask* mask);
::PROTOBUF_NAMESPACE_ID::FieldMask* unsafe_arena_release_mask();
// @@protoc_insertion_point(class_scope:proto_util_converter.testing.FieldMaskWrapper)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::FieldMask* mask_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_google_2fprotobuf_2futil_2finternal_2ftestdata_2ffield_5fmask_2eproto;
};
// ===================================================================
// ===================================================================
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif // __GNUC__
// NestedFieldMask
// string data = 1;
inline void NestedFieldMask::clear_data() {
data_.ClearToEmpty();
}
inline const std::string& NestedFieldMask::data() const {
// @@protoc_insertion_point(field_get:proto_util_converter.testing.NestedFieldMask.data)
return _internal_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void NestedFieldMask::set_data(ArgT0&& arg0, ArgT... args) {
data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:proto_util_converter.testing.NestedFieldMask.data)
}
inline std::string* NestedFieldMask::mutable_data() {
std::string* _s = _internal_mutable_data();
// @@protoc_insertion_point(field_mutable:proto_util_converter.testing.NestedFieldMask.data)
return _s;
}
inline const std::string& NestedFieldMask::_internal_data() const {
return data_.Get();
}
inline void NestedFieldMask::_internal_set_data(const std::string& value) {
data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* NestedFieldMask::_internal_mutable_data() {
return data_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* NestedFieldMask::release_data() {
// @@protoc_insertion_point(field_release:proto_util_converter.testing.NestedFieldMask.data)
return data_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void NestedFieldMask::set_allocated_data(std::string* data) {
if (data != nullptr) {
} else {
}
data_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), data,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (data_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:proto_util_converter.testing.NestedFieldMask.data)
}
// .google.protobuf.FieldMask single_mask = 2;
inline bool NestedFieldMask::_internal_has_single_mask() const {
return this != internal_default_instance() && single_mask_ != nullptr;
}
inline bool NestedFieldMask::has_single_mask() const {
return _internal_has_single_mask();
}
inline const ::PROTOBUF_NAMESPACE_ID::FieldMask& NestedFieldMask::_internal_single_mask() const {
const ::PROTOBUF_NAMESPACE_ID::FieldMask* p = single_mask_;
return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::FieldMask&>(
::PROTOBUF_NAMESPACE_ID::_FieldMask_default_instance_);
}
inline const ::PROTOBUF_NAMESPACE_ID::FieldMask& NestedFieldMask::single_mask() const {
// @@protoc_insertion_point(field_get:proto_util_converter.testing.NestedFieldMask.single_mask)
return _internal_single_mask();
}
inline void NestedFieldMask::unsafe_arena_set_allocated_single_mask(
::PROTOBUF_NAMESPACE_ID::FieldMask* single_mask) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(single_mask_);
}
single_mask_ = single_mask;
if (single_mask) {
} else {
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto_util_converter.testing.NestedFieldMask.single_mask)
}
inline ::PROTOBUF_NAMESPACE_ID::FieldMask* NestedFieldMask::release_single_mask() {
::PROTOBUF_NAMESPACE_ID::FieldMask* temp = single_mask_;
single_mask_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::FieldMask* NestedFieldMask::unsafe_arena_release_single_mask() {
// @@protoc_insertion_point(field_release:proto_util_converter.testing.NestedFieldMask.single_mask)
::PROTOBUF_NAMESPACE_ID::FieldMask* temp = single_mask_;
single_mask_ = nullptr;
return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::FieldMask* NestedFieldMask::_internal_mutable_single_mask() {
if (single_mask_ == nullptr) {
auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::FieldMask>(GetArenaForAllocation());
single_mask_ = p;
}
return single_mask_;
}
inline ::PROTOBUF_NAMESPACE_ID::FieldMask* NestedFieldMask::mutable_single_mask() {
::PROTOBUF_NAMESPACE_ID::FieldMask* _msg = _internal_mutable_single_mask();
// @@protoc_insertion_point(field_mutable:proto_util_converter.testing.NestedFieldMask.single_mask)
return _msg;
}
inline void NestedFieldMask::set_allocated_single_mask(::PROTOBUF_NAMESPACE_ID::FieldMask* single_mask) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(single_mask_);
}
if (single_mask) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(single_mask));
if (message_arena != submessage_arena) {
single_mask = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, single_mask, submessage_arena);
}
} else {
}
single_mask_ = single_mask;
// @@protoc_insertion_point(field_set_allocated:proto_util_converter.testing.NestedFieldMask.single_mask)
}
// repeated .google.protobuf.FieldMask repeated_mask = 3;
inline int NestedFieldMask::_internal_repeated_mask_size() const {
return repeated_mask_.size();
}
inline int NestedFieldMask::repeated_mask_size() const {
return _internal_repeated_mask_size();
}
inline ::PROTOBUF_NAMESPACE_ID::FieldMask* NestedFieldMask::mutable_repeated_mask(int index) {
// @@protoc_insertion_point(field_mutable:proto_util_converter.testing.NestedFieldMask.repeated_mask)
return repeated_mask_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FieldMask >*
NestedFieldMask::mutable_repeated_mask() {
// @@protoc_insertion_point(field_mutable_list:proto_util_converter.testing.NestedFieldMask.repeated_mask)
return &repeated_mask_;
}
inline const ::PROTOBUF_NAMESPACE_ID::FieldMask& NestedFieldMask::_internal_repeated_mask(int index) const {
return repeated_mask_.Get(index);
}
inline const ::PROTOBUF_NAMESPACE_ID::FieldMask& NestedFieldMask::repeated_mask(int index) const {
// @@protoc_insertion_point(field_get:proto_util_converter.testing.NestedFieldMask.repeated_mask)
return _internal_repeated_mask(index);
}
inline ::PROTOBUF_NAMESPACE_ID::FieldMask* NestedFieldMask::_internal_add_repeated_mask() {
return repeated_mask_.Add();
}
inline ::PROTOBUF_NAMESPACE_ID::FieldMask* NestedFieldMask::add_repeated_mask() {
::PROTOBUF_NAMESPACE_ID::FieldMask* _add = _internal_add_repeated_mask();
// @@protoc_insertion_point(field_add:proto_util_converter.testing.NestedFieldMask.repeated_mask)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FieldMask >&
NestedFieldMask::repeated_mask() const {
// @@protoc_insertion_point(field_list:proto_util_converter.testing.NestedFieldMask.repeated_mask)
return repeated_mask_;
}
// -------------------------------------------------------------------
// FieldMaskTest
// string id = 1;
inline void FieldMaskTest::clear_id() {
id_.ClearToEmpty();
}
inline const std::string& FieldMaskTest::id() const {
// @@protoc_insertion_point(field_get:proto_util_converter.testing.FieldMaskTest.id)
return _internal_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void FieldMaskTest::set_id(ArgT0&& arg0, ArgT... args) {
id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:proto_util_converter.testing.FieldMaskTest.id)
}
inline std::string* FieldMaskTest::mutable_id() {
std::string* _s = _internal_mutable_id();
// @@protoc_insertion_point(field_mutable:proto_util_converter.testing.FieldMaskTest.id)
return _s;
}
inline const std::string& FieldMaskTest::_internal_id() const {
return id_.Get();
}
inline void FieldMaskTest::_internal_set_id(const std::string& value) {
id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* FieldMaskTest::_internal_mutable_id() {
return id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* FieldMaskTest::release_id() {
// @@protoc_insertion_point(field_release:proto_util_converter.testing.FieldMaskTest.id)
return id_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void FieldMaskTest::set_allocated_id(std::string* id) {
if (id != nullptr) {
} else {
}
id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), id,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:proto_util_converter.testing.FieldMaskTest.id)
}
// .google.protobuf.FieldMask single_mask = 2;
inline bool FieldMaskTest::_internal_has_single_mask() const {
return this != internal_default_instance() && single_mask_ != nullptr;
}
inline bool FieldMaskTest::has_single_mask() const {
return _internal_has_single_mask();
}
inline const ::PROTOBUF_NAMESPACE_ID::FieldMask& FieldMaskTest::_internal_single_mask() const {
const ::PROTOBUF_NAMESPACE_ID::FieldMask* p = single_mask_;
return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::FieldMask&>(
::PROTOBUF_NAMESPACE_ID::_FieldMask_default_instance_);
}
inline const ::PROTOBUF_NAMESPACE_ID::FieldMask& FieldMaskTest::single_mask() const {
// @@protoc_insertion_point(field_get:proto_util_converter.testing.FieldMaskTest.single_mask)
return _internal_single_mask();
}
inline void FieldMaskTest::unsafe_arena_set_allocated_single_mask(
::PROTOBUF_NAMESPACE_ID::FieldMask* single_mask) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(single_mask_);
}
single_mask_ = single_mask;
if (single_mask) {
} else {
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto_util_converter.testing.FieldMaskTest.single_mask)
}
inline ::PROTOBUF_NAMESPACE_ID::FieldMask* FieldMaskTest::release_single_mask() {
::PROTOBUF_NAMESPACE_ID::FieldMask* temp = single_mask_;
single_mask_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::FieldMask* FieldMaskTest::unsafe_arena_release_single_mask() {
// @@protoc_insertion_point(field_release:proto_util_converter.testing.FieldMaskTest.single_mask)
::PROTOBUF_NAMESPACE_ID::FieldMask* temp = single_mask_;
single_mask_ = nullptr;
return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::FieldMask* FieldMaskTest::_internal_mutable_single_mask() {
if (single_mask_ == nullptr) {
auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::FieldMask>(GetArenaForAllocation());
single_mask_ = p;
}
return single_mask_;
}
inline ::PROTOBUF_NAMESPACE_ID::FieldMask* FieldMaskTest::mutable_single_mask() {
::PROTOBUF_NAMESPACE_ID::FieldMask* _msg = _internal_mutable_single_mask();
// @@protoc_insertion_point(field_mutable:proto_util_converter.testing.FieldMaskTest.single_mask)
return _msg;
}
inline void FieldMaskTest::set_allocated_single_mask(::PROTOBUF_NAMESPACE_ID::FieldMask* single_mask) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(single_mask_);
}
if (single_mask) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(single_mask));
if (message_arena != submessage_arena) {
single_mask = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, single_mask, submessage_arena);
}
} else {
}
single_mask_ = single_mask;
// @@protoc_insertion_point(field_set_allocated:proto_util_converter.testing.FieldMaskTest.single_mask)
}
// repeated .google.protobuf.FieldMask repeated_mask = 3;
inline int FieldMaskTest::_internal_repeated_mask_size() const {
return repeated_mask_.size();
}
inline int FieldMaskTest::repeated_mask_size() const {
return _internal_repeated_mask_size();
}
inline ::PROTOBUF_NAMESPACE_ID::FieldMask* FieldMaskTest::mutable_repeated_mask(int index) {
// @@protoc_insertion_point(field_mutable:proto_util_converter.testing.FieldMaskTest.repeated_mask)
return repeated_mask_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FieldMask >*
FieldMaskTest::mutable_repeated_mask() {
// @@protoc_insertion_point(field_mutable_list:proto_util_converter.testing.FieldMaskTest.repeated_mask)
return &repeated_mask_;
}
inline const ::PROTOBUF_NAMESPACE_ID::FieldMask& FieldMaskTest::_internal_repeated_mask(int index) const {
return repeated_mask_.Get(index);
}
inline const ::PROTOBUF_NAMESPACE_ID::FieldMask& FieldMaskTest::repeated_mask(int index) const {
// @@protoc_insertion_point(field_get:proto_util_converter.testing.FieldMaskTest.repeated_mask)
return _internal_repeated_mask(index);
}
inline ::PROTOBUF_NAMESPACE_ID::FieldMask* FieldMaskTest::_internal_add_repeated_mask() {
return repeated_mask_.Add();
}
inline ::PROTOBUF_NAMESPACE_ID::FieldMask* FieldMaskTest::add_repeated_mask() {
::PROTOBUF_NAMESPACE_ID::FieldMask* _add = _internal_add_repeated_mask();
// @@protoc_insertion_point(field_add:proto_util_converter.testing.FieldMaskTest.repeated_mask)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FieldMask >&
FieldMaskTest::repeated_mask() const {
// @@protoc_insertion_point(field_list:proto_util_converter.testing.FieldMaskTest.repeated_mask)
return repeated_mask_;
}
// repeated .proto_util_converter.testing.NestedFieldMask nested_mask = 4;
inline int FieldMaskTest::_internal_nested_mask_size() const {
return nested_mask_.size();
}
inline int FieldMaskTest::nested_mask_size() const {
return _internal_nested_mask_size();
}
inline void FieldMaskTest::clear_nested_mask() {
nested_mask_.Clear();
}
inline ::proto_util_converter::testing::NestedFieldMask* FieldMaskTest::mutable_nested_mask(int index) {
// @@protoc_insertion_point(field_mutable:proto_util_converter.testing.FieldMaskTest.nested_mask)
return nested_mask_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto_util_converter::testing::NestedFieldMask >*
FieldMaskTest::mutable_nested_mask() {
// @@protoc_insertion_point(field_mutable_list:proto_util_converter.testing.FieldMaskTest.nested_mask)
return &nested_mask_;
}
inline const ::proto_util_converter::testing::NestedFieldMask& FieldMaskTest::_internal_nested_mask(int index) const {
return nested_mask_.Get(index);
}
inline const ::proto_util_converter::testing::NestedFieldMask& FieldMaskTest::nested_mask(int index) const {
// @@protoc_insertion_point(field_get:proto_util_converter.testing.FieldMaskTest.nested_mask)
return _internal_nested_mask(index);
}
inline ::proto_util_converter::testing::NestedFieldMask* FieldMaskTest::_internal_add_nested_mask() {
return nested_mask_.Add();
}
inline ::proto_util_converter::testing::NestedFieldMask* FieldMaskTest::add_nested_mask() {
::proto_util_converter::testing::NestedFieldMask* _add = _internal_add_nested_mask();
// @@protoc_insertion_point(field_add:proto_util_converter.testing.FieldMaskTest.nested_mask)
return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto_util_converter::testing::NestedFieldMask >&
FieldMaskTest::nested_mask() const {
// @@protoc_insertion_point(field_list:proto_util_converter.testing.FieldMaskTest.nested_mask)
return nested_mask_;
}
// -------------------------------------------------------------------
// FieldMaskTestCases
// .proto_util_converter.testing.FieldMaskWrapper single_mask = 1;
inline bool FieldMaskTestCases::_internal_has_single_mask() const {
return this != internal_default_instance() && single_mask_ != nullptr;
}
inline bool FieldMaskTestCases::has_single_mask() const {
return _internal_has_single_mask();
}
inline void FieldMaskTestCases::clear_single_mask() {
if (GetArenaForAllocation() == nullptr && single_mask_ != nullptr) {
delete single_mask_;
}
single_mask_ = nullptr;
}
inline const ::proto_util_converter::testing::FieldMaskWrapper& FieldMaskTestCases::_internal_single_mask() const {
const ::proto_util_converter::testing::FieldMaskWrapper* p = single_mask_;
return p != nullptr ? *p : reinterpret_cast<const ::proto_util_converter::testing::FieldMaskWrapper&>(
::proto_util_converter::testing::_FieldMaskWrapper_default_instance_);
}
inline const ::proto_util_converter::testing::FieldMaskWrapper& FieldMaskTestCases::single_mask() const {
// @@protoc_insertion_point(field_get:proto_util_converter.testing.FieldMaskTestCases.single_mask)
return _internal_single_mask();
}
inline void FieldMaskTestCases::unsafe_arena_set_allocated_single_mask(
::proto_util_converter::testing::FieldMaskWrapper* single_mask) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(single_mask_);
}
single_mask_ = single_mask;
if (single_mask) {
} else {
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto_util_converter.testing.FieldMaskTestCases.single_mask)
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::release_single_mask() {
::proto_util_converter::testing::FieldMaskWrapper* temp = single_mask_;
single_mask_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::unsafe_arena_release_single_mask() {
// @@protoc_insertion_point(field_release:proto_util_converter.testing.FieldMaskTestCases.single_mask)
::proto_util_converter::testing::FieldMaskWrapper* temp = single_mask_;
single_mask_ = nullptr;
return temp;
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::_internal_mutable_single_mask() {
if (single_mask_ == nullptr) {
auto* p = CreateMaybeMessage<::proto_util_converter::testing::FieldMaskWrapper>(GetArenaForAllocation());
single_mask_ = p;
}
return single_mask_;
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::mutable_single_mask() {
::proto_util_converter::testing::FieldMaskWrapper* _msg = _internal_mutable_single_mask();
// @@protoc_insertion_point(field_mutable:proto_util_converter.testing.FieldMaskTestCases.single_mask)
return _msg;
}
inline void FieldMaskTestCases::set_allocated_single_mask(::proto_util_converter::testing::FieldMaskWrapper* single_mask) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete single_mask_;
}
if (single_mask) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::proto_util_converter::testing::FieldMaskWrapper>::GetOwningArena(single_mask);
if (message_arena != submessage_arena) {
single_mask = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, single_mask, submessage_arena);
}
} else {
}
single_mask_ = single_mask;
// @@protoc_insertion_point(field_set_allocated:proto_util_converter.testing.FieldMaskTestCases.single_mask)
}
// .proto_util_converter.testing.FieldMaskWrapper multiple_mask = 2;
inline bool FieldMaskTestCases::_internal_has_multiple_mask() const {
return this != internal_default_instance() && multiple_mask_ != nullptr;
}
inline bool FieldMaskTestCases::has_multiple_mask() const {
return _internal_has_multiple_mask();
}
inline void FieldMaskTestCases::clear_multiple_mask() {
if (GetArenaForAllocation() == nullptr && multiple_mask_ != nullptr) {
delete multiple_mask_;
}
multiple_mask_ = nullptr;
}
inline const ::proto_util_converter::testing::FieldMaskWrapper& FieldMaskTestCases::_internal_multiple_mask() const {
const ::proto_util_converter::testing::FieldMaskWrapper* p = multiple_mask_;
return p != nullptr ? *p : reinterpret_cast<const ::proto_util_converter::testing::FieldMaskWrapper&>(
::proto_util_converter::testing::_FieldMaskWrapper_default_instance_);
}
inline const ::proto_util_converter::testing::FieldMaskWrapper& FieldMaskTestCases::multiple_mask() const {
// @@protoc_insertion_point(field_get:proto_util_converter.testing.FieldMaskTestCases.multiple_mask)
return _internal_multiple_mask();
}
inline void FieldMaskTestCases::unsafe_arena_set_allocated_multiple_mask(
::proto_util_converter::testing::FieldMaskWrapper* multiple_mask) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(multiple_mask_);
}
multiple_mask_ = multiple_mask;
if (multiple_mask) {
} else {
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto_util_converter.testing.FieldMaskTestCases.multiple_mask)
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::release_multiple_mask() {
::proto_util_converter::testing::FieldMaskWrapper* temp = multiple_mask_;
multiple_mask_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::unsafe_arena_release_multiple_mask() {
// @@protoc_insertion_point(field_release:proto_util_converter.testing.FieldMaskTestCases.multiple_mask)
::proto_util_converter::testing::FieldMaskWrapper* temp = multiple_mask_;
multiple_mask_ = nullptr;
return temp;
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::_internal_mutable_multiple_mask() {
if (multiple_mask_ == nullptr) {
auto* p = CreateMaybeMessage<::proto_util_converter::testing::FieldMaskWrapper>(GetArenaForAllocation());
multiple_mask_ = p;
}
return multiple_mask_;
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::mutable_multiple_mask() {
::proto_util_converter::testing::FieldMaskWrapper* _msg = _internal_mutable_multiple_mask();
// @@protoc_insertion_point(field_mutable:proto_util_converter.testing.FieldMaskTestCases.multiple_mask)
return _msg;
}
inline void FieldMaskTestCases::set_allocated_multiple_mask(::proto_util_converter::testing::FieldMaskWrapper* multiple_mask) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete multiple_mask_;
}
if (multiple_mask) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::proto_util_converter::testing::FieldMaskWrapper>::GetOwningArena(multiple_mask);
if (message_arena != submessage_arena) {
multiple_mask = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, multiple_mask, submessage_arena);
}
} else {
}
multiple_mask_ = multiple_mask;
// @@protoc_insertion_point(field_set_allocated:proto_util_converter.testing.FieldMaskTestCases.multiple_mask)
}
// .proto_util_converter.testing.FieldMaskWrapper snake_camel = 3;
inline bool FieldMaskTestCases::_internal_has_snake_camel() const {
return this != internal_default_instance() && snake_camel_ != nullptr;
}
inline bool FieldMaskTestCases::has_snake_camel() const {
return _internal_has_snake_camel();
}
inline void FieldMaskTestCases::clear_snake_camel() {
if (GetArenaForAllocation() == nullptr && snake_camel_ != nullptr) {
delete snake_camel_;
}
snake_camel_ = nullptr;
}
inline const ::proto_util_converter::testing::FieldMaskWrapper& FieldMaskTestCases::_internal_snake_camel() const {
const ::proto_util_converter::testing::FieldMaskWrapper* p = snake_camel_;
return p != nullptr ? *p : reinterpret_cast<const ::proto_util_converter::testing::FieldMaskWrapper&>(
::proto_util_converter::testing::_FieldMaskWrapper_default_instance_);
}
inline const ::proto_util_converter::testing::FieldMaskWrapper& FieldMaskTestCases::snake_camel() const {
// @@protoc_insertion_point(field_get:proto_util_converter.testing.FieldMaskTestCases.snake_camel)
return _internal_snake_camel();
}
inline void FieldMaskTestCases::unsafe_arena_set_allocated_snake_camel(
::proto_util_converter::testing::FieldMaskWrapper* snake_camel) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(snake_camel_);
}
snake_camel_ = snake_camel;
if (snake_camel) {
} else {
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto_util_converter.testing.FieldMaskTestCases.snake_camel)
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::release_snake_camel() {
::proto_util_converter::testing::FieldMaskWrapper* temp = snake_camel_;
snake_camel_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::unsafe_arena_release_snake_camel() {
// @@protoc_insertion_point(field_release:proto_util_converter.testing.FieldMaskTestCases.snake_camel)
::proto_util_converter::testing::FieldMaskWrapper* temp = snake_camel_;
snake_camel_ = nullptr;
return temp;
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::_internal_mutable_snake_camel() {
if (snake_camel_ == nullptr) {
auto* p = CreateMaybeMessage<::proto_util_converter::testing::FieldMaskWrapper>(GetArenaForAllocation());
snake_camel_ = p;
}
return snake_camel_;
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::mutable_snake_camel() {
::proto_util_converter::testing::FieldMaskWrapper* _msg = _internal_mutable_snake_camel();
// @@protoc_insertion_point(field_mutable:proto_util_converter.testing.FieldMaskTestCases.snake_camel)
return _msg;
}
inline void FieldMaskTestCases::set_allocated_snake_camel(::proto_util_converter::testing::FieldMaskWrapper* snake_camel) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete snake_camel_;
}
if (snake_camel) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::proto_util_converter::testing::FieldMaskWrapper>::GetOwningArena(snake_camel);
if (message_arena != submessage_arena) {
snake_camel = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, snake_camel, submessage_arena);
}
} else {
}
snake_camel_ = snake_camel;
// @@protoc_insertion_point(field_set_allocated:proto_util_converter.testing.FieldMaskTestCases.snake_camel)
}
// .proto_util_converter.testing.FieldMaskWrapper empty_field = 4;
inline bool FieldMaskTestCases::_internal_has_empty_field() const {
return this != internal_default_instance() && empty_field_ != nullptr;
}
inline bool FieldMaskTestCases::has_empty_field() const {
return _internal_has_empty_field();
}
inline void FieldMaskTestCases::clear_empty_field() {
if (GetArenaForAllocation() == nullptr && empty_field_ != nullptr) {
delete empty_field_;
}
empty_field_ = nullptr;
}
inline const ::proto_util_converter::testing::FieldMaskWrapper& FieldMaskTestCases::_internal_empty_field() const {
const ::proto_util_converter::testing::FieldMaskWrapper* p = empty_field_;
return p != nullptr ? *p : reinterpret_cast<const ::proto_util_converter::testing::FieldMaskWrapper&>(
::proto_util_converter::testing::_FieldMaskWrapper_default_instance_);
}
inline const ::proto_util_converter::testing::FieldMaskWrapper& FieldMaskTestCases::empty_field() const {
// @@protoc_insertion_point(field_get:proto_util_converter.testing.FieldMaskTestCases.empty_field)
return _internal_empty_field();
}
inline void FieldMaskTestCases::unsafe_arena_set_allocated_empty_field(
::proto_util_converter::testing::FieldMaskWrapper* empty_field) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(empty_field_);
}
empty_field_ = empty_field;
if (empty_field) {
} else {
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto_util_converter.testing.FieldMaskTestCases.empty_field)
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::release_empty_field() {
::proto_util_converter::testing::FieldMaskWrapper* temp = empty_field_;
empty_field_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::unsafe_arena_release_empty_field() {
// @@protoc_insertion_point(field_release:proto_util_converter.testing.FieldMaskTestCases.empty_field)
::proto_util_converter::testing::FieldMaskWrapper* temp = empty_field_;
empty_field_ = nullptr;
return temp;
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::_internal_mutable_empty_field() {
if (empty_field_ == nullptr) {
auto* p = CreateMaybeMessage<::proto_util_converter::testing::FieldMaskWrapper>(GetArenaForAllocation());
empty_field_ = p;
}
return empty_field_;
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::mutable_empty_field() {
::proto_util_converter::testing::FieldMaskWrapper* _msg = _internal_mutable_empty_field();
// @@protoc_insertion_point(field_mutable:proto_util_converter.testing.FieldMaskTestCases.empty_field)
return _msg;
}
inline void FieldMaskTestCases::set_allocated_empty_field(::proto_util_converter::testing::FieldMaskWrapper* empty_field) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete empty_field_;
}
if (empty_field) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::proto_util_converter::testing::FieldMaskWrapper>::GetOwningArena(empty_field);
if (message_arena != submessage_arena) {
empty_field = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, empty_field, submessage_arena);
}
} else {
}
empty_field_ = empty_field;
// @@protoc_insertion_point(field_set_allocated:proto_util_converter.testing.FieldMaskTestCases.empty_field)
}
// .proto_util_converter.testing.FieldMaskWrapper apiary_format1 = 5;
inline bool FieldMaskTestCases::_internal_has_apiary_format1() const {
return this != internal_default_instance() && apiary_format1_ != nullptr;
}
inline bool FieldMaskTestCases::has_apiary_format1() const {
return _internal_has_apiary_format1();
}
inline void FieldMaskTestCases::clear_apiary_format1() {
if (GetArenaForAllocation() == nullptr && apiary_format1_ != nullptr) {
delete apiary_format1_;
}
apiary_format1_ = nullptr;
}
inline const ::proto_util_converter::testing::FieldMaskWrapper& FieldMaskTestCases::_internal_apiary_format1() const {
const ::proto_util_converter::testing::FieldMaskWrapper* p = apiary_format1_;
return p != nullptr ? *p : reinterpret_cast<const ::proto_util_converter::testing::FieldMaskWrapper&>(
::proto_util_converter::testing::_FieldMaskWrapper_default_instance_);
}
inline const ::proto_util_converter::testing::FieldMaskWrapper& FieldMaskTestCases::apiary_format1() const {
// @@protoc_insertion_point(field_get:proto_util_converter.testing.FieldMaskTestCases.apiary_format1)
return _internal_apiary_format1();
}
inline void FieldMaskTestCases::unsafe_arena_set_allocated_apiary_format1(
::proto_util_converter::testing::FieldMaskWrapper* apiary_format1) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(apiary_format1_);
}
apiary_format1_ = apiary_format1;
if (apiary_format1) {
} else {
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto_util_converter.testing.FieldMaskTestCases.apiary_format1)
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::release_apiary_format1() {
::proto_util_converter::testing::FieldMaskWrapper* temp = apiary_format1_;
apiary_format1_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::unsafe_arena_release_apiary_format1() {
// @@protoc_insertion_point(field_release:proto_util_converter.testing.FieldMaskTestCases.apiary_format1)
::proto_util_converter::testing::FieldMaskWrapper* temp = apiary_format1_;
apiary_format1_ = nullptr;
return temp;
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::_internal_mutable_apiary_format1() {
if (apiary_format1_ == nullptr) {
auto* p = CreateMaybeMessage<::proto_util_converter::testing::FieldMaskWrapper>(GetArenaForAllocation());
apiary_format1_ = p;
}
return apiary_format1_;
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::mutable_apiary_format1() {
::proto_util_converter::testing::FieldMaskWrapper* _msg = _internal_mutable_apiary_format1();
// @@protoc_insertion_point(field_mutable:proto_util_converter.testing.FieldMaskTestCases.apiary_format1)
return _msg;
}
inline void FieldMaskTestCases::set_allocated_apiary_format1(::proto_util_converter::testing::FieldMaskWrapper* apiary_format1) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete apiary_format1_;
}
if (apiary_format1) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::proto_util_converter::testing::FieldMaskWrapper>::GetOwningArena(apiary_format1);
if (message_arena != submessage_arena) {
apiary_format1 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, apiary_format1, submessage_arena);
}
} else {
}
apiary_format1_ = apiary_format1;
// @@protoc_insertion_point(field_set_allocated:proto_util_converter.testing.FieldMaskTestCases.apiary_format1)
}
// .proto_util_converter.testing.FieldMaskWrapper apiary_format2 = 6;
inline bool FieldMaskTestCases::_internal_has_apiary_format2() const {
return this != internal_default_instance() && apiary_format2_ != nullptr;
}
inline bool FieldMaskTestCases::has_apiary_format2() const {
return _internal_has_apiary_format2();
}
inline void FieldMaskTestCases::clear_apiary_format2() {
if (GetArenaForAllocation() == nullptr && apiary_format2_ != nullptr) {
delete apiary_format2_;
}
apiary_format2_ = nullptr;
}
inline const ::proto_util_converter::testing::FieldMaskWrapper& FieldMaskTestCases::_internal_apiary_format2() const {
const ::proto_util_converter::testing::FieldMaskWrapper* p = apiary_format2_;
return p != nullptr ? *p : reinterpret_cast<const ::proto_util_converter::testing::FieldMaskWrapper&>(
::proto_util_converter::testing::_FieldMaskWrapper_default_instance_);
}
inline const ::proto_util_converter::testing::FieldMaskWrapper& FieldMaskTestCases::apiary_format2() const {
// @@protoc_insertion_point(field_get:proto_util_converter.testing.FieldMaskTestCases.apiary_format2)
return _internal_apiary_format2();
}
inline void FieldMaskTestCases::unsafe_arena_set_allocated_apiary_format2(
::proto_util_converter::testing::FieldMaskWrapper* apiary_format2) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(apiary_format2_);
}
apiary_format2_ = apiary_format2;
if (apiary_format2) {
} else {
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto_util_converter.testing.FieldMaskTestCases.apiary_format2)
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::release_apiary_format2() {
::proto_util_converter::testing::FieldMaskWrapper* temp = apiary_format2_;
apiary_format2_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::unsafe_arena_release_apiary_format2() {
// @@protoc_insertion_point(field_release:proto_util_converter.testing.FieldMaskTestCases.apiary_format2)
::proto_util_converter::testing::FieldMaskWrapper* temp = apiary_format2_;
apiary_format2_ = nullptr;
return temp;
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::_internal_mutable_apiary_format2() {
if (apiary_format2_ == nullptr) {
auto* p = CreateMaybeMessage<::proto_util_converter::testing::FieldMaskWrapper>(GetArenaForAllocation());
apiary_format2_ = p;
}
return apiary_format2_;
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::mutable_apiary_format2() {
::proto_util_converter::testing::FieldMaskWrapper* _msg = _internal_mutable_apiary_format2();
// @@protoc_insertion_point(field_mutable:proto_util_converter.testing.FieldMaskTestCases.apiary_format2)
return _msg;
}
inline void FieldMaskTestCases::set_allocated_apiary_format2(::proto_util_converter::testing::FieldMaskWrapper* apiary_format2) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete apiary_format2_;
}
if (apiary_format2) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::proto_util_converter::testing::FieldMaskWrapper>::GetOwningArena(apiary_format2);
if (message_arena != submessage_arena) {
apiary_format2 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, apiary_format2, submessage_arena);
}
} else {
}
apiary_format2_ = apiary_format2;
// @@protoc_insertion_point(field_set_allocated:proto_util_converter.testing.FieldMaskTestCases.apiary_format2)
}
// .proto_util_converter.testing.FieldMaskWrapper apiary_format3 = 7;
inline bool FieldMaskTestCases::_internal_has_apiary_format3() const {
return this != internal_default_instance() && apiary_format3_ != nullptr;
}
inline bool FieldMaskTestCases::has_apiary_format3() const {
return _internal_has_apiary_format3();
}
inline void FieldMaskTestCases::clear_apiary_format3() {
if (GetArenaForAllocation() == nullptr && apiary_format3_ != nullptr) {
delete apiary_format3_;
}
apiary_format3_ = nullptr;
}
inline const ::proto_util_converter::testing::FieldMaskWrapper& FieldMaskTestCases::_internal_apiary_format3() const {
const ::proto_util_converter::testing::FieldMaskWrapper* p = apiary_format3_;
return p != nullptr ? *p : reinterpret_cast<const ::proto_util_converter::testing::FieldMaskWrapper&>(
::proto_util_converter::testing::_FieldMaskWrapper_default_instance_);
}
inline const ::proto_util_converter::testing::FieldMaskWrapper& FieldMaskTestCases::apiary_format3() const {
// @@protoc_insertion_point(field_get:proto_util_converter.testing.FieldMaskTestCases.apiary_format3)
return _internal_apiary_format3();
}
inline void FieldMaskTestCases::unsafe_arena_set_allocated_apiary_format3(
::proto_util_converter::testing::FieldMaskWrapper* apiary_format3) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(apiary_format3_);
}
apiary_format3_ = apiary_format3;
if (apiary_format3) {
} else {
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto_util_converter.testing.FieldMaskTestCases.apiary_format3)
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::release_apiary_format3() {
::proto_util_converter::testing::FieldMaskWrapper* temp = apiary_format3_;
apiary_format3_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::unsafe_arena_release_apiary_format3() {
// @@protoc_insertion_point(field_release:proto_util_converter.testing.FieldMaskTestCases.apiary_format3)
::proto_util_converter::testing::FieldMaskWrapper* temp = apiary_format3_;
apiary_format3_ = nullptr;
return temp;
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::_internal_mutable_apiary_format3() {
if (apiary_format3_ == nullptr) {
auto* p = CreateMaybeMessage<::proto_util_converter::testing::FieldMaskWrapper>(GetArenaForAllocation());
apiary_format3_ = p;
}
return apiary_format3_;
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::mutable_apiary_format3() {
::proto_util_converter::testing::FieldMaskWrapper* _msg = _internal_mutable_apiary_format3();
// @@protoc_insertion_point(field_mutable:proto_util_converter.testing.FieldMaskTestCases.apiary_format3)
return _msg;
}
inline void FieldMaskTestCases::set_allocated_apiary_format3(::proto_util_converter::testing::FieldMaskWrapper* apiary_format3) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete apiary_format3_;
}
if (apiary_format3) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::proto_util_converter::testing::FieldMaskWrapper>::GetOwningArena(apiary_format3);
if (message_arena != submessage_arena) {
apiary_format3 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, apiary_format3, submessage_arena);
}
} else {
}
apiary_format3_ = apiary_format3;
// @@protoc_insertion_point(field_set_allocated:proto_util_converter.testing.FieldMaskTestCases.apiary_format3)
}
// .proto_util_converter.testing.FieldMaskWrapper map_key1 = 8;
inline bool FieldMaskTestCases::_internal_has_map_key1() const {
return this != internal_default_instance() && map_key1_ != nullptr;
}
inline bool FieldMaskTestCases::has_map_key1() const {
return _internal_has_map_key1();
}
inline void FieldMaskTestCases::clear_map_key1() {
if (GetArenaForAllocation() == nullptr && map_key1_ != nullptr) {
delete map_key1_;
}
map_key1_ = nullptr;
}
inline const ::proto_util_converter::testing::FieldMaskWrapper& FieldMaskTestCases::_internal_map_key1() const {
const ::proto_util_converter::testing::FieldMaskWrapper* p = map_key1_;
return p != nullptr ? *p : reinterpret_cast<const ::proto_util_converter::testing::FieldMaskWrapper&>(
::proto_util_converter::testing::_FieldMaskWrapper_default_instance_);
}
inline const ::proto_util_converter::testing::FieldMaskWrapper& FieldMaskTestCases::map_key1() const {
// @@protoc_insertion_point(field_get:proto_util_converter.testing.FieldMaskTestCases.map_key1)
return _internal_map_key1();
}
inline void FieldMaskTestCases::unsafe_arena_set_allocated_map_key1(
::proto_util_converter::testing::FieldMaskWrapper* map_key1) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(map_key1_);
}
map_key1_ = map_key1;
if (map_key1) {
} else {
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto_util_converter.testing.FieldMaskTestCases.map_key1)
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::release_map_key1() {
::proto_util_converter::testing::FieldMaskWrapper* temp = map_key1_;
map_key1_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::unsafe_arena_release_map_key1() {
// @@protoc_insertion_point(field_release:proto_util_converter.testing.FieldMaskTestCases.map_key1)
::proto_util_converter::testing::FieldMaskWrapper* temp = map_key1_;
map_key1_ = nullptr;
return temp;
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::_internal_mutable_map_key1() {
if (map_key1_ == nullptr) {
auto* p = CreateMaybeMessage<::proto_util_converter::testing::FieldMaskWrapper>(GetArenaForAllocation());
map_key1_ = p;
}
return map_key1_;
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::mutable_map_key1() {
::proto_util_converter::testing::FieldMaskWrapper* _msg = _internal_mutable_map_key1();
// @@protoc_insertion_point(field_mutable:proto_util_converter.testing.FieldMaskTestCases.map_key1)
return _msg;
}
inline void FieldMaskTestCases::set_allocated_map_key1(::proto_util_converter::testing::FieldMaskWrapper* map_key1) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete map_key1_;
}
if (map_key1) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::proto_util_converter::testing::FieldMaskWrapper>::GetOwningArena(map_key1);
if (message_arena != submessage_arena) {
map_key1 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, map_key1, submessage_arena);
}
} else {
}
map_key1_ = map_key1;
// @@protoc_insertion_point(field_set_allocated:proto_util_converter.testing.FieldMaskTestCases.map_key1)
}
// .proto_util_converter.testing.FieldMaskWrapper map_key2 = 9;
inline bool FieldMaskTestCases::_internal_has_map_key2() const {
return this != internal_default_instance() && map_key2_ != nullptr;
}
inline bool FieldMaskTestCases::has_map_key2() const {
return _internal_has_map_key2();
}
inline void FieldMaskTestCases::clear_map_key2() {
if (GetArenaForAllocation() == nullptr && map_key2_ != nullptr) {
delete map_key2_;
}
map_key2_ = nullptr;
}
inline const ::proto_util_converter::testing::FieldMaskWrapper& FieldMaskTestCases::_internal_map_key2() const {
const ::proto_util_converter::testing::FieldMaskWrapper* p = map_key2_;
return p != nullptr ? *p : reinterpret_cast<const ::proto_util_converter::testing::FieldMaskWrapper&>(
::proto_util_converter::testing::_FieldMaskWrapper_default_instance_);
}
inline const ::proto_util_converter::testing::FieldMaskWrapper& FieldMaskTestCases::map_key2() const {
// @@protoc_insertion_point(field_get:proto_util_converter.testing.FieldMaskTestCases.map_key2)
return _internal_map_key2();
}
inline void FieldMaskTestCases::unsafe_arena_set_allocated_map_key2(
::proto_util_converter::testing::FieldMaskWrapper* map_key2) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(map_key2_);
}
map_key2_ = map_key2;
if (map_key2) {
} else {
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto_util_converter.testing.FieldMaskTestCases.map_key2)
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::release_map_key2() {
::proto_util_converter::testing::FieldMaskWrapper* temp = map_key2_;
map_key2_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::unsafe_arena_release_map_key2() {
// @@protoc_insertion_point(field_release:proto_util_converter.testing.FieldMaskTestCases.map_key2)
::proto_util_converter::testing::FieldMaskWrapper* temp = map_key2_;
map_key2_ = nullptr;
return temp;
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::_internal_mutable_map_key2() {
if (map_key2_ == nullptr) {
auto* p = CreateMaybeMessage<::proto_util_converter::testing::FieldMaskWrapper>(GetArenaForAllocation());
map_key2_ = p;
}
return map_key2_;
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::mutable_map_key2() {
::proto_util_converter::testing::FieldMaskWrapper* _msg = _internal_mutable_map_key2();
// @@protoc_insertion_point(field_mutable:proto_util_converter.testing.FieldMaskTestCases.map_key2)
return _msg;
}
inline void FieldMaskTestCases::set_allocated_map_key2(::proto_util_converter::testing::FieldMaskWrapper* map_key2) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete map_key2_;
}
if (map_key2) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::proto_util_converter::testing::FieldMaskWrapper>::GetOwningArena(map_key2);
if (message_arena != submessage_arena) {
map_key2 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, map_key2, submessage_arena);
}
} else {
}
map_key2_ = map_key2;
// @@protoc_insertion_point(field_set_allocated:proto_util_converter.testing.FieldMaskTestCases.map_key2)
}
// .proto_util_converter.testing.FieldMaskWrapper map_key3 = 10;
inline bool FieldMaskTestCases::_internal_has_map_key3() const {
return this != internal_default_instance() && map_key3_ != nullptr;
}
inline bool FieldMaskTestCases::has_map_key3() const {
return _internal_has_map_key3();
}
inline void FieldMaskTestCases::clear_map_key3() {
if (GetArenaForAllocation() == nullptr && map_key3_ != nullptr) {
delete map_key3_;
}
map_key3_ = nullptr;
}
inline const ::proto_util_converter::testing::FieldMaskWrapper& FieldMaskTestCases::_internal_map_key3() const {
const ::proto_util_converter::testing::FieldMaskWrapper* p = map_key3_;
return p != nullptr ? *p : reinterpret_cast<const ::proto_util_converter::testing::FieldMaskWrapper&>(
::proto_util_converter::testing::_FieldMaskWrapper_default_instance_);
}
inline const ::proto_util_converter::testing::FieldMaskWrapper& FieldMaskTestCases::map_key3() const {
// @@protoc_insertion_point(field_get:proto_util_converter.testing.FieldMaskTestCases.map_key3)
return _internal_map_key3();
}
inline void FieldMaskTestCases::unsafe_arena_set_allocated_map_key3(
::proto_util_converter::testing::FieldMaskWrapper* map_key3) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(map_key3_);
}
map_key3_ = map_key3;
if (map_key3) {
} else {
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto_util_converter.testing.FieldMaskTestCases.map_key3)
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::release_map_key3() {
::proto_util_converter::testing::FieldMaskWrapper* temp = map_key3_;
map_key3_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::unsafe_arena_release_map_key3() {
// @@protoc_insertion_point(field_release:proto_util_converter.testing.FieldMaskTestCases.map_key3)
::proto_util_converter::testing::FieldMaskWrapper* temp = map_key3_;
map_key3_ = nullptr;
return temp;
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::_internal_mutable_map_key3() {
if (map_key3_ == nullptr) {
auto* p = CreateMaybeMessage<::proto_util_converter::testing::FieldMaskWrapper>(GetArenaForAllocation());
map_key3_ = p;
}
return map_key3_;
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::mutable_map_key3() {
::proto_util_converter::testing::FieldMaskWrapper* _msg = _internal_mutable_map_key3();
// @@protoc_insertion_point(field_mutable:proto_util_converter.testing.FieldMaskTestCases.map_key3)
return _msg;
}
inline void FieldMaskTestCases::set_allocated_map_key3(::proto_util_converter::testing::FieldMaskWrapper* map_key3) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete map_key3_;
}
if (map_key3) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::proto_util_converter::testing::FieldMaskWrapper>::GetOwningArena(map_key3);
if (message_arena != submessage_arena) {
map_key3 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, map_key3, submessage_arena);
}
} else {
}
map_key3_ = map_key3;
// @@protoc_insertion_point(field_set_allocated:proto_util_converter.testing.FieldMaskTestCases.map_key3)
}
// .proto_util_converter.testing.FieldMaskWrapper map_key4 = 11;
inline bool FieldMaskTestCases::_internal_has_map_key4() const {
return this != internal_default_instance() && map_key4_ != nullptr;
}
inline bool FieldMaskTestCases::has_map_key4() const {
return _internal_has_map_key4();
}
inline void FieldMaskTestCases::clear_map_key4() {
if (GetArenaForAllocation() == nullptr && map_key4_ != nullptr) {
delete map_key4_;
}
map_key4_ = nullptr;
}
inline const ::proto_util_converter::testing::FieldMaskWrapper& FieldMaskTestCases::_internal_map_key4() const {
const ::proto_util_converter::testing::FieldMaskWrapper* p = map_key4_;
return p != nullptr ? *p : reinterpret_cast<const ::proto_util_converter::testing::FieldMaskWrapper&>(
::proto_util_converter::testing::_FieldMaskWrapper_default_instance_);
}
inline const ::proto_util_converter::testing::FieldMaskWrapper& FieldMaskTestCases::map_key4() const {
// @@protoc_insertion_point(field_get:proto_util_converter.testing.FieldMaskTestCases.map_key4)
return _internal_map_key4();
}
inline void FieldMaskTestCases::unsafe_arena_set_allocated_map_key4(
::proto_util_converter::testing::FieldMaskWrapper* map_key4) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(map_key4_);
}
map_key4_ = map_key4;
if (map_key4) {
} else {
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto_util_converter.testing.FieldMaskTestCases.map_key4)
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::release_map_key4() {
::proto_util_converter::testing::FieldMaskWrapper* temp = map_key4_;
map_key4_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::unsafe_arena_release_map_key4() {
// @@protoc_insertion_point(field_release:proto_util_converter.testing.FieldMaskTestCases.map_key4)
::proto_util_converter::testing::FieldMaskWrapper* temp = map_key4_;
map_key4_ = nullptr;
return temp;
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::_internal_mutable_map_key4() {
if (map_key4_ == nullptr) {
auto* p = CreateMaybeMessage<::proto_util_converter::testing::FieldMaskWrapper>(GetArenaForAllocation());
map_key4_ = p;
}
return map_key4_;
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::mutable_map_key4() {
::proto_util_converter::testing::FieldMaskWrapper* _msg = _internal_mutable_map_key4();
// @@protoc_insertion_point(field_mutable:proto_util_converter.testing.FieldMaskTestCases.map_key4)
return _msg;
}
inline void FieldMaskTestCases::set_allocated_map_key4(::proto_util_converter::testing::FieldMaskWrapper* map_key4) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete map_key4_;
}
if (map_key4) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::proto_util_converter::testing::FieldMaskWrapper>::GetOwningArena(map_key4);
if (message_arena != submessage_arena) {
map_key4 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, map_key4, submessage_arena);
}
} else {
}
map_key4_ = map_key4;
// @@protoc_insertion_point(field_set_allocated:proto_util_converter.testing.FieldMaskTestCases.map_key4)
}
// .proto_util_converter.testing.FieldMaskWrapper map_key5 = 12;
inline bool FieldMaskTestCases::_internal_has_map_key5() const {
return this != internal_default_instance() && map_key5_ != nullptr;
}
inline bool FieldMaskTestCases::has_map_key5() const {
return _internal_has_map_key5();
}
inline void FieldMaskTestCases::clear_map_key5() {
if (GetArenaForAllocation() == nullptr && map_key5_ != nullptr) {
delete map_key5_;
}
map_key5_ = nullptr;
}
inline const ::proto_util_converter::testing::FieldMaskWrapper& FieldMaskTestCases::_internal_map_key5() const {
const ::proto_util_converter::testing::FieldMaskWrapper* p = map_key5_;
return p != nullptr ? *p : reinterpret_cast<const ::proto_util_converter::testing::FieldMaskWrapper&>(
::proto_util_converter::testing::_FieldMaskWrapper_default_instance_);
}
inline const ::proto_util_converter::testing::FieldMaskWrapper& FieldMaskTestCases::map_key5() const {
// @@protoc_insertion_point(field_get:proto_util_converter.testing.FieldMaskTestCases.map_key5)
return _internal_map_key5();
}
inline void FieldMaskTestCases::unsafe_arena_set_allocated_map_key5(
::proto_util_converter::testing::FieldMaskWrapper* map_key5) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(map_key5_);
}
map_key5_ = map_key5;
if (map_key5) {
} else {
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto_util_converter.testing.FieldMaskTestCases.map_key5)
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::release_map_key5() {
::proto_util_converter::testing::FieldMaskWrapper* temp = map_key5_;
map_key5_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::unsafe_arena_release_map_key5() {
// @@protoc_insertion_point(field_release:proto_util_converter.testing.FieldMaskTestCases.map_key5)
::proto_util_converter::testing::FieldMaskWrapper* temp = map_key5_;
map_key5_ = nullptr;
return temp;
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::_internal_mutable_map_key5() {
if (map_key5_ == nullptr) {
auto* p = CreateMaybeMessage<::proto_util_converter::testing::FieldMaskWrapper>(GetArenaForAllocation());
map_key5_ = p;
}
return map_key5_;
}
inline ::proto_util_converter::testing::FieldMaskWrapper* FieldMaskTestCases::mutable_map_key5() {
::proto_util_converter::testing::FieldMaskWrapper* _msg = _internal_mutable_map_key5();
// @@protoc_insertion_point(field_mutable:proto_util_converter.testing.FieldMaskTestCases.map_key5)
return _msg;
}
inline void FieldMaskTestCases::set_allocated_map_key5(::proto_util_converter::testing::FieldMaskWrapper* map_key5) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete map_key5_;
}
if (map_key5) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::proto_util_converter::testing::FieldMaskWrapper>::GetOwningArena(map_key5);
if (message_arena != submessage_arena) {
map_key5 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, map_key5, submessage_arena);
}
} else {
}
map_key5_ = map_key5;
// @@protoc_insertion_point(field_set_allocated:proto_util_converter.testing.FieldMaskTestCases.map_key5)
}
// -------------------------------------------------------------------
// FieldMaskWrapper
// .google.protobuf.FieldMask mask = 1;
inline bool FieldMaskWrapper::_internal_has_mask() const {
return this != internal_default_instance() && mask_ != nullptr;
}
inline bool FieldMaskWrapper::has_mask() const {
return _internal_has_mask();
}
inline const ::PROTOBUF_NAMESPACE_ID::FieldMask& FieldMaskWrapper::_internal_mask() const {
const ::PROTOBUF_NAMESPACE_ID::FieldMask* p = mask_;
return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::FieldMask&>(
::PROTOBUF_NAMESPACE_ID::_FieldMask_default_instance_);
}
inline const ::PROTOBUF_NAMESPACE_ID::FieldMask& FieldMaskWrapper::mask() const {
// @@protoc_insertion_point(field_get:proto_util_converter.testing.FieldMaskWrapper.mask)
return _internal_mask();
}
inline void FieldMaskWrapper::unsafe_arena_set_allocated_mask(
::PROTOBUF_NAMESPACE_ID::FieldMask* mask) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(mask_);
}
mask_ = mask;
if (mask) {
} else {
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto_util_converter.testing.FieldMaskWrapper.mask)
}
inline ::PROTOBUF_NAMESPACE_ID::FieldMask* FieldMaskWrapper::release_mask() {
::PROTOBUF_NAMESPACE_ID::FieldMask* temp = mask_;
mask_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::FieldMask* FieldMaskWrapper::unsafe_arena_release_mask() {
// @@protoc_insertion_point(field_release:proto_util_converter.testing.FieldMaskWrapper.mask)
::PROTOBUF_NAMESPACE_ID::FieldMask* temp = mask_;
mask_ = nullptr;
return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::FieldMask* FieldMaskWrapper::_internal_mutable_mask() {
if (mask_ == nullptr) {
auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::FieldMask>(GetArenaForAllocation());
mask_ = p;
}
return mask_;
}
inline ::PROTOBUF_NAMESPACE_ID::FieldMask* FieldMaskWrapper::mutable_mask() {
::PROTOBUF_NAMESPACE_ID::FieldMask* _msg = _internal_mutable_mask();
// @@protoc_insertion_point(field_mutable:proto_util_converter.testing.FieldMaskWrapper.mask)
return _msg;
}
inline void FieldMaskWrapper::set_allocated_mask(::PROTOBUF_NAMESPACE_ID::FieldMask* mask) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(mask_);
}
if (mask) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(mask));
if (message_arena != submessage_arena) {
mask = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, mask, submessage_arena);
}
} else {
}
mask_ = mask;
// @@protoc_insertion_point(field_set_allocated:proto_util_converter.testing.FieldMaskWrapper.mask)
}
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif // __GNUC__
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// @@protoc_insertion_point(namespace_scope)
} // namespace testing
} // namespace proto_util_converter
// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>
#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2futil_2finternal_2ftestdata_2ffield_5fmask_2eproto
| 43.298467 | 151 | 0.768054 |
aea2d10820da8d3417ed683f7e6a6620d355976f | 2,559 | h | C | parameter_tuner/include/parameteritem.h | pcchenxi/mrs_slam_modiflied | 0471ee340bc8d0048a0664600c65f1de8b9c7ef3 | [
"BSD-3-Clause"
] | 70 | 2016-07-09T12:55:46.000Z | 2022-03-19T04:49:46.000Z | parameter_tuner/include/parameteritem.h | pcchenxi/mrs_slam_modiflied | 0471ee340bc8d0048a0664600c65f1de8b9c7ef3 | [
"BSD-3-Clause"
] | 4 | 2016-07-14T20:30:17.000Z | 2019-12-13T10:20:55.000Z | parameter_tuner/include/parameteritem.h | pcchenxi/mrs_slam_modiflied | 0471ee340bc8d0048a0664600c65f1de8b9c7ef3 | [
"BSD-3-Clause"
] | 44 | 2016-07-14T19:30:57.000Z | 2022-03-19T05:50:01.000Z | //subclass for slider
//Author: Sebastian Schüller
#ifndef PARAMETERITEM_H
#define PARAMETERITEM_H
#include <QTreeWidget>
#include <QSpinBox>
#include <QLineEdit>
#include <QCheckBox>
#include <config_server/parameter.h>
namespace parametertuner
{
class WheelFilter : public QObject
{
Q_OBJECT
public:
explicit WheelFilter(QObject* parent = 0);
protected:
virtual bool eventFilter(QObject* object, QEvent* event);
};
class ParameterWidgetBase : public QWidget
{
Q_OBJECT
public:
virtual void IncValue() = 0;
virtual void DecValue() = 0;
};
class IntParameterWidget : public ParameterWidgetBase
{
Q_OBJECT
public:
explicit IntParameterWidget(ros::NodeHandle& nh, const config_server::ParameterDescription& description);
virtual ~IntParameterWidget();
virtual void DecValue();
virtual void IncValue();
Q_SIGNALS:
void called(int);
private Q_SLOTS:
void handleSlider();
void handleSpinbox();
void handleCallback(int value);
private:
config_server::Parameter<int> m_parameter;
QSlider* m_slider;
QSpinBox* m_spinbox;
};
class FloatParameterWidget : public ParameterWidgetBase
{
Q_OBJECT
public:
explicit FloatParameterWidget(ros::NodeHandle& nh, const config_server::ParameterDescription& description);
virtual ~FloatParameterWidget();
virtual void DecValue();
virtual void IncValue();
Q_SIGNALS:
void called(float);
private Q_SLOTS:
void handleSlider();
void handleSpinbox();
void handleCallback(float value);
private:
config_server::Parameter< float > m_parameter;
double m_sliderStepRatio;
QSlider* m_slider;
QDoubleSpinBox* m_spinbox;
};
class StringParameterWidget : public ParameterWidgetBase
{
Q_OBJECT
public:
explicit StringParameterWidget(ros::NodeHandle& nh, const config_server::ParameterDescription& description);
virtual ~StringParameterWidget();
virtual void DecValue();
virtual void IncValue();
Q_SIGNALS:
void called(std::string);
private Q_SLOTS:
void handleLineEdit();
void handleCallback(std::string text);
private:
config_server::Parameter< std::string > m_parameter;
QLineEdit* m_lineEdit;
};
class BoolParameterWidget : public ParameterWidgetBase
{
Q_OBJECT
public:
explicit BoolParameterWidget(ros::NodeHandle& nh, const config_server::ParameterDescription& description);
virtual ~BoolParameterWidget();
virtual void DecValue();
virtual void IncValue();
Q_SIGNALS:
void called(bool);
private Q_SLOTS:
void handleCheckbox();
void handleCallback(bool value);
private:
config_server::Parameter< bool > m_parameter;
QCheckBox* m_checkBox;
};
}
#endif | 19.097015 | 109 | 0.775303 |
aea307d9f8e6396732579a0eee72893e146194c5 | 528 | h | C | HW10/ws2812b.h | jimas95/advanced_mechatronics | 5ef5efdb66d4b4bed85d4a756bf7099b92ef7207 | [
"BSD-2-Clause"
] | null | null | null | HW10/ws2812b.h | jimas95/advanced_mechatronics | 5ef5efdb66d4b4bed85d4a756bf7099b92ef7207 | [
"BSD-2-Clause"
] | null | null | null | HW10/ws2812b.h | jimas95/advanced_mechatronics | 5ef5efdb66d4b4bed85d4a756bf7099b92ef7207 | [
"BSD-2-Clause"
] | null | null | null | #ifndef WS2812B_H__
#define WS2812B_H__
#include<xc.h> // processor SFR definitions
// Timer2 delay times, you can tune these if necessary
#define LOWTIME 15 // number of 48MHz cycles to be low for 0.35uS
#define HIGHTIME 65 // number of 48MHz cycles to be high for 1.65uS
// link three 8bit colors together
typedef struct {
unsigned char r;
unsigned char g;
unsigned char b;
} wsColor;
void ws2812b_setup();
void ws2812b_setColor(wsColor*,int);
wsColor HSBtoRGB(float hue, float sat, float brightness);
#endif | 25.142857 | 67 | 0.744318 |
aea347deace6a0e6c7af94345ff9cecdf3111834 | 1,771 | h | C | edas/include/alibabacloud/edas/model/InsertOrUpdateRegionRequest.h | aliyun/aliyun-openapi-cpp-sdk | 0cf5861ece17dfb0bb251f13bf3fbdb39c0c6e36 | [
"Apache-2.0"
] | 89 | 2018-02-02T03:54:39.000Z | 2021-12-13T01:32:55.000Z | edas/include/alibabacloud/edas/model/InsertOrUpdateRegionRequest.h | aliyun/aliyun-openapi-cpp-sdk | 0cf5861ece17dfb0bb251f13bf3fbdb39c0c6e36 | [
"Apache-2.0"
] | 89 | 2018-03-14T07:44:54.000Z | 2021-11-26T07:43:25.000Z | edas/include/alibabacloud/edas/model/InsertOrUpdateRegionRequest.h | aliyun/aliyun-openapi-cpp-sdk | 0cf5861ece17dfb0bb251f13bf3fbdb39c0c6e36 | [
"Apache-2.0"
] | 69 | 2018-01-22T09:45:52.000Z | 2022-03-28T07:58:38.000Z | /*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_EDAS_MODEL_INSERTORUPDATEREGIONREQUEST_H_
#define ALIBABACLOUD_EDAS_MODEL_INSERTORUPDATEREGIONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RoaServiceRequest.h>
#include <alibabacloud/edas/EdasExport.h>
namespace AlibabaCloud
{
namespace Edas
{
namespace Model
{
class ALIBABACLOUD_EDAS_EXPORT InsertOrUpdateRegionRequest : public RoaServiceRequest
{
public:
InsertOrUpdateRegionRequest();
~InsertOrUpdateRegionRequest();
bool getDebugEnable()const;
void setDebugEnable(bool debugEnable);
std::string getRegionTag()const;
void setRegionTag(const std::string& regionTag);
std::string getRegionName()const;
void setRegionName(const std::string& regionName);
std::string getDescription()const;
void setDescription(const std::string& description);
long getId()const;
void setId(long id);
private:
bool debugEnable_;
std::string regionTag_;
std::string regionName_;
std::string description_;
long id_;
};
}
}
}
#endif // !ALIBABACLOUD_EDAS_MODEL_INSERTORUPDATEREGIONREQUEST_H_ | 29.516667 | 88 | 0.738566 |
aea3ae764aeecb12cd77b1390ad4d168dc1c7512 | 338 | h | C | src/cetech/editor/selcted_object.h | ValtoForks/cetech | 03347c5ec34e8827024ae4ddd911bd0f804a85b0 | [
"CC0-1.0"
] | null | null | null | src/cetech/editor/selcted_object.h | ValtoForks/cetech | 03347c5ec34e8827024ae4ddd911bd0f804a85b0 | [
"CC0-1.0"
] | null | null | null | src/cetech/editor/selcted_object.h | ValtoForks/cetech | 03347c5ec34e8827024ae4ddd911bd0f804a85b0 | [
"CC0-1.0"
] | null | null | null | #ifndef CETECH_SELECTED_OBJECT_H
#define CETECH_SELECTED_OBJECT_H
#include <stdint.h>
#include "celib/module.inl"
struct ct_selected_object_a0 {
void (*set_selected_object)(uint64_t context, uint64_t obj);
uint64_t (*selected_object)(uint64_t context);
};
CE_MODULE(ct_selected_object_a0);
#endif //CETECH_SELECTED_OBJECT_H
| 19.882353 | 64 | 0.792899 |
aea437a298b151a3e0b4cba7c21b15d2ecbfcb93 | 11,960 | h | C | Source/wtf/text/AtomicString.h | igordmn/blink-typo | 4b25f34cb6580373beb900fd46886e05604fe6c3 | [
"BSD-3-Clause"
] | 20 | 2015-08-26T06:46:00.000Z | 2019-02-27T09:05:58.000Z | Source/wtf/text/AtomicString.h | igordmn/blink-typo | 4b25f34cb6580373beb900fd46886e05604fe6c3 | [
"BSD-3-Clause"
] | null | null | null | Source/wtf/text/AtomicString.h | igordmn/blink-typo | 4b25f34cb6580373beb900fd46886e05604fe6c3 | [
"BSD-3-Clause"
] | 2 | 2015-08-26T05:49:35.000Z | 2020-02-03T20:22:43.000Z | /*
* Copyright (C) 2004, 2005, 2006, 2008 Apple Inc. All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*
*/
#ifndef AtomicString_h
#define AtomicString_h
#include "wtf/HashTableDeletedValueType.h"
#include "wtf/WTFExport.h"
#include "wtf/text/CString.h"
#include "wtf/text/WTFString.h"
namespace WTF {
struct AtomicStringHash;
class WTF_EXPORT AtomicString {
public:
static void init();
AtomicString() { }
AtomicString(const LChar* s) : m_string(add(s)) { }
AtomicString(const char* s) : m_string(add(s)) { }
AtomicString(const LChar* s, unsigned length) : m_string(add(s, length)) { }
AtomicString(const UChar* s, unsigned length) : m_string(add(s, length)) { }
AtomicString(const UChar* s, unsigned length, unsigned existingHash) : m_string(add(s, length, existingHash)) { }
AtomicString(const UChar* s) : m_string(add(s)) { }
template<size_t inlineCapacity>
explicit AtomicString(const Vector<UChar, inlineCapacity>& characters)
: m_string(add(characters.data(), characters.size()))
{
}
// Constructing an AtomicString from a String / StringImpl can be expensive if
// the StringImpl is not already atomic.
explicit AtomicString(StringImpl* impl) : m_string(add(impl)) { }
explicit AtomicString(const String& s) : m_string(add(s.impl())) { }
AtomicString(StringImpl* baseString, unsigned start, unsigned length) : m_string(add(baseString, start, length)) { }
enum ConstructFromLiteralTag { ConstructFromLiteral };
AtomicString(const char* characters, unsigned length, ConstructFromLiteralTag)
: m_string(addFromLiteralData(characters, length))
{
}
template<unsigned charactersCount>
ALWAYS_INLINE AtomicString(const char (&characters)[charactersCount], ConstructFromLiteralTag)
: m_string(addFromLiteralData(characters, charactersCount - 1))
{
static_assert(charactersCount > 1, "AtomicString FromLiteralData should not be empty");
static_assert((charactersCount - 1 <= ((unsigned(~0) - sizeof(StringImpl)) / sizeof(LChar))), "AtomicString FromLiteralData cannot overflow");
}
// Hash table deleted values, which are only constructed and never copied or destroyed.
AtomicString(WTF::HashTableDeletedValueType) : m_string(WTF::HashTableDeletedValue) { }
bool isHashTableDeletedValue() const { return m_string.isHashTableDeletedValue(); }
static StringImpl* find(const StringImpl*);
operator const String&() const { return m_string; }
const String& string() const { return m_string; };
StringImpl* impl() const { return m_string.impl(); }
bool is8Bit() const { return m_string.is8Bit(); }
const LChar* characters8() const { return m_string.characters8(); }
const UChar* characters16() const { return m_string.characters16(); }
unsigned length() const { return m_string.length(); }
UChar operator[](unsigned i) const { return m_string[i]; }
bool contains(UChar c) const { return m_string.contains(c); }
bool contains(const LChar* s, TextCaseSensitivity caseSensitivity = TextCaseSensitive) const
{ return m_string.contains(s, caseSensitivity); }
bool contains(const String& s, TextCaseSensitivity caseSensitivity = TextCaseSensitive) const
{ return m_string.contains(s, caseSensitivity); }
size_t find(UChar c, size_t start = 0) const { return m_string.find(c, start); }
size_t find(const LChar* s, size_t start = 0, TextCaseSensitivity caseSensitivity = TextCaseSensitive) const
{ return m_string.find(s, start, caseSensitivity); }
size_t find(const String& s, size_t start = 0, TextCaseSensitivity caseSensitivity = TextCaseSensitive) const
{ return m_string.find(s, start, caseSensitivity); }
bool startsWith(const String& s, TextCaseSensitivity caseSensitivity = TextCaseSensitive) const
{ return m_string.startsWith(s, caseSensitivity); }
bool startsWith(UChar character) const
{ return m_string.startsWith(character); }
template<unsigned matchLength>
bool startsWith(const char (&prefix)[matchLength], TextCaseSensitivity caseSensitivity = TextCaseSensitive) const
{ return m_string.startsWith<matchLength>(prefix, caseSensitivity); }
bool endsWith(const String& s, TextCaseSensitivity caseSensitivity = TextCaseSensitive) const
{ return m_string.endsWith(s, caseSensitivity); }
bool endsWith(UChar character) const
{ return m_string.endsWith(character); }
template<unsigned matchLength>
bool endsWith(const char (&prefix)[matchLength], TextCaseSensitivity caseSensitivity = TextCaseSensitive) const
{ return m_string.endsWith<matchLength>(prefix, caseSensitivity); }
AtomicString lower() const;
AtomicString upper() const { return AtomicString(impl()->upper()); }
int toInt(bool* ok = 0) const { return m_string.toInt(ok); }
double toDouble(bool* ok = 0) const { return m_string.toDouble(ok); }
float toFloat(bool* ok = 0) const { return m_string.toFloat(ok); }
static AtomicString number(int);
static AtomicString number(unsigned);
static AtomicString number(long);
static AtomicString number(unsigned long);
static AtomicString number(long long);
static AtomicString number(unsigned long long);
static AtomicString number(double, unsigned precision = 6, TrailingZerosTruncatingPolicy = TruncateTrailingZeros);
bool isNull() const { return m_string.isNull(); }
bool isEmpty() const { return m_string.isEmpty(); }
static void remove(StringImpl*);
#if USE(CF)
AtomicString(CFStringRef s) : m_string(add(s)) { }
#endif
#ifdef __OBJC__
AtomicString(NSString* s) : m_string(add((CFStringRef)s)) { }
operator NSString*() const { return m_string; }
#endif
// AtomicString::fromUTF8 will return a null string if
// the input data contains invalid UTF-8 sequences.
static AtomicString fromUTF8(const char*, size_t);
static AtomicString fromUTF8(const char*);
CString ascii() const { return m_string.ascii(); }
CString latin1() const { return m_string.latin1(); }
CString utf8(UTF8ConversionMode mode = LenientUTF8Conversion) const { return m_string.utf8(mode); }
#ifndef NDEBUG
void show() const;
#endif
private:
String m_string;
static PassRefPtr<StringImpl> add(const LChar*);
ALWAYS_INLINE static PassRefPtr<StringImpl> add(const char* s) { return add(reinterpret_cast<const LChar*>(s)); };
static PassRefPtr<StringImpl> add(const LChar*, unsigned length);
static PassRefPtr<StringImpl> add(const UChar*, unsigned length);
ALWAYS_INLINE static PassRefPtr<StringImpl> add(const char* s, unsigned length) { return add(reinterpret_cast<const LChar*>(s), length); };
static PassRefPtr<StringImpl> add(const UChar*, unsigned length, unsigned existingHash);
static PassRefPtr<StringImpl> add(const UChar*);
static PassRefPtr<StringImpl> add(StringImpl*, unsigned offset, unsigned length);
ALWAYS_INLINE static PassRefPtr<StringImpl> add(StringImpl* r)
{
if (!r || r->isAtomic())
return r;
return addSlowCase(r);
}
static PassRefPtr<StringImpl> addFromLiteralData(const char* characters, unsigned length);
static PassRefPtr<StringImpl> addSlowCase(StringImpl*);
#if USE(CF)
static PassRefPtr<StringImpl> add(CFStringRef);
#endif
static AtomicString fromUTF8Internal(const char*, const char*);
};
inline bool operator==(const AtomicString& a, const AtomicString& b) { return a.impl() == b.impl(); }
WTF_EXPORT bool operator==(const AtomicString&, const LChar*);
inline bool operator==(const AtomicString& a, const char* b) { return WTF::equal(a.impl(), reinterpret_cast<const LChar*>(b)); }
inline bool operator==(const AtomicString& a, const Vector<UChar>& b) { return a.impl() && equal(a.impl(), b.data(), b.size()); }
inline bool operator==(const AtomicString& a, const String& b) { return equal(a.impl(), b.impl()); }
inline bool operator==(const LChar* a, const AtomicString& b) { return b == a; }
inline bool operator==(const String& a, const AtomicString& b) { return equal(a.impl(), b.impl()); }
inline bool operator==(const Vector<UChar>& a, const AtomicString& b) { return b == a; }
inline bool operator!=(const AtomicString& a, const AtomicString& b) { return a.impl() != b.impl(); }
inline bool operator!=(const AtomicString& a, const LChar* b) { return !(a == b); }
inline bool operator!=(const AtomicString& a, const char* b) { return !(a == b); }
inline bool operator!=(const AtomicString& a, const String& b) { return !equal(a.impl(), b.impl()); }
inline bool operator!=(const AtomicString& a, const Vector<UChar>& b) { return !(a == b); }
inline bool operator!=(const LChar* a, const AtomicString& b) { return !(b == a); }
inline bool operator!=(const String& a, const AtomicString& b) { return !equal(a.impl(), b.impl()); }
inline bool operator!=(const Vector<UChar>& a, const AtomicString& b) { return !(a == b); }
inline bool equalIgnoringCase(const AtomicString& a, const AtomicString& b) { return equalIgnoringCase(a.impl(), b.impl()); }
inline bool equalIgnoringCase(const AtomicString& a, const LChar* b) { return equalIgnoringCase(a.impl(), b); }
inline bool equalIgnoringCase(const AtomicString& a, const char* b) { return equalIgnoringCase(a.impl(), reinterpret_cast<const LChar*>(b)); }
inline bool equalIgnoringCase(const AtomicString& a, const String& b) { return equalIgnoringCase(a.impl(), b.impl()); }
inline bool equalIgnoringCase(const LChar* a, const AtomicString& b) { return equalIgnoringCase(a, b.impl()); }
inline bool equalIgnoringCase(const char* a, const AtomicString& b) { return equalIgnoringCase(reinterpret_cast<const LChar*>(a), b.impl()); }
inline bool equalIgnoringCase(const String& a, const AtomicString& b) { return equalIgnoringCase(a.impl(), b.impl()); }
// Define external global variables for the commonly used atomic strings.
// These are only usable from the main thread.
WTF_EXPORT extern const AtomicString& nullAtom;
WTF_EXPORT extern const AtomicString& emptyAtom;
WTF_EXPORT extern const AtomicString& starAtom;
WTF_EXPORT extern const AtomicString& xmlAtom;
WTF_EXPORT extern const AtomicString& xmlnsAtom;
WTF_EXPORT extern const AtomicString& xlinkAtom;
inline AtomicString AtomicString::fromUTF8(const char* characters, size_t length)
{
if (!characters)
return nullAtom;
if (!length)
return emptyAtom;
return fromUTF8Internal(characters, characters + length);
}
inline AtomicString AtomicString::fromUTF8(const char* characters)
{
if (!characters)
return nullAtom;
if (!*characters)
return emptyAtom;
return fromUTF8Internal(characters, 0);
}
// AtomicStringHash is the default hash for AtomicString
template<typename T> struct DefaultHash;
template<> struct DefaultHash<AtomicString> {
typedef AtomicStringHash Hash;
};
} // namespace WTF
WTF_ALLOW_MOVE_INIT_AND_COMPARE_WITH_MEM_FUNCTIONS(AtomicString);
using WTF::AtomicString;
using WTF::nullAtom;
using WTF::emptyAtom;
using WTF::starAtom;
using WTF::xmlAtom;
using WTF::xmlnsAtom;
using WTF::xlinkAtom;
#include "wtf/text/StringConcatenate.h"
#endif // AtomicString_h
| 46.356589 | 150 | 0.725 |
aea4677127b2101bb5d23ca80a1a0117b62ff904 | 3,568 | h | C | backends/gpu/include/tfrt/gpu/wrapper/blas_wrapper.h | Dig-Doug/runtime | e578f442cadc112074032964a4745b1873887ab2 | [
"Apache-2.0"
] | null | null | null | backends/gpu/include/tfrt/gpu/wrapper/blas_wrapper.h | Dig-Doug/runtime | e578f442cadc112074032964a4745b1873887ab2 | [
"Apache-2.0"
] | null | null | null | backends/gpu/include/tfrt/gpu/wrapper/blas_wrapper.h | Dig-Doug/runtime | e578f442cadc112074032964a4745b1873887ab2 | [
"Apache-2.0"
] | null | null | null | /*
* Copyright 2020 The TensorFlow Runtime Authors
*
* 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.
*/
// Thin abstraction layer for cuBLAS and MIOpen.
#ifndef TFRT_GPU_WRAPPER_BLAS_WRAPPER_H_
#define TFRT_GPU_WRAPPER_BLAS_WRAPPER_H_
#include <cstddef>
#include <memory>
#include "tfrt/gpu/wrapper/wrapper.h"
namespace tfrt {
namespace gpu {
namespace wrapper {
// Platform-discriminated enums.
struct BlasDataTypeTag;
using BlasDataType = Enum<BlasDataTypeTag>;
struct BlasOperationTag;
using BlasOperation = Enum<BlasOperationTag>;
struct BlasGemmAlgoTag;
using BlasGemmAlgo = Enum<BlasGemmAlgoTag>;
struct BlasFillModeTag;
using BlasFillMode = Enum<BlasFillModeTag>;
// Non-owning handles of GPU resources.
using BlasHandle = Resource<cublasHandle_t, rocblas_handle>;
namespace internal {
// Helper to wrap resources and memory into RAII types.
struct BlasHandleDeleter {
using pointer = BlasHandle;
void operator()(BlasHandle handle) const;
};
} // namespace internal
// RAII wrappers for resources. Instances own the underlying resource.
//
// They are implemented as std::unique_ptrs with custom deleters.
//
// Use get() and release() to access the non-owning handle, please use with
// appropriate care.
using OwningBlasHandle = internal::OwningResource<internal::BlasHandleDeleter>;
llvm::Expected<OwningBlasHandle> BlasCreate(CurrentContext current);
llvm::Error BlasDestroy(BlasHandle handle);
llvm::Error BlasSetStream(BlasHandle handle, Stream stream);
llvm::Expected<Stream> BlasGetStream(BlasHandle handle);
llvm::Error BlasAxpyEx(CurrentContext current, BlasHandle handle, int n,
Pointer<const void> alpha, BlasDataType alphaType,
Pointer<const void> x, BlasDataType typeX, int strideX,
Pointer<void> y, BlasDataType typeY, int strideY,
BlasDataType executionType);
llvm::Error BlasGemmEx(CurrentContext current, BlasHandle handle,
BlasOperation transA, BlasOperation transB, int m, int n,
int k, Pointer<const void> alpha, Pointer<const void> A,
BlasDataType typeA, int heightA, Pointer<const void> B,
BlasDataType typeB, int heightB,
Pointer<const void> beta, Pointer<void> C,
BlasDataType typeC, int heightC,
BlasDataType computeType, BlasGemmAlgo algo);
llvm::Error BlasGemmStridedBatchedEx(
CurrentContext current, BlasHandle handle, BlasOperation transA,
BlasOperation transB, int m, int n, int k, Pointer<const void> alpha,
Pointer<const void> A, BlasDataType typeA, int heightA, int64_t strideA,
Pointer<const void> B, BlasDataType typeB, int heightB, int64_t strideB,
Pointer<const void> beta, Pointer<void> C, BlasDataType typeC, int heightC,
int64_t strideC, int batchCount, BlasDataType computeType,
BlasGemmAlgo algo);
} // namespace wrapper
} // namespace gpu
} // namespace tfrt
#endif // TFRT_GPU_WRAPPER_BLAS_WRAPPER_H_
| 38.782609 | 80 | 0.723655 |
aea5ff963400f9e15563b4c0f9750344ac9f2367 | 1,669 | h | C | translator/include/xbyak_translator_for_aarch64/instructions/vpinsrb.h | kawakami-k/xbyak_translator_aarch64 | 92c2a958325a49f3d148cb7b003a7511abbe3718 | [
"Apache-2.0",
"BSD-3-Clause"
] | null | null | null | translator/include/xbyak_translator_for_aarch64/instructions/vpinsrb.h | kawakami-k/xbyak_translator_aarch64 | 92c2a958325a49f3d148cb7b003a7511abbe3718 | [
"Apache-2.0",
"BSD-3-Clause"
] | null | null | null | translator/include/xbyak_translator_for_aarch64/instructions/vpinsrb.h | kawakami-k/xbyak_translator_aarch64 | 92c2a958325a49f3d148cb7b003a7511abbe3718 | [
"Apache-2.0",
"BSD-3-Clause"
] | null | null | null | /*******************************************************************************
* Copyright 2020 FUJITSU LIMITED
*
* 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.
*******************************************************************************/
void translateVPINSRB(xed_decoded_inst_t *p) {
namespace xa = Xbyak_aarch64;
struct xt_a64fx_operands_struct_t a64;
xt_construct_a64fx_operands(p, &a64);
/* 2020/02/14 10:12 */
/* Col=V103*/
if (false || (a64.src2Type == A64_OP_MEM && true)) {
CodeGeneratorAArch64::ldrb(W_TMP_0, xa::ptr(X_TMP_ADDR));
}
/* Col=X103*/
if (false || (a64.src2Type == A64_OP_REG && true) ||
(a64.src2Type == A64_OP_MEM && true)) {
CodeGeneratorAArch64::mov(xa::VReg(a64.dstIdx).b16,
xa::VReg(a64.srcIdx).b16);
}
/* Col=Z103*/
if (false || (a64.src2Type == A64_OP_REG && true)) {
CodeGeneratorAArch64::ins_(xa::VReg16B(a64.dstIdx)[a64.uimm],
xa::WReg(a64.src2Idx));
}
/* Col=AA103*/
if (false || (a64.src2Type == A64_OP_MEM && true)) {
CodeGeneratorAArch64::ins_(xa::VReg16B(a64.dstIdx)[a64.uimm], W_TMP_0);
}
}
| 37.088889 | 81 | 0.594368 |
aea646188271e4a52744ccf258bdda130d6d7a86 | 1,302 | h | C | src/draw/Backend.h | cyllene-project/Rubric | dae36e7a0801b35056dfb676c2f9c60faaaa09f8 | [
"MIT"
] | null | null | null | src/draw/Backend.h | cyllene-project/Rubric | dae36e7a0801b35056dfb676c2f9c60faaaa09f8 | [
"MIT"
] | null | null | null | src/draw/Backend.h | cyllene-project/Rubric | dae36e7a0801b35056dfb676c2f9c60faaaa09f8 | [
"MIT"
] | null | null | null | // Rubric
// Copyright (c) 2019 Chris Daley <chebizarro@gmail.com>
// This code is licensed under MIT license (see LICENSE.txt for details)
#ifndef RUBRIC_BACKEND_H
#define RUBRIC_BACKEND_H
#include <draw/Display.h>
#include <memory>
#include <map>
#include <draw/Context.h>
#define RUBRIC_DRAW_REGISTER_BACKEND(klass) \
class klass##Factory : public rubric::draw::BackendFactory { \
public: \
klass##Factory() noexcept { \
rubric::draw::Backend::registerBackend(#klass, this); \
} \
virtual std::shared_ptr<rubric::draw::Backend> create() { \
return std::make_shared<klass>(); \
} \
}; \
static klass##Factory global_##klass##Factory;
namespace rubric::draw {
class Backend;
class BackendFactory;
}
class rubric::draw::Backend {
public:
virtual std::unique_ptr<Display> open(rubric::draw::Context &, const std::string &) const = 0;
virtual std::string getName() const = 0;
static void registerBackend(const std::string &, BackendFactory *);
static std::map<std::string, BackendFactory*> getBackends();
private:
static std::map<std::string, BackendFactory*> backends;
};
class rubric::draw::BackendFactory {
public:
virtual std::shared_ptr<Backend> create() = 0;
};
#endif //RUBRIC_BACKEND_H
| 27.125 | 98 | 0.676651 |
aea811ba5b89283c087be8585b31acf2a4ed44c1 | 940 | h | C | System/Library/PrivateFrameworks/AVFCapture.framework/AVCaptureSystemPressureStateInternal.h | zhangkn/iOS14Header | 4323e9459ed6f6f5504ecbea2710bfd6c3d7c946 | [
"MIT"
] | 1 | 2020-11-04T15:43:01.000Z | 2020-11-04T15:43:01.000Z | System/Library/PrivateFrameworks/AVFCapture.framework/AVCaptureSystemPressureStateInternal.h | zhangkn/iOS14Header | 4323e9459ed6f6f5504ecbea2710bfd6c3d7c946 | [
"MIT"
] | null | null | null | System/Library/PrivateFrameworks/AVFCapture.framework/AVCaptureSystemPressureStateInternal.h | zhangkn/iOS14Header | 4323e9459ed6f6f5504ecbea2710bfd6c3d7c946 | [
"MIT"
] | null | null | null | /*
* This header is generated by classdump-dyld 1.0
* on Sunday, September 27, 2020 at 11:42:32 AM Mountain Standard Time
* Operating System: Version 14.0 (Build 18A373)
* Image Source: /System/Library/PrivateFrameworks/AVFCapture.framework/AVFCapture
* classdump-dyld is licensed under GPLv3, Copyright © 2013-2016 by Elias Limneos.
*/
@class AVFrameRateRange;
@interface AVCaptureSystemPressureStateInternal : NSObject {
int _figLevel;
unsigned long long _factors;
AVFrameRateRange* _recommendedFrameRateRangeForPortrait;
}
@property (readonly) int figLevel;
@property (readonly) unsigned long long factors;
@property (readonly) AVFrameRateRange * recommendedFrameRateRangeForPortrait;
-(int)figLevel;
-(void)dealloc;
-(id)initWithFigLevel:(int)arg1 factors:(unsigned long long)arg2 recommendedFrameRateRangeForPortrait:(id)arg3 ;
-(AVFrameRateRange *)recommendedFrameRateRangeForPortrait;
-(unsigned long long)factors;
@end
| 31.333333 | 112 | 0.8 |
aea92df35f7fd3c7eb9a06f5935af1824f93fa9a | 1,941 | h | C | include/conway.h | carsonclarke570/render-farm | 13e3f95998a9b42f0bd81002c14bf496de4baea5 | [
"Apache-2.0"
] | null | null | null | include/conway.h | carsonclarke570/render-farm | 13e3f95998a9b42f0bd81002c14bf496de4baea5 | [
"Apache-2.0"
] | null | null | null | include/conway.h | carsonclarke570/render-farm | 13e3f95998a9b42f0bd81002c14bf496de4baea5 | [
"Apache-2.0"
] | null | null | null | /*
Copyright 2020 Carson Clarke-Magrab
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 CONWAY_H
#define CONWAY_H
#include <stdlib.h>
#include <stdio.h>
#include "grid.h"
#define CONWAY_SURVIVE_LOW (5)
#define CONWAY_SURVIVE_HIGH (7)
#define CONWAY_BIRTH_LOW (6)
#define CONWAY_BIRTH_HIGH (6)
class GameOfLife {
private:
Grid *m_next;
int count_neigbors(int x, int y, int z);
void wrap_bounds(int x0, int y0, int z0, int *x1, int *y1, int *z1);
public:
Grid *m_current;
int x;
int y;
int z;
/**
* Construct a new Game Of Life object
*
* @param x_len Length of the x dimension
* @param y_len Length of the y dimension
* @param z_len Length of the z dimension
*/
GameOfLife(int x, int y, int z);
/**
* Destroy the Game Of Life object
*/
~GameOfLife();
/**
* Creates a new Grid object and populates it with living cells.
*
* @param percent Percent of the cells to fill in the range [0:100]
*/
void populate(int percent);
/**
* Applies the given rule represented by:
* [A A A A B B B B C C C C D D D D]
* - Live cells remain living if they have between A and B neighbors
* - Dead cells become alive if they have between C and D neighnors
*
* @param rule Rule for the system
*/
void step();
};
#endif
| 24.56962 | 77 | 0.638331 |
aea94c9203a3c76eebf2286284bf671e466e3d75 | 758 | h | C | include/ClientSocketUDP.h | DJJA/UltimateDeathRace | ade30b8b2c8ab0e3eb81364f683838e18a0b2efb | [
"MIT"
] | 1 | 2017-05-19T13:02:12.000Z | 2017-05-19T13:02:12.000Z | include/ClientSocketUDP.h | DJJA/UltimateDeathRace | ade30b8b2c8ab0e3eb81364f683838e18a0b2efb | [
"MIT"
] | null | null | null | include/ClientSocketUDP.h | DJJA/UltimateDeathRace | ade30b8b2c8ab0e3eb81364f683838e18a0b2efb | [
"MIT"
] | null | null | null | #ifndef CLIENTSOCKETUDP_H
#define CLIENTSOCKETUDP_H
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include "PacketTypes.h"
#define SERVERADDRESS "10.1.10.100"
#define SERVERPORT "45621"
class ClientSocketUDP
{
public:
ClientSocketUDP();
virtual ~ClientSocketUDP();
int CreateSocket();
int SendData(Packet&);
int ReceiveDataFrom(char[], int);
void Close();
protected:
private:
int sockfd;
struct addrinfo *p, *servinfo;
//int numbytes;
};
#endif // CLIENTSOCKETUDP_H
| 19.947368 | 42 | 0.620053 |
aea98f497263d1a5723014233113f9a5ae4c1105 | 708 | c | C | src/mgos_lcd_1602.c | lilrom13/lcd_1602 | 14be70f1f55fbe2c169d38b6f309b668c83b25c8 | [
"Apache-2.0"
] | 1 | 2022-01-10T00:07:54.000Z | 2022-01-10T00:07:54.000Z | src/mgos_lcd_1602.c | lilrom13/lcd_1602 | 14be70f1f55fbe2c169d38b6f309b668c83b25c8 | [
"Apache-2.0"
] | null | null | null | src/mgos_lcd_1602.c | lilrom13/lcd_1602 | 14be70f1f55fbe2c169d38b6f309b668c83b25c8 | [
"Apache-2.0"
] | null | null | null | #include "mgos.h"
#include "mgos_lcd_1602.h"
bool mgos_lcd_1602_init() {
return true;
}
mgos_lcd_1602 *mgos_lcd_1602_create(int rs, int rw, int enable) {
mgos_lcd_1602 *lcd = (mgos_lcd_1602 *) calloc(0, sizeof(mgos_lcd_1602));
if (lcd) {
lcd->rs = rs;
lcd->rw = rw;
lcd->enable = enable;
// default values after reset
lcd->display = LCD_DISPLAY_OFF;
lcd->cursor = LCD_CURSOR_OFF;
lcd->blinking = LCD_BLINKING_OFF;
}
LOG(LL_INFO, ("lcd_1602 has been created..."));
return lcd;
}
void mgos_lcd_1602_destroy(mgos_lcd_1602 *lcd) {
LOG(LL_INFO, ("lcd_1602 has been destroy..."));
}
bool set_display(mgos_lcd_1602 *, bool display) {
if (display) {
}
}
| 19.666667 | 74 | 0.658192 |
aeae50375505ffdaf82af65e14b895df88d1698c | 2,766 | h | C | lighter/common/model_loader.h | VulkanWorks/lighter-Earth-Map-Spline | b3a8ab4b3ab0ce3027f337d7991015db8758ded9 | [
"Apache-2.0"
] | 3 | 2020-09-07T12:26:59.000Z | 2021-09-04T08:37:54.000Z | lighter/common/model_loader.h | lun0522/jessie-steamer | 74379c9bd685bb9f1b3197a798df40cde5ed4fb2 | [
"Apache-2.0"
] | null | null | null | lighter/common/model_loader.h | lun0522/jessie-steamer | 74379c9bd685bb9f1b3197a798df40cde5ed4fb2 | [
"Apache-2.0"
] | 1 | 2021-09-04T08:38:03.000Z | 2021-09-04T08:38:03.000Z | //
// model_loader.h
//
// Created by Pujun Lun on 4/13/19.
// Copyright © 2019 Pujun Lun. All rights reserved.
//
#ifndef LIGHTER_COMMON_MODEL_LOADER_H
#define LIGHTER_COMMON_MODEL_LOADER_H
#include <string>
#include <vector>
#include "lighter/common/file.h"
#include "third_party/assimp/material.h"
#include "third_party/assimp/mesh.h"
#include "third_party/assimp/scene.h"
namespace lighter::common {
// Model loader backed by Assimp.
class ModelLoader {
public:
// Texture types that can be bound to shaders.
enum class TextureType {
kDiffuse, kSpecular, kReflection, kCubemap, kNumTypes,
};
// Information about a texture.
struct TextureInfo {
// This class is only movable.
TextureInfo(TextureInfo&&) noexcept = default;
TextureInfo& operator=(TextureInfo&&) noexcept = default;
// Path to the texture.
std::string path;
// Texture type.
TextureType texture_type;
};
// Vertex data and textures information for one mesh.
struct MeshData {
MeshData() = default;
// This class is only movable.
MeshData(MeshData&&) noexcept = default;
MeshData& operator=(MeshData&&) noexcept = default;
// Vertex data of the mesh.
std::vector<Vertex3DWithTex> vertices;
std::vector<uint32_t> indices;
// Textures information of the mesh.
std::vector<TextureInfo> textures;
};
// Loads the model from 'model_path' and textures from 'texture_dir', assuming
// all textures are in the same directory.
ModelLoader(const std::string& model_path, const std::string& texture_dir);
// This class is neither copyable nor movable.
ModelLoader(const ModelLoader&) = delete;
ModelLoader& operator=(const ModelLoader&) = delete;
// Accessors.
const std::vector<MeshData>& mesh_datas() const { return mesh_datas_; }
private:
// Processes the 'node' in Assimp scene graph. This adds all the data of
// meshes stored in 'node' to 'mesh_datas_', and recursively processes all
// children nodes.
void ProcessNode(const std::string& directory,
const aiNode* node,
const aiScene* scene);
// Loads mesh data from the given 'mesh'.
MeshData LoadMesh(const std::string& directory,
const aiMesh* mesh,
const aiScene* scene) const;
// Loads textures of the given 'texture_type' and appends to 'texture_infos'.
void LoadTextures(const std::string& directory,
const aiMaterial* material,
TextureType texture_type,
std::vector<TextureInfo>* texture_infos) const;
// Holds the data of all meshes in one model.
std::vector<MeshData> mesh_datas_;
};
} // namespace lighter::common
#endif // LIGHTER_COMMON_MODEL_LOADER_H
| 29.115789 | 80 | 0.683659 |
aeaf09829e02a4a88e0971d9a2771b621911a279 | 4,449 | c | C | src/ALSP/io_poll_nb.c | pr0gr4m/Study | da6792b181644c05ca0545c2bb5e19bdef593a78 | [
"Apache-2.0"
] | null | null | null | src/ALSP/io_poll_nb.c | pr0gr4m/Study | da6792b181644c05ca0545c2bb5e19bdef593a78 | [
"Apache-2.0"
] | null | null | null | src/ALSP/io_poll_nb.c | pr0gr4m/Study | da6792b181644c05ca0545c2bb5e19bdef593a78 | [
"Apache-2.0"
] | null | null | null | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <poll.h>
#include <fcntl.h>
#include "stdalsp.h"
#define LISTEN_BACKLOG 256
#define MAX_FD_SOCKET 0xff
struct pollfd pollfds[MAX_FD_SOCKET];
int cnt_fd_socket;
int add_socket(int fd);
int del_socket(int fd);
int main(int argc, char *argv[])
{
socklen_t len_saddr;
int i, fd, fd_listener, ret_recv, ret_poll;
char *port, buf[1024];
if (argc != 2)
printf("%s [port number] \n", argv[0]);
if (argc == 2)
port = strdup(argv[1]);
else
port = strdup("0");
struct addrinfo ai, *ai_ret;
int rc_gai;
memset(&ai, 0, sizeof(ai));
ai.ai_family = AF_INET;
ai.ai_socktype = SOCK_STREAM;
ai.ai_flags = AI_ADDRCONFIG | AI_PASSIVE;
if ((rc_gai = getaddrinfo(NULL, port, &ai, &ai_ret)) != 0) {
pr_err("Fail: getaddrinfo():%s", gai_strerror(rc_gai));
exit(EXIT_FAILURE);
}
if ((fd_listener = socket(ai_ret->ai_family,
ai_ret->ai_socktype, ai_ret->ai_protocol)) == -1) {
pr_err("Fail: socket()");
exit(EXIT_FAILURE);
}
int sockopt = 1;
if (setsockopt(fd_listener, SOL_SOCKET, SO_REUSEADDR, &sockopt, sizeof(sockopt)) == -1) {
pr_err("Fail: setsockopt()");
exit(EXIT_FAILURE);
}
if (fcntl(fd_listener, F_SETFL, O_NONBLOCK) == -1) {
pr_err("Fail: fcntl() error");
exit(EXIT_FAILURE);
}
if (bind(fd_listener, ai_ret->ai_addr, ai_ret->ai_addrlen) == -1) {
pr_err("Fail: bind()");
exit(EXIT_FAILURE);
}
if (!strncmp(port, "0", strlen(port))) {
struct sockaddr_storage saddr_s;
len_saddr = sizeof(saddr_s);
getsockname(fd_listener, (struct sockaddr *)&saddr_s, &len_saddr);
if (saddr_s.ss_family == AF_INET) {
pr_out("bind : IPv4 Port : #%d",
ntohs(((struct sockaddr_in *)&saddr_s)->sin_port));
} else if (saddr_s.ss_family == AF_INET6) {
pr_out("bind : IPv6 Port : #%d",
ntohs(((struct sockaddr_in6 *)&saddr_s)->sin6_port));
} else {
pr_out("getsockname : ss_family = %d", saddr_s.ss_family);
}
} else {
pr_out("bind : %s", port);
}
listen(fd_listener, LISTEN_BACKLOG);
add_socket(fd_listener);
while (1) {
if ((ret_poll = poll(pollfds, cnt_fd_socket, -1)) == -1) {
pr_err("Fail: poll()");
exit(EXIT_FAILURE);
}
pr_out("\tpoll = (%d)", ret_poll);
if (pollfds[0].revents & POLLIN) {
struct sockaddr_storage saddr_c;
while (1) {
len_saddr = sizeof(saddr_c);
if ((fd = accept(pollfds[0].fd, (struct sockaddr *)&saddr_c, &len_saddr)) == -1) {
if (errno == EAGAIN) {
break;
}
pr_err("Error get connection from listen socket");
break;
}
if (add_socket(fd) == -1) {
/* error */
}
pr_out("accept : add socket(%d)", fd);
}
continue;
}
for (i = 1; i < cnt_fd_socket && ret_poll > 0; ++i) {
if (pollfds[i].revents & POLLIN) {
pr_out("POLLIN : normal-inband");
if ((ret_recv = recv(pollfds[i].fd, buf, sizeof(buf), 0)) == -1) {
pr_err("fd(%d) recv() error (%s)", pollfds[i].fd, strerror(errno));
} else {
if (ret_recv == 0) {
pr_out("fd(%d) : Session closed", pollfds[i].fd);
del_socket(pollfds[i].fd);
i--;
} else {
pr_out("recv(fd=%d,n=%d) = %.*s", pollfds[i].fd, ret_recv, ret_recv, buf);
}
}
ret_poll--;
#ifdef ENABLE_MSG_OOB
} else if (pollfds[i].revents & POLLPRI) {
pr_out("POLLPRI : Urgent data detected");
if ((ret_recv = recv(pollfds[i].fd, buf, 1, MSG_OOB)) == -1) {
pr_err("Fail: recv()");
}
pr_out("recv(fd=%d,n=1) = %.*s (OOB)", pollfds[i].fd, 1, buf);
#endif
} else if (pollfds[i].revents & POLLERR) {
ret_poll--;
} else if (pollfds[i].revents & POLLNVAL) {
ret_poll--;
} else {
pr_out("> No signal:fd(%d)", pollfds[i].fd);
}
}
}
return 0;
}
int add_socket(int fd)
{
if (cnt_fd_socket < MAX_FD_SOCKET) {
pollfds[cnt_fd_socket].fd = fd;
#ifdef ENABLE_MSG_OOB
pollfds[cnt_fd_socket].events = POLLIN | POLLPRI;
#else
pollfds[cnt_fd_socket].events = POLLIN;
#endif
return ++cnt_fd_socket;
} else {
return -1;
}
}
int del_socket(int fd)
{
int i, flag = 0;
close(fd);
for (i = 0; i < cnt_fd_socket; i++) {
if (pollfds[i].fd == fd) {
if (i != (cnt_fd_socket - 1)) {
pollfds[i] = pollfds[cnt_fd_socket - 1];
}
pollfds[cnt_fd_socket - 1].fd = -1;
flag = 1;
break;
}
}
if (flag == 0) {
return -1;
}
--cnt_fd_socket;
return i;
}
| 22.583756 | 90 | 0.608676 |
aeb2e934e8f709e45822b13f39e51a137b51f5d5 | 1,459 | c | C | src/ant_pusher_path_op.c | jde-maga/lem-in | acc0aa697cda14c3e9d323c997a1d8a7c4b0c7eb | [
"MIT"
] | null | null | null | src/ant_pusher_path_op.c | jde-maga/lem-in | acc0aa697cda14c3e9d323c997a1d8a7c4b0c7eb | [
"MIT"
] | null | null | null | src/ant_pusher_path_op.c | jde-maga/lem-in | acc0aa697cda14c3e9d323c997a1d8a7c4b0c7eb | [
"MIT"
] | null | null | null | /* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ant_pusher_path_op.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jde-maga <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/06/30 18:38:20 by jde-maga #+# #+# */
/* Updated: 2016/06/30 18:43:09 by jde-maga ### ########.fr */
/* */
/* ************************************************************************** */
#include <lemin.h>
int calculate_size(int *path)
{
int i;
i = 0;
while (path[i] != -1)
i++;
return (i);
}
void clean_path(int **paths, int ants)
{
int i;
i = 0;
while (paths[i] != NULL)
i++;
i--;
while (calculate_size(paths[i]) - ants > 0 && i != 0)
{
paths[i] = NULL;
i--;
}
}
void print_ant_move(t_ants *ant, t_room **room, t_linkid *linkid,
int sig)
{
if (sig)
ft_printf(" ");
if (ant->room == -1)
ft_printf("L%d-%s", ant->ant + 1, room[END_ROOM]->name);
else
ft_printf("L%d-%s", ant->ant + 1, room[ant->room - 1]->name);
}
| 29.18 | 80 | 0.282385 |
aeb2f33dd34421b39d5dbef9a92252dbe6488c7d | 675 | h | C | gcompiler/delta_infer/custom_grappler/auto_fusion.h | didichuxing/delta | 31dfebc8f20b7cb282b62f291ff25a87e403cc86 | [
"Apache-2.0"
] | 1,442 | 2019-07-09T07:34:28.000Z | 2020-11-15T09:52:09.000Z | gcompiler/delta_infer/custom_grappler/auto_fusion.h | didichuxing/delta | 31dfebc8f20b7cb282b62f291ff25a87e403cc86 | [
"Apache-2.0"
] | 93 | 2019-07-22T09:20:20.000Z | 2020-11-13T01:59:30.000Z | gcompiler/delta_infer/custom_grappler/auto_fusion.h | didichuxing/delta | 31dfebc8f20b7cb282b62f291ff25a87e403cc86 | [
"Apache-2.0"
] | 296 | 2019-07-09T07:35:28.000Z | 2020-11-16T02:27:51.000Z | #ifndef _DELTA_INFER_AUTO_FUSION_H_
#define _DELTA_INFER_AUTO_FUSION_H_
#include "delta_infer/core/scatter_search.h"
#include "delta_infer/custom_grappler/local_optimizer.h"
namespace tensorflow {
namespace grappler {
/// help function to regist grpah pattern for automatic fusion
void RegisterFusionPattern(const std::string& name, const Pattern& graph,
const std::string& hint_op);
class AutoFusion : public LocalOptimizer {
public:
explicit AutoFusion(const string& name) : LocalOptimizer(name) {}
virtual GraphDef* GenOptGraph(const GraphDef* original_graph) final;
};
} /* namespace grappler */
} /* namespace tensorflow */
#endif
| 27 | 73 | 0.755556 |
aeb4713884b140358a5d2efb73a5b2528b4c1963 | 1,458 | h | C | src/ci/ModelItem.h | kay54068/qtc-utilities | e75b2a7a8d8183de2ff1178f06fe79e36838ad17 | [
"MIT"
] | 8 | 2016-08-26T16:54:35.000Z | 2021-07-16T19:48:33.000Z | src/ci/ModelItem.h | kay54068/qtc-utilities | e75b2a7a8d8183de2ff1178f06fe79e36838ad17 | [
"MIT"
] | 1 | 2020-09-08T16:32:53.000Z | 2020-09-10T14:14:56.000Z | src/ci/ModelItem.h | kay54068/qtc-utilities | e75b2a7a8d8183de2ff1178f06fe79e36838ad17 | [
"MIT"
] | 4 | 2018-04-25T22:19:24.000Z | 2020-09-10T14:15:35.000Z | #pragma once
#include <QMetaType>
#include <QVariant>
namespace QtcUtilities {
namespace Internal {
namespace Ci {
class ModelItem {
public:
enum class Decoration {
None, Success, Failure, Running, Skipped, Pending
};
using Data = QVariantList;
explicit ModelItem (ModelItem *parent);
virtual ~ModelItem ();
ModelItem *parent () const;
ModelItem *child (int row) const;
void prependChild (QSharedPointer<ModelItem> child);
void addChild (QSharedPointer<ModelItem> child);
void removeAt (int row);
int row () const;
bool isEmpty () const;
int rowCount () const;
int columnCount () const;
void clear ();
Decoration decoration () const;
void setDecoration (Decoration decoration);
void setData (int column, const QVariant &data);
QVariant data (int column, int role = Qt::DisplayRole) const;
QList<QSharedPointer<ModelItem> > children () const;
int levelInTree (ModelItem *item, int current = 0) const;
protected:
ModelItem *parent_;
Data data_;
Decoration decoration_;
QList<QSharedPointer<ModelItem> > children_;
};
} // namespace Ci
} // namespace Internal
} // namespace QtcUtilities
Q_DECLARE_METATYPE (QtcUtilities::Internal::Ci::ModelItem *)
| 28.588235 | 71 | 0.599451 |
aeb60ea776320c11efc4ae076d85772d853c3acd | 4,274 | h | C | bin/htxd/htxd_option_methods.h | narasimhan-v/HTX | 9f92fe8a07132cef9889e21ac17317b3adbae98e | [
"Apache-2.0"
] | 16 | 2016-04-06T18:47:59.000Z | 2019-07-23T01:31:45.000Z | bin/htxd/htxd_option_methods.h | narasimhan-v/HTX | 9f92fe8a07132cef9889e21ac17317b3adbae98e | [
"Apache-2.0"
] | 53 | 2016-04-06T13:40:33.000Z | 2020-03-02T06:49:14.000Z | bin/htxd/htxd_option_methods.h | narasimhan-v/HTX | 9f92fe8a07132cef9889e21ac17317b3adbae98e | [
"Apache-2.0"
] | 18 | 2016-04-05T19:27:04.000Z | 2022-03-23T14:13:25.000Z | /* IBM_PROLOG_BEGIN_TAG */
/*
* Copyright 2003,2016 IBM International Business Machines Corp.
*
* 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.
*/
/* IBM_PROLOG_END_TAG */
/* @(#)61 1.3 src/htx/usr/lpp/htx/bin/htxd/htxd_option_methods.h, htxd, htxubuntu 9/15/15 20:28:35 */
#ifndef HTXD__OPTION__METHODS__HEADER
#define HTXD__OPTION__METHODS__HEADER
#include <netinet/in.h>
#include <errno.h>
#include "htxd.h"
typedef struct
{
htxd *htxd_instance;
char command_ecg_name[MAX_ECG_NAME_LENGTH];
char command_option_list[MAX_OPTION_LIST_LENGTH];
char error_string[512];
int return_code;
} htxd_option_method_object;
#define OPTION_METHOD_ARGS (char **, htxd_command *)
//typedef int(*ecg_process_function)(char*);
extern void init_option_list(void);
extern int htxd_validate_command_requirements(htxd *, char *);
extern void htxd_init_option_method(htxd_option_method_object *, htxd_command *);
extern int htxd_process_command(char **, htxd_command *);
//int htxd_process_all_active_ecg(ecg_process_function, char *);
extern int htxd_option_method_create_mdt OPTION_METHOD_ARGS;
extern int htxd_option_method_list_mdt OPTION_METHOD_ARGS;
extern int htxd_option_method_run_mdt OPTION_METHOD_ARGS;
extern int htxd_option_method_getactecg OPTION_METHOD_ARGS;
extern int htxd_option_method_shutdown_mdt OPTION_METHOD_ARGS;
extern int htxd_option_method_refresh OPTION_METHOD_ARGS;
extern int htxd_option_method_activate OPTION_METHOD_ARGS;
extern int htxd_option_method_suspend OPTION_METHOD_ARGS;
extern int htxd_option_method_terminate OPTION_METHOD_ARGS;
extern int htxd_option_method_restart OPTION_METHOD_ARGS;
extern int htxd_option_method_coe OPTION_METHOD_ARGS;
extern int htxd_option_method_soe OPTION_METHOD_ARGS;
extern int htxd_option_method_status OPTION_METHOD_ARGS;
extern int htxd_option_method_getstats OPTION_METHOD_ARGS;
extern int htxd_option_method_geterrlog OPTION_METHOD_ARGS;
extern int htxd_option_method_clrerrlog OPTION_METHOD_ARGS;
extern int htxd_option_method_cmd OPTION_METHOD_ARGS;
extern int htxd_option_method_set_eeh OPTION_METHOD_ARGS;
extern int htxd_option_method_set_kdblevel OPTION_METHOD_ARGS;
extern int htxd_option_method_set_hxecom OPTION_METHOD_ARGS;
extern int htxd_option_method_getvpd OPTION_METHOD_ARGS;
extern int htxd_option_method_getecgsum OPTION_METHOD_ARGS;
extern int htxd_option_method_getecglist OPTION_METHOD_ARGS;
extern int htxd_option_method_select_mdt OPTION_METHOD_ARGS;
extern int htxd_option_method_exersetupinfo OPTION_METHOD_ARGS;
extern int htxd_option_method_bootme OPTION_METHOD_ARGS;
extern int htxd_option_method_query OPTION_METHOD_ARGS;
extern int htxd_option_method_screen_2 OPTION_METHOD_ARGS;
extern int htxd_option_method_screen_4 OPTION_METHOD_ARGS;
extern int htxd_option_method_screen_5 OPTION_METHOD_ARGS;
extern int htxd_option_method_get_file OPTION_METHOD_ARGS;
extern int htxd_option_method_get_daemon_state OPTION_METHOD_ARGS;
extern int htxd_option_method_coe_soe OPTION_METHOD_ARGS;
extern int htxd_option_method_activate_halt OPTION_METHOD_ARGS;
extern int htxd_option_method_device_count OPTION_METHOD_ARGS;
extern int htxd_option_method_test_activate_halt OPTION_METHOD_ARGS;
extern int htxd_option_method_config_net OPTION_METHOD_ARGS;
extern int htxd_option_method_append_net_mdt OPTION_METHOD_ARGS;
extern int htxd_option_method_test_net OPTION_METHOD_ARGS;
extern int htxd_option_method_set_htx_env OPTION_METHOD_ARGS;
extern int htxd_option_method_get_htx_env OPTION_METHOD_ARGS;
extern int htxd_option_method_get_run_time OPTION_METHOD_ARGS;
extern int htxd_option_method_get_last_update_time OPTION_METHOD_ARGS;
extern int htxd_option_method_get_fail_status OPTION_METHOD_ARGS;
extern int htxd_option_method_get_dev_cycles OPTION_METHOD_ARGS;
#endif
| 43.612245 | 102 | 0.862424 |
aeb65a7e2e30dbe22abd7720a8793943f8cac6c0 | 5,926 | h | C | headers/synthetic.h | KOLANICH/FastPFor | 978d4e24ed0caaa9d37e44cbde276e0c170909d5 | [
"Apache-2.0"
] | 1,006 | 2016-06-29T14:53:54.000Z | 2022-03-05T16:02:07.000Z | headers/synthetic.h | KOLANICH/FastPFor | 978d4e24ed0caaa9d37e44cbde276e0c170909d5 | [
"Apache-2.0"
] | 64 | 2015-01-06T14:25:21.000Z | 2022-02-05T00:53:43.000Z | headers/synthetic.h | KOLANICH/FastPFor | 978d4e24ed0caaa9d37e44cbde276e0c170909d5 | [
"Apache-2.0"
] | 110 | 2015-01-31T05:24:32.000Z | 2022-02-02T16:32:09.000Z | /**
* This code is released under the
* Apache License Version 2.0 http://www.apache.org/licenses/.
*/
#ifndef SYNTHETICDATA_H_
#define SYNTHETICDATA_H_
#include <vector>
#include <set>
#include "common.h"
#include "util.h"
#include "mersenne.h"
#include "memutil.h"
namespace FastPForLib {
std::vector<uint32_t, cacheallocator>
generateArray(uint32_t N, const uint32_t mask = 0xFFFFFFFFU) {
std::vector<uint32_t, cacheallocator> ans(N);
for (size_t k = 0; k < N; ++k)
ans[k] = rand() & mask;
return ans;
}
std::vector<uint32_t, cacheallocator>
generateArray32(uint32_t N, const uint32_t mask = 0xFFFFFFFFU) {
std::vector<uint32_t, cacheallocator> ans(N);
for (size_t k = 0; k < N; ++k)
ans[k] = rand() & mask;
return ans;
}
class UniformDataGenerator {
public:
UniformDataGenerator(uint32_t seed = static_cast<uint32_t>(time(NULL)))
: rand(seed) {}
/**
* fill the vector with N numbers uniformly picked from from 0 to Max, not
* including Max
* if it is not possible, an exception is thrown
*/
std::vector<uint32_t, cacheallocator> generateUniform(uint32_t N,
uint32_t Max) {
if (Max < N)
throw std::runtime_error(
"can't generate enough distinct elements in small interval");
std::vector<uint32_t, cacheallocator> ans;
if (N == 0)
return ans; // nothing to do
ans.reserve(N);
assert(Max >= 1);
if (2 * N > Max) {
std::set<uint32_t> s;
while (s.size() < Max - N)
s.insert(rand.getValue(Max - 1));
s.insert(Max);
ans.resize(N);
uint32_t i = 0;
size_t c = 0;
for (uint32_t v : s) {
for (; i < v; ++i)
ans[c++] = i;
++i;
}
assert(c == ans.size());
} else {
std::set<uint32_t> s;
while (s.size() < N)
s.insert(rand.getValue(Max - 1));
ans.assign(s.begin(), s.end());
assert(N == ans.size());
}
return ans;
}
ZRandom rand;
};
/*
* Reference: Vo Ngoc Anh and Alistair Moffat. 2010. Index compression using
* 64-bit words. Softw. Pract. Exper.40, 2 (February 2010), 131-147.
*/
class ClusteredDataGenerator {
public:
UniformDataGenerator unidg;
ClusteredDataGenerator(uint32_t seed = static_cast<uint32_t>(time(NULL)))
: unidg(seed) {}
// Max value is excluded from range
template <class iterator>
void fillUniform(iterator begin, iterator end, uint32_t Min, uint32_t Max) {
std::vector<uint32_t, cacheallocator> v =
unidg.generateUniform(static_cast<uint32_t>(end - begin), Max - Min);
for (size_t k = 0; k < v.size(); ++k)
*(begin + k) = Min + v[k];
}
// Max value is excluded from range
// throws exception if impossible
template <class iterator>
void fillClustered(iterator begin, iterator end, uint32_t Min, uint32_t Max) {
const uint32_t N = static_cast<uint32_t>(end - begin);
const uint32_t range = Max - Min;
if (range < N)
throw std::runtime_error("can't generate that many in small interval.");
assert(range >= N);
if ((range == N) || (N < 10)) {
fillUniform(begin, end, Min, Max);
return;
}
const uint32_t cut = N / 2 + unidg.rand.getValue(range - N);
assert(cut >= N / 2);
assert(Max - Min - cut >= N - N / 2);
const double p = unidg.rand.getDouble();
assert(p <= 1);
assert(p >= 0);
if (p <= 0.25) {
fillUniform(begin, begin + N / 2, Min, Min + cut);
fillClustered(begin + N / 2, end, Min + cut, Max);
} else if (p <= 0.5) {
fillClustered(begin, begin + N / 2, Min, Min + cut);
fillUniform(begin + N / 2, end, Min + cut, Max);
} else {
fillClustered(begin, begin + N / 2, Min, Min + cut);
fillClustered(begin + N / 2, end, Min + cut, Max);
}
}
// Max value is excluded from range
std::vector<uint32_t, cacheallocator> generateClustered(uint32_t N,
uint32_t Max) {
std::vector<uint32_t, cacheallocator> ans(N);
fillClustered(ans.begin(), ans.end(), 0, Max);
return ans;
}
};
class ZipfianGenerator {
public:
uint32_t n;
double zetan, theta;
std::vector<double> proba;
ZRandom rand;
ZipfianGenerator(uint32_t seed = static_cast<uint32_t>(time(NULL)))
: n(0), zetan(0), theta(0), proba(n), rand(seed) {}
void init(int _items, double _zipfianconstant = 1.0) {
n = _items;
if (_items == 0)
throw std::runtime_error("no items?");
theta = _zipfianconstant;
if (theta > 0) {
zetan = 1 / zeta(n, theta);
proba.clear();
proba.resize(n, 0);
proba[0] = zetan;
for (uint32_t i = 1; i < n; ++i)
proba[i] = proba[i - 1] + zetan / pow(i + 1, theta);
} else {
proba.resize(n, 1.0 / n);
}
}
void seed(uint32_t s) { rand.seed(s); }
ZipfianGenerator(int _items, double _zipfianconstant,
uint32_t seed = static_cast<uint32_t>(time(NULL)))
: n(_items), zetan(0), theta(_zipfianconstant), proba(n), rand(seed) {
init(_items, _zipfianconstant);
}
double zeta(int n, double theta) {
double sum = 0;
for (long i = 0; i < n; i++) {
sum += 1.0 / (pow(static_cast<double>(i + 1), theta));
}
return sum;
}
int nextInt() {
// Map z to the value
const double u = rand.getDouble();
return static_cast<int>(lower_bound(proba.begin(), proba.end(), u) -
proba.begin());
}
};
std::vector<uint32_t, cacheallocator>
generateZipfianArray32(uint32_t N, double power,
const uint32_t mask = 0xFFFFFFFFU) {
std::vector<uint32_t, cacheallocator> ans(N);
ZipfianGenerator zipf;
const uint32_t MAXVALUE = 1U << 22;
zipf.init(mask > MAXVALUE - 1 ? MAXVALUE : mask + 1, power);
for (size_t k = 0; k < N; ++k)
ans[k] = zipf.nextInt();
return ans;
}
} // namespace FastPFor
#endif
| 29.04902 | 80 | 0.593824 |
aeb7cc1c20be97a8dde9d37c65d27237c5417265 | 350 | c | C | install_dependencies/xianyi-OpenBLAS-6d2da63/driver/level2/CMakeFiles/ztpsv_CUN.c | lanl/DnMFkCPP | a6bca290bf7d57be07f7a80d049d6b7714fbdc61 | [
"BSD-3-Clause",
"Unlicense"
] | 1 | 2021-07-29T21:56:02.000Z | 2021-07-29T21:56:02.000Z | install_dependencies/xianyi-OpenBLAS-6d2da63/driver/level2/CMakeFiles/ztpsv_CUN.c | rvangara/DnMFk | a6bca290bf7d57be07f7a80d049d6b7714fbdc61 | [
"BSD-3-Clause",
"Unlicense"
] | null | null | null | install_dependencies/xianyi-OpenBLAS-6d2da63/driver/level2/CMakeFiles/ztpsv_CUN.c | rvangara/DnMFk | a6bca290bf7d57be07f7a80d049d6b7714fbdc61 | [
"BSD-3-Clause",
"Unlicense"
] | 2 | 2021-07-29T21:55:33.000Z | 2021-08-02T21:30:15.000Z | #define TRANSA 4
#define ASMNAME ztpsv_CUN
#define ASMFNAME ztpsv_CUN_
#define NAME ztpsv_CUN_
#define CNAME ztpsv_CUN
#define CHAR_NAME "ztpsv_CUN_"
#define CHAR_CNAME "ztpsv_CUN"
#define DOUBLE
#define COMPLEX
#include "/lustre/scratch3/turquoise/rvangara/RD100/distnnmfkcpp_Src/install_dependencies/xianyi-OpenBLAS-6d2da63/driver/level2/ztpsv_L.c" | 35 | 138 | 0.84 |
aeb80cbde430ebf16746277435993cba2c666642 | 29,137 | c | C | provisioning_client/src/secure_device_tpm.c | nsadula/azure-iot-sdk-c | 5847d861fd9b27e0c07225490d06cee1230596bc | [
"MIT"
] | 545 | 2016-11-29T18:04:48.000Z | 2022-03-28T09:31:06.000Z | provisioning_client/src/secure_device_tpm.c | nsadula/azure-iot-sdk-c | 5847d861fd9b27e0c07225490d06cee1230596bc | [
"MIT"
] | 1,644 | 2016-11-17T09:49:31.000Z | 2022-03-30T18:10:13.000Z | provisioning_client/src/secure_device_tpm.c | nsadula/azure-iot-sdk-c | 5847d861fd9b27e0c07225490d06cee1230596bc | [
"MIT"
] | 826 | 2016-11-16T16:05:16.000Z | 2022-03-18T19:23:22.000Z | // Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
#include <stdlib.h>
#include <stdbool.h>
#include "umock_c/umock_c_prod.h"
#include "azure_c_shared_utility/gballoc.h"
#include "azure_c_shared_utility/sastoken.h"
#include "azure_c_shared_utility/azure_base64.h"
#include "azure_c_shared_utility/sha.h"
#include "azure_c_shared_utility/urlencode.h"
#include "azure_c_shared_utility/strings.h"
#include "azure_c_shared_utility/xlogging.h"
#include "azure_c_shared_utility/crt_abstractions.h"
#include "azure_c_shared_utility/buffer_.h"
#include "azure_hub_modules/secure_device_factory.h"
#include "azure_hub_modules/secure_device_tpm.h"
#if 0
#include "azure_utpm_c/tpm_comm.h"
#include "azure_utpm_c/tpm_codec.h"
#include "azure_utpm_c/Marshal_fp.h" // for activation blob unmarshaling
#define EPOCH_TIME_T_VALUE 0
#define HMAC_LENGTH 32
static TPM2B_AUTH NullAuth = { 0 };
static TSS_SESSION NullPwSession;
static const UINT32 TPM_20_SRK_HANDLE = HR_PERSISTENT | 0x00000001;
static const UINT32 TPM_20_EK_HANDLE = HR_PERSISTENT | 0x00010001;
static const UINT32 DRS_ID_KEY_HANDLE = HR_PERSISTENT | 0x00000100;
typedef struct SEC_DEVICE_INFO_TAG
{
TPM_HANDLE tpm_handle;
TSS_DEVICE tpm_device;
TPM2B_PUBLIC ek_pub;
TPM2B_PUBLIC srk_pub;
TPM2B_PUBLIC id_key_public;
TPM2B_PRIVATE id_key_dup_blob;
TPM2B_PRIVATE id_key_priv;
} SEC_DEVICE_INFO;
static const SEC_TPM_INTERFACE sec_tpm_interface =
{
secure_dev_tpm_create,
secure_dev_tpm_destroy,
secure_dev_tpm_import_key,
secure_dev_tpm_get_endorsement_key,
secure_dev_tpm_get_storage_key,
secure_dev_tpm_sign_data,
secure_dev_tpm_decrypt_data
};
static TPMS_RSA_PARMS RsaStorageParams = {
{ TPM_ALG_AES, 128, TPM_ALG_CFB }, // TPMT_SYM_DEF_OBJECT symmetric
{ TPM_ALG_NULL }, // TPMT_RSA_SCHEME scheme
2048, // TPMI_RSA_KEY_BITS keyBits
0 // UINT32 exponent
};
static TPM2B_PUBLIC* GetEkTemplate ()
{
static TPM2B_PUBLIC EkTemplate = { 0, // size will be computed during marshaling
{
TPM_ALG_RSA, // TPMI_ALG_PUBLIC type
TPM_ALG_SHA256, // TPMI_ALG_HASH nameAlg
{ 0 }, // TPMA_OBJECT objectAttributes (set below)
{32,
{ 0x83, 0x71, 0x97, 0x67, 0x44, 0x84, 0xb3, 0xf8,
0x1a, 0x90, 0xcc, 0x8d, 0x46, 0xa5, 0xd7, 0x24,
0xfd, 0x52, 0xd7, 0x6e, 0x06, 0x52, 0x0b, 0x64,
0xf2, 0xa1, 0xda, 0x1b, 0x33, 0x14, 0x69, 0xaa }
}, // TPM2B_DIGEST authPolicy
{ 0 }, // TPMU_PUBLIC_PARMS parameters (set below)
{ 0 } // TPMU_PUBLIC_ID unique
} };
EkTemplate.publicArea.objectAttributes = ToTpmaObject(
Restricted | Decrypt | FixedTPM | FixedParent | AdminWithPolicy | SensitiveDataOrigin);
EkTemplate.publicArea.parameters.rsaDetail = RsaStorageParams;
return &EkTemplate;
}
static TPM2B_PUBLIC* GetSrkTemplate()
{
static TPM2B_PUBLIC SrkTemplate = { 0, // size will be computed during marshaling
{
TPM_ALG_RSA, // TPMI_ALG_PUBLIC type
TPM_ALG_SHA256, // TPMI_ALG_HASH nameAlg
{ 0 }, // TPMA_OBJECT objectAttributes (set below)
{ 0 }, // TPM2B_DIGEST authPolicy
{ 0 }, // TPMU_PUBLIC_PARMS parameters (set before use)
{ 0 } // TPMU_PUBLIC_ID unique
} };
SrkTemplate.publicArea.objectAttributes = ToTpmaObject(
Restricted | Decrypt | FixedTPM | FixedParent | NoDA | UserWithAuth | SensitiveDataOrigin);
SrkTemplate.publicArea.parameters.rsaDetail = RsaStorageParams;
return &SrkTemplate;
}
#define DRS_UNMARSHAL(Type, pValue) \
{ \
TPM_RC rc = Type##_Unmarshal(pValue, &curr_pos, (INT32*)&act_size); \
if (rc != TPM_RC_SUCCESS) \
{ \
LogError(#Type"_Unmarshal() for " #pValue " failed"); \
} \
}
#define DRS_UNMARSHAL_FLAGGED(Type, pValue) \
{ \
TPM_RC rc = Type##_Unmarshal(pValue, &curr_pos, (INT32*)&act_size, TRUE); \
if (rc != TPM_RC_SUCCESS) \
{ \
LogError(#Type"_Unmarshal() for " #pValue " failed"); \
} \
}
#define DRS_UNMARSHAL_ARRAY(dstPtr, arrSize) \
DRS_UNMARSHAL(UINT32, &(arrSize)); \
printf("act_size %d < actSize %d\r\n", act_size, arrSize); \
if (act_size < arrSize) \
{ \
LogError("Unmarshaling " #dstPtr " failed: Need %d bytes, while only %d left", arrSize, act_size); \
result = MU_FAILURE; \
} \
else \
{ \
dstPtr = curr_pos - sizeof(UINT16); \
*(UINT16*)dstPtr = (UINT16)arrSize; \
curr_pos += arrSize; \
}
static int dps_umarshal_array(unsigned char* dst_ptr, uint32_t dest_size, unsigned char* act_buff, uint32_t act_size)
{
int result;
uint8_t* curr_pos = act_buff;
DRS_UNMARSHAL(UINT32, &(dest_size));
if (act_size < dest_size)
{
LogError("Unmarshaling failed: Need %d bytes, while only %d left", dest_size, act_size);
result = __LINE__;
}
else
{
dst_ptr = act_buff - sizeof(UINT16);
*(UINT16*)dst_ptr = (UINT16)dest_size;
act_buff += dest_size;
result = 0;
}
return result;
}
static int unmarshal_array(uint8_t* dstptr, uint32_t size, uint8_t** curr_pos, uint32_t* curr_size)
{
int result;
TPM_RC tpm_res = UINT32_Unmarshal((uint32_t*)dstptr, curr_pos, (int32_t*)curr_size);
if (tpm_res != TPM_RC_SUCCESS)
{
LogError("Failure: unmarshalling array.");
result = MU_FAILURE;
}
else if (*curr_size < size)
{
LogError("Failure: unmarshalling array need %d bytes, while only %d left.", size, *curr_size);
result = MU_FAILURE;
}
else
{
dstptr = *curr_pos - sizeof(UINT16);
*(UINT16*)dstptr = (UINT16)size;
curr_pos += size;
result = 0;
}
return result;
}
static int marshal_array_values(const unsigned char* key, size_t key_len, uint8_t** decrypt_blob, uint8_t** decrypt_secret, uint8_t** decrypt_wrap_key, TPM2B_PRIVATE* enc_key_blob)
{
int result = 0;
uint8_t* curr_pos = (uint8_t*)key;
uint32_t act_size = (int32_t)key_len;
uint32_t decrypt_size = 0;
uint32_t decrypt_secret_size = 0;
uint32_t decrypt_key_size = 0;
TPM2B_PUBLIC id_key_Public = { TPM_ALG_NULL };
UINT16 gratuitousSizeField; // WORKAROUND for the current protocol
DRS_UNMARSHAL_ARRAY(*decrypt_blob, decrypt_size);
if (result != 0)
{
LogError("Failure: decrypting blob");
}
else
{
DRS_UNMARSHAL_ARRAY(*decrypt_secret, decrypt_secret_size);
if (result != 0)
{
LogError("Failure: decrypting secret");
}
else
{
DRS_UNMARSHAL_ARRAY(*decrypt_wrap_key, decrypt_key_size);
if (result != 0)
{
LogError("Failure: decrypting wrap secret");
}
else
{
DRS_UNMARSHAL_FLAGGED(TPM2B_PUBLIC, &id_key_Public);
if (result != 0)
{
LogError("Failure: id key public");
}
else
{
DRS_UNMARSHAL(UINT16, &gratuitousSizeField);
if (result != 0)
{
LogError("Failure: gratuitousSizeField");
}
else
{
DRS_UNMARSHAL(TPM2B_PRIVATE, enc_key_blob);
if (result != 0)
{
LogError("Failure: enc key blob");
}
}
}
}
}
}
return result;
}
static int create_tpm_session(SEC_DEVICE_INFO* sec_info, TSS_SESSION* tpm_session)
{
int result;
TPMA_SESSION sess_attrib = { 1 };
if (TSS_StartAuthSession(&sec_info->tpm_device, TPM_SE_POLICY, TPM_ALG_SHA256, sess_attrib, tpm_session) != TPM_RC_SUCCESS)
{
LogError("Failure: Starting EK policy session");
result = MU_FAILURE;
}
else if (TSS_PolicySecret(&sec_info->tpm_device, &NullPwSession, TPM_RH_ENDORSEMENT, tpm_session, NULL, 0) != TPM_RC_SUCCESS)
{
LogError("Failure: PolicySecret() for EK");
result = MU_FAILURE;
}
else
{
result = 0;
}
return result;
}
static int insert_key_in_tpm(SEC_DEVICE_INFO* sec_info, const unsigned char* key, size_t key_len)
{
int result;
TSS_SESSION ek_sess = { { TPM_RH_NULL } };
if (create_tpm_session(sec_info, &ek_sess) != 0)
{
LogError("Failure: Starting EK policy session");
result = MU_FAILURE;
}
else
{
TPMT_SYM_DEF_OBJECT Aes128SymDef = { TPM_ALG_AES, 128, TPM_ALG_CFB };
TPM2B_ID_OBJECT enc_key_blob;
TPM2B_ENCRYPTED_SECRET tpm_enc_secret;
TPM2B_PRIVATE id_key_dup_blob;
TPM2B_ENCRYPTED_SECRET encrypt_wrap_key;
TPM2B_PUBLIC id_key_Public = { TPM_ALG_NULL };
UINT16 enc_data_size = 0;
TPM2B_DIGEST inner_wrap_key = { 0 };
TPM2B_PRIVATE id_key_priv;
TPM_HANDLE load_id_key = TPM_ALG_NULL;
uint8_t* curr_pos = (uint8_t*)key;
uint32_t act_size = (int32_t)key_len;
DRS_UNMARSHAL(TPM2B_ID_OBJECT, &enc_key_blob);
DRS_UNMARSHAL(TPM2B_ENCRYPTED_SECRET, &tpm_enc_secret);
DRS_UNMARSHAL(TPM2B_PRIVATE, &id_key_dup_blob);
DRS_UNMARSHAL(TPM2B_ENCRYPTED_SECRET, &encrypt_wrap_key);
DRS_UNMARSHAL_FLAGGED(TPM2B_PUBLIC, &id_key_Public);
// The given TPM may support larger TPM2B_MAX_BUFFER than this API headers define.
// So instead of unmarshaling data in a standalone data structure just reuse the
// original activation buffer (after updating byte order of the UINT16 counter)
DRS_UNMARSHAL(UINT16, &enc_data_size);
if (TPM2_ActivateCredential(&sec_info->tpm_device, &NullPwSession, &ek_sess, TPM_20_SRK_HANDLE, TPM_20_EK_HANDLE,
&enc_key_blob, &tpm_enc_secret, &inner_wrap_key) != TPM_RC_SUCCESS)
{
LogError("Failure: TPM2_ActivateCredential");
result = MU_FAILURE;
}
else if (TPM2_Import(&sec_info->tpm_device, &NullPwSession, TPM_20_SRK_HANDLE, (TPM2B_DATA*)&inner_wrap_key, &id_key_Public, &id_key_dup_blob, &encrypt_wrap_key, &Aes128SymDef, &id_key_priv) != TPM_RC_SUCCESS)
{
LogError("Failure: importing dps Id key");
result = MU_FAILURE;
}
else
{
TPM2B_SENSITIVE_CREATE sen_create = { 0 };
TPM2B_PUBLIC sym_pub = { 0 };
TPM2B_PRIVATE sym_priv = { 0 };
static TPM2B_PUBLIC symTemplate = { 0, // size will be computed during marshaling
{
TPM_ALG_SYMCIPHER, // TPMI_ALG_PUBLIC type
TPM_ALG_SHA256, // TPMI_ALG_HASH nameAlg
{ 0 }, // TPMA_OBJECT objectAttributes (set below)
{ 0 }, // TPM2B_DIGEST authPolicy
{ 0 }, // TPMU_PUBLIC_PARMS parameters (set below)
{ 0 } // TPMU_PUBLIC_ID unique
} };
symTemplate.publicArea.objectAttributes = ToTpmaObject(Decrypt | FixedTPM | FixedParent | UserWithAuth);
symTemplate.publicArea.parameters.symDetail.sym.algorithm = TPM_ALG_AES;
symTemplate.publicArea.parameters.symDetail.sym.keyBits.sym = inner_wrap_key.t.size * 8;
symTemplate.publicArea.parameters.symDetail.sym.mode.sym = TPM_ALG_CFB;
memcpy(sen_create.sensitive.data.t.buffer, inner_wrap_key.t.buffer, inner_wrap_key.t.size);
sen_create.sensitive.data.t.size = inner_wrap_key.t.size;
if (TSS_Create(&sec_info->tpm_device, &NullPwSession, TPM_20_SRK_HANDLE, &sen_create, &symTemplate, &sym_priv, &sym_pub) != TPM_RC_SUCCESS)
{
LogError("Failed to inject symmetric key data");
result = MU_FAILURE;
}
else if (TPM2_Load(&sec_info->tpm_device, &NullPwSession, TPM_20_SRK_HANDLE, &id_key_priv, &id_key_Public, &load_id_key, NULL) != TPM_RC_SUCCESS)
{
LogError("Failed Load Id key.");
result = MU_FAILURE;
}
else
{
// Remove old Id key
(void)TPM2_EvictControl(&sec_info->tpm_device, &NullPwSession, TPM_RH_OWNER, DRS_ID_KEY_HANDLE, DRS_ID_KEY_HANDLE);
if (TPM2_EvictControl(&sec_info->tpm_device, &NullPwSession, TPM_RH_OWNER, load_id_key, DRS_ID_KEY_HANDLE) != TPM_RC_SUCCESS)
{
LogError("Failed Load Id key.");
result = MU_FAILURE;
}
else if (TPM2_FlushContext(&sec_info->tpm_device, load_id_key) != TPM_RC_SUCCESS)
{
LogError("Failed Load Id key.");
result = MU_FAILURE;
}
else
{
result = 0;
}
}
}
}
return result;
}
static BUFFER_HANDLE decrypt_data(SEC_DEVICE_INFO* sec_info, const unsigned char* key, size_t key_len)
{
BUFFER_HANDLE result;
TSS_SESSION ek_sess = { { TPM_RH_NULL } };
UINT32 max_tpm_data_size;
if (create_tpm_session(sec_info, &ek_sess) != 0)
{
LogError("Failure: Starting EK policy session");
result = NULL;
}
else if ((max_tpm_data_size = TSS_GetTpmProperty(&sec_info->tpm_device, TPM_PT_INPUT_BUFFER)) == 0)
{
LogError("Failure: TSS_GetTpmProperty Input buffer");
result = NULL;
}
else
{
TPM2B_ID_OBJECT tpm_blob;
TPM2B_ENCRYPTED_SECRET tpm_enc_secret;
TPM2B_ENCRYPTED_SECRET tpm_enc_key;
TPM2B_PRIVATE id_key_dup_blob;
UINT16 enc_data_size = 0;
TPM2B_PUBLIC id_key_Public = { TPM_ALG_NULL };
TPM2B_MAX_BUFFER* target_data = NULL;
TPM2B_DIGEST inner_wrap_key = { 0 };
uint8_t* curr_pos = (uint8_t*)key;
uint32_t act_size = (int32_t)key_len;
DRS_UNMARSHAL(TPM2B_ID_OBJECT, &tpm_blob);
DRS_UNMARSHAL(TPM2B_ENCRYPTED_SECRET, &tpm_enc_secret);
DRS_UNMARSHAL(TPM2B_PRIVATE, &id_key_dup_blob);
DRS_UNMARSHAL(TPM2B_ENCRYPTED_SECRET, &tpm_enc_key);
DRS_UNMARSHAL_FLAGGED(TPM2B_PUBLIC, &id_key_Public);
// The given TPM may support larger TPM2B_MAX_BUFFER than this API headers define.
// So instead of unmarshaling data in a standalone data structure just reuse the
// original activation buffer (after updating byte order of the UINT16 counter)
DRS_UNMARSHAL(UINT16, &enc_data_size);
if (enc_data_size > max_tpm_data_size)
{
LogError("Failure: The encrypted data len (%zu) is too long for tpm", enc_data_size);
result = NULL;
}
else
{
target_data = (TPM2B_MAX_BUFFER*)(curr_pos - sizeof(UINT16));
target_data->t.size = enc_data_size;
// Update local vars in case activation blob contains more data to unmarshal
curr_pos += enc_data_size;
act_size -= enc_data_size;
// decrypts encrypted symmetric key ?encSecret? and returns it as 'tpm_blob'.
// Later 'tpm_blob' is used as the inner wrapper key for import of the HMAC key blob.
if (TPM2_ActivateCredential(&sec_info->tpm_device, &NullPwSession, &ek_sess, TPM_20_SRK_HANDLE, TPM_20_EK_HANDLE, &tpm_blob, &tpm_enc_secret, &inner_wrap_key) != TPM_RC_SUCCESS)
{
LogError("Failure: TPM2_ActivateCredential");
result = NULL;
}
else
{
result = BUFFER_create(tpm_blob.t.credential, tpm_blob.t.size);
if (result == NULL)
{
LogError("Failure building buffer");
result = NULL;
}
}
}
}
return result;
}
static int create_persistent_key(SEC_DEVICE_INFO* tpm_info, TPM_HANDLE request_handle, TPMI_DH_OBJECT hierarchy, TPM2B_PUBLIC* inPub, TPM2B_PUBLIC* outPub)
{
int result;
TPM_RC tpm_result;
TPM2B_NAME name;
TPM2B_NAME qName;
tpm_result = TPM2_ReadPublic(&tpm_info->tpm_device, request_handle, outPub, &name, &qName);
if (tpm_result == TPM_RC_SUCCESS)
{
tpm_info->tpm_handle = request_handle;
result = 0;
}
else if (tpm_result != TPM_RC_HANDLE)
{
LogError("Failed calling TPM2_ReadPublic 0%x", tpm_result);
result = MU_FAILURE;
}
else
{
if (TSS_CreatePrimary(&tpm_info->tpm_device, &NullPwSession, hierarchy, inPub, &tpm_info->tpm_handle, outPub) != TPM_RC_SUCCESS)
{
LogError("Failed calling TSS_CreatePrimary");
result = MU_FAILURE;
}
else
{
if (TPM2_EvictControl(&tpm_info->tpm_device, &NullPwSession, TPM_RH_OWNER, tpm_info->tpm_handle, request_handle) != TPM_RC_SUCCESS)
{
LogError("Failed calling TSS_CreatePrimary");
result = MU_FAILURE;
}
else if (TPM2_FlushContext(&tpm_info->tpm_device, tpm_info->tpm_handle) != TPM_RC_SUCCESS)
{
LogError("Failed calling TSS_CreatePrimary");
result = MU_FAILURE;
}
else
{
tpm_info->tpm_handle = request_handle;
result = 0;
}
}
}
return result;
}
static int initialize_tpm_device(SEC_DEVICE_INFO* tpm_info)
{
int result;
if (TSS_CreatePwAuthSession(&NullAuth, &NullPwSession) != TPM_RC_SUCCESS)
{
LogError("Failure calling TSS_CreatePwAuthSession");
result = MU_FAILURE;
}
else if (Initialize_TPM_Codec(&tpm_info->tpm_device) != TPM_RC_SUCCESS)
{
LogError("Failure initializeing TPM Codec");
result = MU_FAILURE;
}
/* Codes_secure_dev_tpm_create shall get a handle to the Endorsement Key and Storage Root Key.*/
else if (create_persistent_key(tpm_info, TPM_20_EK_HANDLE, TPM_RH_ENDORSEMENT, GetEkTemplate(), &tpm_info->ek_pub) != 0)
{
LogError("Failure calling creating persistent key for Endorsement key");
result = MU_FAILURE;
}
/* Codes_secure_dev_tpm_create shall get a handle to the Endorsement Key and Storage Root Key.*/
else if (create_persistent_key(tpm_info, TPM_20_SRK_HANDLE, TPM_RH_OWNER, GetSrkTemplate(), &tpm_info->srk_pub) != 0)
{
LogError("Failure calling creating persistent key for Storage Root key");
result = MU_FAILURE;
}
else
{
result = 0;
}
return result;
}
SEC_DEVICE_HANDLE secure_dev_tpm_create()
{
SEC_DEVICE_INFO* result;
/* Codes_SRS_SECURE_DEVICE_TPM_07_002: [ On success secure_dev_tpm_create shall allocate a new instance of the secure device tpm interface. ] */
result = malloc(sizeof(SEC_DEVICE_INFO) );
if (result == NULL)
{
/* Codes_SRS_SECURE_DEVICE_TPM_07_001: [ If any failure is encountered secure_dev_tpm_create shall return NULL ] */
LogError("Failure: malloc SEC_DEVICE_INFO.");
}
else
{
memset(result, 0, sizeof(SEC_DEVICE_INFO));
/* Codes_secure_dev_tpm_create shall call into the tpm_codec to initialize a TSS session.*/
if (initialize_tpm_device(result) != 0)
{
/* Codes_SRS_SECURE_DEVICE_TPM_07_001: [ If any failure is encountered secure_dev_tpm_create shall return NULL ] */
LogError("Failure initializing tpm device.");
free(result);
result = NULL;
}
}
return (SEC_DEVICE_HANDLE)result;
}
void secure_dev_tpm_destroy(SEC_DEVICE_HANDLE handle)
{
/* Codes_SRS_SECURE_DEVICE_TPM_07_005: [ if handle is NULL, secure_dev_tpm_destroy shall do nothing. ] */
if (handle != NULL)
{
/* Codes_SRS_SECURE_DEVICE_TPM_07_004: [ secure_dev_tpm_destroy shall free the SEC_DEVICE_INFO instance. ] */
Deinit_TPM_Codec(&handle->tpm_device);
/* Codes_SRS_SECURE_DEVICE_TPM_07_006: [ secure_dev_tpm_destroy shall free all resources allocated in this module. ]*/
free(handle);
}
}
int secure_dev_tpm_import_key(SEC_DEVICE_HANDLE handle, const unsigned char* key, size_t key_len)
{
int result;
if (handle == NULL || key == NULL || key_len == 0)
{
/* Codes_SRS_SECURE_DEVICE_TPM_07_007: [ if handle or key are NULL, or key_len is 0 secure_dev_tpm_import_key shall return a non-zero value ] */
LogError("Invalid argument specified handle: %p, key: %p, key_len: %zu", handle, key, key_len);
result = MU_FAILURE;
}
else
{
/* Codes_secure_dev_tpm_import_key shall establish a tpm session in preparation to inserting the key into the tpm. */
if (insert_key_in_tpm(handle, key, key_len))
{
LogError("Failure inserting key into tpm");
result = MU_FAILURE;
}
else
{
/* Codes_SRS_SECURE_DEVICE_TPM_07_008: [ On success secure_dev_tpm_import_key shall return zero ] */
result = 0;
}
}
return result;
}
char* secure_dev_tpm_get_endorsement_key(SEC_DEVICE_HANDLE handle)
{
char* result;
if (handle == NULL)
{
/* Codes_SRS_SECURE_DEVICE_TPM_07_013: [ If handle is NULL secure_dev_tpm_get_endorsement_key shall return NULL. ] */
LogError("Invalid handle value specified");
result = NULL;
}
else if (handle->ek_pub.publicArea.unique.rsa.t.size == 0)
{
/* Codes_SRS_SECURE_DEVICE_TPM_07_027: [ If the ek_public was not initialized secure_dev_tpm_get_endorsement_key shall return NULL. ] */
LogError("Endorsement key is invalid");
result = NULL;
}
else
{
unsigned char data_bytes[1024];
unsigned char* data_pos = data_bytes;
/* Codes_SRS_SECURE_DEVICE_TPM_07_014: [ secure_dev_tpm_get_endorsement_key shall allocate and return the Endorsement Key. ] */
uint32_t data_length = TPM2B_PUBLIC_Marshal(&handle->ek_pub, &data_pos, NULL);
STRING_HANDLE encoded_ek = Azure_Base64_Encode_Bytes(data_bytes, data_length);
if (encoded_ek == NULL)
{
/* Codes_SRS_SECURE_DEVICE_TPM_07_015: [ If a failure is encountered, secure_dev_tpm_get_endorsement_key shall return NULL. ] */
LogError("Failure encoding endorsement key");
result = NULL;
}
else
{
if (mallocAndStrcpy_s(&result, STRING_c_str(encoded_ek)) != 0)
{
/* Codes_SRS_SECURE_DEVICE_TPM_07_015: [ If a failure is encountered, secure_dev_tpm_get_endorsement_key shall return NULL. ] */
LogError("Failure allocating endorsement key");
result = NULL;
}
STRING_delete(encoded_ek);
}
}
return result;
}
char* secure_dev_tpm_get_storage_key(SEC_DEVICE_HANDLE handle)
{
char* result;
if (handle == NULL)
{
/* Codes_SRS_SECURE_DEVICE_TPM_07_016: [ If handle is NULL, secure_dev_tpm_get_storage_key shall return NULL. ] */
LogError("Invalid handle value specified");
result = NULL;
}
else if (handle->srk_pub.publicArea.unique.rsa.t.size == 0)
{
/* Codes_SRS_SECURE_DEVICE_TPM_07_017: [ If the srk_public value was not initialized, secure_dev_tpm_get_storage_key shall return NULL. ] */
LogError("storage root key is invalid");
result = NULL;
}
else
{
unsigned char data_bytes[1024];
unsigned char* data_pos = data_bytes;
/* Codes_SRS_SECURE_DEVICE_TPM_07_018: [ secure_dev_tpm_get_storage_key shall allocate and return the Storage Root Key. ] */
uint32_t data_length = TPM2B_PUBLIC_Marshal(&handle->srk_pub, &data_pos, NULL);
STRING_HANDLE encoded_srk = Azure_Base64_Encode_Bytes(data_bytes, data_length);
if (encoded_srk == NULL)
{
/* Codes_SRS_SECURE_DEVICE_TPM_07_019: [ If any failure is encountered, secure_dev_tpm_get_storage_key shall return NULL. ] */
LogError("Failure encoding storage root key");
result = NULL;
}
else
{
if (mallocAndStrcpy_s(&result, STRING_c_str(encoded_srk)) != 0)
{
/* Codes_SRS_SECURE_DEVICE_TPM_07_019: [ If any failure is encountered, secure_dev_tpm_get_storage_key shall return NULL. ] */
LogError("Failure allocating storage root key");
result = NULL;
}
STRING_delete(encoded_srk);
}
}
return result;
}
BUFFER_HANDLE secure_dev_tpm_sign_data(SEC_DEVICE_HANDLE handle, const unsigned char* data, size_t data_len)
{
BUFFER_HANDLE result;
/* Codes_SRS_SECURE_DEVICE_TPM_07_020: [ If handle or data is NULL or data_len is 0, secure_dev_tpm_sign_data shall return NULL. ] */
if (handle == NULL || data == NULL || data_len == 0)
{
LogError("Invalid handle value specified handle: %p, data: %p", handle, data);
result = NULL;
}
else
{
BYTE data_signature[1024];
BYTE* data_copy = (unsigned char*)data;
/* Codes_SRS_SECURE_DEVICE_TPM_07_021: [ secure_dev_tpm_sign_data shall call into the tpm to hash the supplied data value. ] */
uint32_t sign_len = SignData(&handle->tpm_device, &NullPwSession, data_copy, data_len, data_signature, sizeof(data_signature) );
if (sign_len == 0)
{
/* Codes_SRS_SECURE_DEVICE_TPM_07_023: [ If an error is encountered secure_dev_tpm_sign_data shall return NULL. ] */
LogError("Failure signing data from hash");
result = NULL;
}
else
{
/* Codes_SRS_SECURE_DEVICE_TPM_07_022: [ If hashing the data was successful, secure_dev_tpm_sign_data shall create a BUFFER_HANDLE with the supplied signed data. ] */
result = BUFFER_create(data_signature, sign_len);
if (result == NULL)
{
/* Codes_SRS_SECURE_DEVICE_TPM_07_023: [ If an error is encountered secure_dev_tpm_sign_data shall return NULL. ] */
LogError("Failure allocating sign data");
}
}
}
return result;
}
BUFFER_HANDLE secure_dev_tpm_decrypt_data(SEC_DEVICE_HANDLE handle, const unsigned char* data, size_t data_len)
{
BUFFER_HANDLE result;
/* Codes_SRS_SECURE_DEVICE_TPM_07_025: [ If handle or data is NULL or data_len is 0, secure_dev_tpm_decrypt_data shall return NULL. ] */
if (handle == NULL || data == NULL || data_len == 0)
{
LogError("Invalid handle value specified handle: %p, data: %p, data_len: %zu", handle, data, data_len);
result = NULL;
}
else
{
/* Codes_SRS_SECURE_DEVICE_TPM_07_024: [ secure_dev_tpm_decrypt_data shall call into the tpm to decrypt the supplied data value. ] */
result = decrypt_data(handle, data, data_len);
if (result == NULL)
{
/* Codes_SRS_SECURE_DEVICE_TPM_07_029: [ If an error is encountered secure_dev_tpm_sign_data shall return NULL. ] */
LogError("Failure decrypting data with tpm");
}
}
return result;
}
/* Codes_SRS_SECURE_DEVICE_TPM_07_026: [ secure_dev_tpm_interface shall return the SEC_TPM_INTERFACE structure. ] */
const SEC_TPM_INTERFACE* secure_dev_tpm_interface()
{
return &sec_tpm_interface;
}
| 39.804645 | 217 | 0.604798 |
aeb8227dcf73630700f1aa62bbf0aa1958a33a7c | 740 | c | C | Hardware_wrappers-for_ZEDboard/project_3/project_3.sdk/Getting_Started_bsp/ps7_cortexa9_0/libsrc/gpio_v4_0/src/xgpio_g.c | dwij2812/UART-Spectrum-Analyzer-for-Serial-Devices | af1cc6f9deac8cf7b33288e8c3891189f376ca42 | [
"MIT"
] | 2 | 2019-06-12T10:45:47.000Z | 2019-08-23T01:30:38.000Z | Hardware_wrappers-for_ZEDboard/project_3/project_3.sdk/Getting_Started_bsp/ps7_cortexa9_0/libsrc/gpio_v4_0/src/xgpio_g.c | dwij2812/UART-Spectrum-Analyzer-for-Serial-Devices | af1cc6f9deac8cf7b33288e8c3891189f376ca42 | [
"MIT"
] | 1 | 2021-10-18T19:36:22.000Z | 2021-10-18T19:36:22.000Z | Hardware_wrappers-for_ZEDboard/project_3/project_3.sdk/Getting_Started_bsp/ps7_cortexa9_0/libsrc/gpio_v4_0/src/xgpio_g.c | dwij2812/UART-Spectrum-Analyzer-for-Serial-Devices | af1cc6f9deac8cf7b33288e8c3891189f376ca42 | [
"MIT"
] | 1 | 2022-01-16T13:16:34.000Z | 2022-01-16T13:16:34.000Z |
/*******************************************************************
*
* CAUTION: This file is automatically generated by HSM.
* Version:
* DO NOT EDIT.
*
* v (64-bit)
SW Build (by ) on
Copyright 1986-2014 Xilinx, Inc. All Rights Reserved.
*
* Description: Driver configuration
*
*******************************************************************/
#include "xparameters.h"
#include "xgpio.h"
/*
* The configuration table for devices
*/
XGpio_Config XGpio_ConfigTable[] =
{
{
XPAR_AXI_GPIO_0_DEVICE_ID,
XPAR_AXI_GPIO_0_BASEADDR,
XPAR_AXI_GPIO_0_INTERRUPT_PRESENT,
XPAR_AXI_GPIO_0_IS_DUAL
},
{
XPAR_AXI_GPIO_1_DEVICE_ID,
XPAR_AXI_GPIO_1_BASEADDR,
XPAR_AXI_GPIO_1_INTERRUPT_PRESENT,
XPAR_AXI_GPIO_1_IS_DUAL
}
};
| 18.5 | 68 | 0.610811 |
aeb859cef91830f82831f1b93410f44cc84a507d | 356 | h | C | viogpudo/viogpu_idr.h | minmossi/virtio-gpu-wddm-dod-laptop | 6288040bb20ca855c81e49e9c7546b331da6e842 | [
"BSD-2-Clause"
] | 24 | 2017-08-08T13:34:16.000Z | 2021-11-14T17:09:29.000Z | viogpudo/viogpu_idr.h | minmossi/virtio-gpu-wddm-dod-laptop | 6288040bb20ca855c81e49e9c7546b331da6e842 | [
"BSD-2-Clause"
] | null | null | null | viogpudo/viogpu_idr.h | minmossi/virtio-gpu-wddm-dod-laptop | 6288040bb20ca855c81e49e9c7546b331da6e842 | [
"BSD-2-Clause"
] | 6 | 2018-02-08T16:53:58.000Z | 2021-12-21T20:24:36.000Z | #pragma once
#include "helper.h"
class VioGpuIdr
{
public:
VioGpuIdr();
~VioGpuIdr();
BOOLEAN Init(_In_ ULONG start);
ULONG GetId(void);
void PutId(_In_ ULONG id);
private:
void Close(void);
void Lock(void);
void Unlock(void);
private:
ULONG m_uStartIndex;
RTL_BITMAP m_IdBitMap;
FAST_MUTEX m_IdBitMapMutex;
};
| 16.952381 | 35 | 0.66573 |
aeb89a9d4df8dfb22d22505cf6557ea8e66ef646 | 924 | h | C | GLBaseObj.h | MaskingM/DynamicDesktop | f19653a56ad42246c329f2c8be67c09c259b9ccf | [
"MIT"
] | 2 | 2019-12-29T13:23:38.000Z | 2020-08-15T07:42:08.000Z | GLBaseObj.h | MaskingM/DynamicDesktop | f19653a56ad42246c329f2c8be67c09c259b9ccf | [
"MIT"
] | null | null | null | GLBaseObj.h | MaskingM/DynamicDesktop | f19653a56ad42246c329f2c8be67c09c259b9ccf | [
"MIT"
] | 1 | 2020-04-07T07:00:43.000Z | 2020-04-07T07:00:43.000Z | #include "GLBaseShader.h"
#ifndef __GLBASEOBJ__H_
#define __GLBASEOBJ__H_
class GLBaseObj
{
public:
virtual ~GLBaseObj(){
};
virtual GLuint getGLVBO() = 0;
virtual GLuint getGLVAO() = 0;
virtual GLint getGLWndWidth() = 0;
virtual GLint getGLWndHeight() = 0;
virtual GLuint getGLTexture() = 0;
virtual GLFWwindow* getGLWindow() = 0;
virtual void setGLShader(GLBaseShader* shader) = 0;
virtual void setTextureData(int width, int height, unsigned char* imgDate, int colorMode = GL_RGB) = 0;
virtual void setVerticesData(GLfloat* data, GLuint size, int drawMode = GL_STATIC_DRAW) = 0;
virtual void render() = 0;
virtual void resizeGLWindowSize(GLsizei w, GLsizei h) = 0;
virtual void hideGLWindow() = 0;
virtual void showGLWindow() = 0;
virtual void setGLWindowPos(int xpos, int ypos) = 0;
virtual void setGLContext(int val) = 0;
virtual int getGLWndHandle() = 0;
};
#endif | 29.806452 | 105 | 0.709957 |
aebad324d3505e50aa1a74401556a5229c335a37 | 95 | c | C | MDK-ARM/moteurcc.c | KilianDesportes/projet_voilier | 067ac9b733ff9a7721bfd49471b95fd406146885 | [
"Cube"
] | null | null | null | MDK-ARM/moteurcc.c | KilianDesportes/projet_voilier | 067ac9b733ff9a7721bfd49471b95fd406146885 | [
"Cube"
] | null | null | null | MDK-ARM/moteurcc.c | KilianDesportes/projet_voilier | 067ac9b733ff9a7721bfd49471b95fd406146885 | [
"Cube"
] | null | null | null | #include "moteurcc.h"
void MoteurCC_Congif(TIM_TypeDef * Timer, int valeurTelecommande)
{
}
| 11.875 | 65 | 0.757895 |
aebb209c9b393f70a0dab844a56a6511f0e44027 | 1,063 | h | C | System/Library/PrivateFrameworks/SiriUICore.framework/SUICFauxFlamesView.h | lechium/tvOS145Headers | 9940da19adb0017f8037853e9cfccbe01b290dd5 | [
"MIT"
] | 5 | 2021-04-29T04:31:43.000Z | 2021-08-19T18:59:58.000Z | System/Library/PrivateFrameworks/SiriUICore.framework/SUICFauxFlamesView.h | lechium/tvOS145Headers | 9940da19adb0017f8037853e9cfccbe01b290dd5 | [
"MIT"
] | null | null | null | System/Library/PrivateFrameworks/SiriUICore.framework/SUICFauxFlamesView.h | lechium/tvOS145Headers | 9940da19adb0017f8037853e9cfccbe01b290dd5 | [
"MIT"
] | 1 | 2022-03-19T11:16:23.000Z | 2022-03-19T11:16:23.000Z | /*
* This header is generated by classdump-dyld 1.5
* on Wednesday, April 28, 2021 at 9:07:57 PM Mountain Standard Time
* Operating System: Version 14.5 (Build 18L204)
* Image Source: /System/Library/PrivateFrameworks/SiriUICore.framework/SiriUICore
* classdump-dyld is licensed under GPLv3, Copyright © 2013-2016 by Elias Limneos. Updated by Kevin Bradley.
*/
#import <SiriUICore/SiriUICore-Structs.h>
#import <UIKitCore/UIView.h>
@interface SUICFauxFlamesView : UIView {
long long _style;
SCD_Struct_SU12 _sequenceAttributes;
}
+(id)_frameImagesForSequence:(SCD_Struct_SU12)arg1 ;
-(id)initWithCoder:(id)arg1 ;
-(void)setHidden:(BOOL)arg1 ;
-(void)prewarm;
-(id)initWithFrame:(CGRect)arg1 ;
-(void)start:(BOOL)arg1 ;
-(id)initWithStyle:(long long)arg1 ;
-(BOOL)isAnimating;
-(void)didMoveToSuperview;
-(void)stop:(BOOL)arg1 ;
-(id)initWithStyle:(long long)arg1 screenSize:(long long)arg2 ;
-(void)_cleanupView;
@end
| 33.21875 | 130 | 0.662277 |
aebc375051152e626c8db43dba2ffbf275309303 | 14,416 | h | C | YapDatabase/Extensions/CloudCore/Utilities/Execution/YapDatabaseCloudCorePipeline.h | aldonin/YapDatabase | c63690b4d83229a0b52890e029422ed819e175f6 | [
"BSD-3-Clause"
] | null | null | null | YapDatabase/Extensions/CloudCore/Utilities/Execution/YapDatabaseCloudCorePipeline.h | aldonin/YapDatabase | c63690b4d83229a0b52890e029422ed819e175f6 | [
"BSD-3-Clause"
] | null | null | null | YapDatabase/Extensions/CloudCore/Utilities/Execution/YapDatabaseCloudCorePipeline.h | aldonin/YapDatabase | c63690b4d83229a0b52890e029422ed819e175f6 | [
"BSD-3-Clause"
] | null | null | null | /**
* Copyright Deusty LLC.
**/
#import <Foundation/Foundation.h>
#import "YapDatabaseCloudCorePipelineDelegate.h"
#import "YapDatabaseCloudCoreGraph.h"
#import "YapDatabaseCloudCoreOperation.h"
#import "YapDatabaseCloudCore.h"
NS_ASSUME_NONNULL_BEGIN
typedef NS_ENUM(NSInteger, YDBCloudCorePipelineAlgorithm) {
/**
* This is the default algorithm if you don't explicitly pick one.
* It is HIGHLY recommended you start with this algorithm, until you become more advanced.
*
* The "Commit Graph" algorithm works as follows:
*
* - all operations added within a specific commit are added to their own "graph"
* - the pipeline will execute each graph 1-at-a-time
* - this ensures that graphs are completed in commit order
*
* That is, if a pipeline contains 2 graphs:
* - graph "A" - representing operations from commit #32
* - graph "B" - represending operations from commit #33
*
* Then the pipeline will ensure that ALL operations from graphA are either completed or skipped
* before ANY operations from graphB start.
*
* This is the safest option because it means:
* - you only have to think about operation dependencies within the context of a single commit
* - the pipeline ensures the cloud moves from commit to commit (just as occurred locally)
**/
YDBCloudCorePipelineAlgorithm_CommitGraph = 0,
/**
* This is and ADVANCED algorithm that is only recommended after your cloud solution has matured.
*
* The "Flat Graph" algorithm works as follows:
*
* - all operations added within a specific commit are added to their own "graph"
* - HOWEVER, the pipeline is free to start operations from ANY graph
* - and it will do so, while respecting dependencies, priorities & maxConcurrentOperationCount
*
* In particular, what this means for you is:
*
* - you MUST create a FORMAL DEPENDENCY GRAPH (think: state diagram for dependencies)
*
* That is:
* - given any possible operation (opA) in commitA
* - and given any possible operation (opB) in commitB
* - your formal dependency graph must determine if opB should depend on opA
*
* The recommended way of implementing your formal dependency graph is by
* subclassing YapDatabaseCloudCoreTransaction & overriding the method
* `processOperations:inPipeline:withGraphIdx:`.
**/
YDBCloudCorePipelineAlgorithm_FlatGraph = 1
};
typedef NS_ENUM(NSInteger, YDBCloudCoreOperationStatus) {
/**
* Pending means that the operation is queued in the pipeline,
* and may be released to the delegate when ready.
*
* If an operation fails, the PipelineDelegate may re-queue the operation by marking its status as pending.
* This gives control over the operation back to the pipeline,
* and it will dispatch it to the PipelineDelegate again when ready.
**/
YDBCloudOperationStatus_Pending = 0,
/**
* The operation has been started.
* I.e. has been handed to the PipelineDelegate via 'startOperation::'.
**/
YDBCloudOperationStatus_Active,
/**
* Until an operation is marked as either completed or skipped,
* the pipeline will act as if the operation is still in progress.
*
* In order to mark an operation as completed or skipped, the following must be used:
* - [YapDatabaseCloudCoreTransaction completeOperation:]
* - [YapDatabaseCloudCoreTransaction skipOperation:]
*
* These methods allow the system to delete the operation from the internal sqlite table.
**/
YDBCloudOperationStatus_Completed,
YDBCloudOperationStatus_Skipped,
};
/**
* This notification is posted whenever the operations in the pipeline's queue have changed.
* That is, one of the following have occurred:
* - One or more operations were removed from the queue (completed or skipped)
* - One or more operations were added to the queue (added or inserted)
* - One or more operations were modified
*
* This notification is posted to the main thread.
**/
extern NSString *const YDBCloudCorePipelineQueueChangedNotification;
extern NSString *const YDBCloudCorePipelineQueueChangedKey_addedOperationUUIDs;
extern NSString *const YDBCloudCorePipelineQueueChangedKey_modifiedOperationUUIDs;
extern NSString *const YDBCloudCorePipelineQueueChangedKey_insertedOperationUUIDs;
extern NSString *const YDBCloudCorePipelineQueueChangedKey_removedOperationUUIDs;
/**
* This notification is posted whenever the suspendCount changes.
* This notification is posted to the main thread.
**/
extern NSString *const YDBCloudCorePipelineSuspendCountChangedNotification;
/**
* This notification is posted whenever the isActive status changes.
* This notification is posted to the main thread.
**/
extern NSString *const YDBCloudCorePipelineActiveStatusChangedNotification;
/**
* A "pipeline" represents a queue of operations for syncing with a cloud server.
* It operates by managing a series of "graphs".
*
* Generally speaking, a graph is all the cloud operations that were generated in a single commit (for a
* specific pipeline). Within the graph are the various operations with their different dependencies & priorities.
* The operations within a graph will be executed in accordance with the set dependencies & priorities.
*
* The pipeline manages executing the operations within each graph.
**/
@interface YapDatabaseCloudCorePipeline : NSObject
/**
* Initializes a pipeline instance with the given name and delegate.
* After creating a pipeline instance, you need to register it via [YapDatabaseCloudCore registerPipeline:].
**/
- (instancetype)initWithName:(NSString *)name
delegate:(id <YapDatabaseCloudCorePipelineDelegate>)delegate;
/**
* Initializes a pipeline instance with the given name and delegate.
* Additionally, you may choose to use an advanced algorithm such as FlatGraph.
*
* After creating a pipeline instance, you need to register it via [YapDatabaseCloudCore registerPipeline:].
**/
- (instancetype)initWithName:(NSString *)name
algorithm:(YDBCloudCorePipelineAlgorithm)algorithm
delegate:(id <YapDatabaseCloudCorePipelineDelegate>)delegate;
@property (nonatomic, copy, readonly) NSString *name;
@property (nonatomic, assign, readonly) YDBCloudCorePipelineAlgorithm algorithm;
@property (nonatomic, weak, readonly) id <YapDatabaseCloudCorePipelineDelegate> delegate;
@property (atomic, weak, readonly, nullable) YapDatabaseCloudCore *owner;
#pragma mark Configuration
/**
* If you decide to rename a pipeline, you should be sure to set the previousNames property.
* This is to ensure that operations (from previous app launches) that were tagged with the previous pipeline name
* can be properly migrated to the new pipeline name.
*
* This property must be set before the pipeline is registered.
**/
@property (nonatomic, copy, readwrite, nullable) NSSet *previousNames;
/**
* This value is the maximum number of operations that will be assigned to the delegate at any one time.
*
* The pipeline keeps track of operations that have been assigned to the delegate (via startOperation:forPipeline:),
* and will delay assigning any more operations once the maxConcurrentOperationCount has been reached.
* Once an operation is completed (or skipped), the pipeline will automatically resume.
*
* Of course, the delegate is welcome to perform its own concurrency restriction.
* For example, via NSURLSessionConfiguration.HTTPMaximumConnectionsPerHost.
* In which case it may simply set this to a high enough value that it won't interfere with its own implementation.
*
* This value may be changed at anytime.
*
* The default value is 8.
*
* Setting the value to zero is the equivalent of setting the value to NSUIntegerMax.
* If your intention is to pause/suspend the queue, use the suspend/resume methods.
**/
@property (atomic, assign, readwrite) NSUInteger maxConcurrentOperationCount;
#pragma mark Operation Searching
/**
* Searches for an operation with the given UUID.
*
* @return The corresponding operation, if found. Otherwise nil.
**/
- (nullable YapDatabaseCloudCoreOperation *)operationWithUUID:(NSUUID *)uuid;
/**
* Searches for a list of operations.
*
* @return A dictionary with all the found operations.
* Operations which were not found won't be present in the returned dictionary.
**/
- (NSDictionary<NSUUID*, YapDatabaseCloudCoreOperation*> *)operationsWithUUIDs:(NSArray<NSUUID*> *)uuids;
/**
* Returns a list of operations in state 'YDBCloudOperationStatus_Active'.
**/
- (NSArray<YapDatabaseCloudCoreOperation *> *)activeOperations;
/**
* Enumerates the queued operations.
*
* This is useful for finding operation.
* For example, you might use this to search for an upload operation with a certain cloudPath.
**/
- (void)enumerateOperationsUsingBlock:(void (^)(YapDatabaseCloudCoreOperation *operation,
NSUInteger graphIdx, BOOL *stop))enumBlock;
/**
* Returns the number of graphs queued in the pipeline.
* Each graph represents the operations from a particular commit.
**/
- (NSUInteger)graphCount;
#pragma mark Operation Status
/**
* Returns the current status for the given operation.
**/
- (YDBCloudCoreOperationStatus)statusForOperationWithUUID:(NSUUID *)opUUID;
/**
* Typically you are strongly discouraged from manually starting an operation.
* You should allow the pipeline to mange the queue, and only start operations when told to.
*
* However, there is one particular edge case in which is is unavoidable: background network tasks.
* If the app is relaunched, and you discover there are network tasks from a previous app session,
* you'll obviously want to avoid starting the corresponding operation again.
* In this case, you should use this method to inform the pipeline that the operation is already started.
**/
- (void)setStatusAsActiveForOperationWithUUID:(NSUUID *)opUUID;
/**
* The PipelineDelegate may invoke this method to reset a failed operation.
* This gives control over the operation back to the pipeline,
* and it will dispatch it back to the PipelineDelegate again when ready.
**/
- (void)setStatusAsPendingForOperationWithUUID:(NSUUID *)opUUID;
#pragma mark Operation Hold
/**
* Returns the current hold for the operation (with the given context), or nil if there is no hold.
*
* Different context's allow different parts of the system to operate in parallel.
* For example, if an operation requires several different subsystems to each complete an action,
* then each susbsystem can independently place a hold on the operation.
* Once all holds are lifted, the pipeline can dispatch the operation again.
**/
- (nullable NSDate *)holdDateForOperationWithUUID:(NSUUID *)opUUID context:(NSString *)context;
/**
* And operation can be put on "hold" until a specified date.
*
* There are multiple uses for this. For example:
* - An operation may require various preparation tasks to complete before it can be started.
* - A failed operation may use a holdDate in conjunction with retry logic, such as exponential backoff.
*
* The operation won't be started again until all associated holdDate's have expired.
* You can pass a nil date to remove a hold on an operation (for a given context).
**/
- (void)setHoldDate:(nullable NSDate *)date forOperationWithUUID:(NSUUID *)opUUID context:(NSString *)context;
/**
* Returns the latest hold date for the given operation.
*
* If there are no holdDates for the operation, returns nil.
* If there are 1 or more holdDates, returns the latest date.
**/
- (nullable NSDate *)latestHoldDateForOperationWithUUID:(NSUUID *)opUUID;
/**
* Returns a dictionary of all the hold dates associated with an operation.
**/
- (nullable NSDictionary<NSString*, NSDate*> *)holdDatesForOperationWithUUID:(NSUUID *)opUUID;
/**
* Returns a dictionary of all the hold dates associated with a particular context.
**/
- (nullable NSDictionary<NSUUID*, NSDate*> *)holdDatesForContext:(NSString *)context;
#pragma mark Suspend & Resume
/**
* Returns YES if the upload operation queue is suspended.
*
* @see suspend
* @see resume
**/
@property (atomic, readonly) BOOL isSuspended;
/**
* Returns the current suspendCount.
* If the suspendCount is zero, that means isSuspended == NO;
* if the suspendCount is non-zero, that means isSuspended == YES;
*
* @see suspend
* @see resume
**/
@property (atomic, readonly) NSUInteger suspendCount;
/**
* Increments the suspendCount.
* All calls to 'suspend' need to be matched with an equal number of calls to 'resume'.
*
* @return
* The new suspend count.
* This will be 1 if the pipeline was previously active, and is now suspended due to this call.
* Otherwise it will be greater than one, meaning it was previously suspended,
* and you just incremented the suspend count.
*
* @see resume
* @see suspendCount
**/
- (NSUInteger)suspend;
/**
* This method operates the same as invoking the suspend method the given number of times.
* That is, it increments the suspend count by the given number.
*
* If you invoke this method with a zero parameter,
* it will simply return the current suspend count, without modifying it.
*
* @see suspend
* @see suspendCount
**/
- (NSUInteger)suspendWithCount:(NSUInteger)suspendCountIncrement;
/**
* Decrements the suspendCount.
* All calls to 'suspend' need to be matched with an equal number of calls to 'resume'.
*
* @return
* The current suspend count.
* This will be 0 if the extension was previously suspended, and is now resumed due to this call.
* Otherwise it will be greater than one, meaning it's still suspended,
* and you just decremented the suspend count.
*
* @see suspend
* @see suspendCount
**/
- (NSUInteger)resume;
#pragma mark Activity
/**
* A pipeline transitions to the 'active' state when:
* - There are 1 or more operations in 'YDBCloudOperationStatus_Active' mode.
*
* A pipeline transitions to the 'inactive' state when:
* - There are 0 operations in 'YDBCloudOperationStatus_Active' mode
* - AND (the pipeline is suspended OR there are no more operations)
*
* ^In other words, there may be situations in which there are zero active operations,
* due to something like a conflict resolution, however the pipeline is still considered
* active because it still has pending operations, and it hasn't been suspended.
**/
@property (atomic, readonly) BOOL isActive;
@end
NS_ASSUME_NONNULL_END
| 38.545455 | 116 | 0.754648 |
aec0ca4d1ede505b8e6ebf639ff9cea7858c5139 | 741 | h | C | src/qt/multisenddialog.h | Tillkoeln/WYTF | 5092f9a457843a34903d51a289d8b6dcb97e6082 | [
"MIT"
] | null | null | null | src/qt/multisenddialog.h | Tillkoeln/WYTF | 5092f9a457843a34903d51a289d8b6dcb97e6082 | [
"MIT"
] | 1 | 2020-03-04T05:04:43.000Z | 2020-03-04T07:55:56.000Z | src/qt/multisenddialog.h | Tillkoeln/WYTF | 5092f9a457843a34903d51a289d8b6dcb97e6082 | [
"MIT"
] | 6 | 2019-07-18T19:01:16.000Z | 2021-04-20T23:57:10.000Z | #ifndef CHARITYDIALOG_H
#define CHARITYDIALOG_H
#include <QDialog>
namespace Ui {
class MultisendDialog;
}
class WalletModel;
class QLineEdit;
class MultisendDialog : public QDialog
{
Q_OBJECT
public:
explicit MultisendDialog(QWidget *parent = 0);
~MultisendDialog();
void setModel(WalletModel *model);
void setAddress(const QString &address);
void setAddress(const QString &address, QLineEdit *addrEdit);
private slots:
void on_viewButton_clicked();
void on_addButton_clicked();
void on_deleteButton_clicked();
void on_activateButton_clicked();
void on_disableButton_clicked();
void on_addressBookButton_clicked();
private:
Ui::MultisendDialog *ui;
WalletModel *model;
};
#endif // CHARITYDIALOG_H | 20.583333 | 62 | 0.763833 |
aec165a2ec4fb200807d527936b48f644768c2fa | 3,042 | h | C | MXCHIP/mxchip_advanced/src/iotc/json.h | obastemur/iot-central-firmware | 852e020aa0b60c1f0e93702c16d89050eab78dea | [
"MIT"
] | null | null | null | MXCHIP/mxchip_advanced/src/iotc/json.h | obastemur/iot-central-firmware | 852e020aa0b60c1f0e93702c16d89050eab78dea | [
"MIT"
] | null | null | null | MXCHIP/mxchip_advanced/src/iotc/json.h | obastemur/iot-central-firmware | 852e020aa0b60c1f0e93702c16d89050eab78dea | [
"MIT"
] | null | null | null | // Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license.
#ifndef AZURE_IOTC_API_JSON
#define AZURE_IOTC_API_JSON
#include "parson.h"
#include "iotc.h"
namespace AzureIOTC
{
class JSObject
{
private:
JSON_Value* value;
JSON_Object* object;
bool isSubObject;
JSON_Object* toObject() {
object = json_value_get_object(value);
if (object == NULL) {
LOG_ERROR("JSON value is not an object");
return NULL;
}
return object;
}
public:
JSObject(): value(NULL), object(NULL), isSubObject(false) { }
JSObject(const char * json_string) : isSubObject(false) {
value = json_parse_string(json_string);
if (value == NULL) {
LOG_ERROR("parsing JSON failed");
}
object = toObject();
if (object == NULL) {
LOG_ERROR("json data: %s", json_string);
}
}
const char * getNameAt(unsigned index) {
assert(object != NULL);
return json_object_get_name(object, index);
}
unsigned getCount() {
return object ? (unsigned)json_object_get_count(object) : 0;
}
bool hasProperty(const char * name) {
return object ? json_object_has_value(object, name) == 1 : false;
}
const char * toString() {
assert(object != NULL);
JSON_Value * val = json_object_get_wrapping_value(object);
if (val == NULL) return NULL;
return json_value_get_string(val);
}
~JSObject() {
if (value != NULL && isSubObject == false) {
json_value_free(value);
value = NULL;
}
}
bool getObjectAt(unsigned index, JSObject * outJSObject) {
if (index >= getCount()) return false;
JSON_Value * subValue = json_object_get_value_at(object, index);
if (subValue == NULL) return false;
outJSObject->isSubObject = true;
outJSObject->value = subValue;
outJSObject->toObject();
if (outJSObject->object == NULL) return false;
return true;
}
bool getObjectByName(const char * name, JSObject * outJSObject) {
JSON_Object* subObject = json_object_get_object(object, name);
if (subObject == NULL) {
// outJSObject->value memory freed by it's own de-constructor.
return false; // let consumer file the log
}
outJSObject->value = json_object_get_wrapping_value(object);
outJSObject->object = subObject;
outJSObject->isSubObject = true;
return true;
}
const char * getStringByName(const char * name) {
assert(object != NULL);
const char * text = json_object_get_string(object, name);
if (text == NULL) {
return NULL; // let consumer file the log
}
return text;
}
double getNumberByName(const char * name) {
assert(object != NULL);
// API returns 0.0 on fail hence it doesn't actually have a good
// fail discovery strategy
return json_object_get_number(object, name);
}
};
} // namespace AzureIOTC
#endif // AZURE_IOTC_API_JSON
| 25.563025 | 71 | 0.624918 |
aec213d4ee21851d78fe508015066570642e04df | 1,469 | c | C | src/workqueue/workqueue_new.c | bjnw/libft | d351310c09041377ed491628f5b24c3293cf5117 | [
"WTFPL"
] | 3 | 2020-10-13T18:55:41.000Z | 2022-02-19T03:37:11.000Z | src/workqueue/workqueue_new.c | bjnw/libft | d351310c09041377ed491628f5b24c3293cf5117 | [
"WTFPL"
] | null | null | null | src/workqueue/workqueue_new.c | bjnw/libft | d351310c09041377ed491628f5b24c3293cf5117 | [
"WTFPL"
] | 1 | 2021-01-10T16:14:27.000Z | 2021-01-10T16:14:27.000Z | /* ************************************************************************** */
/* */
/* ::: :::::::: */
/* workqueue_new.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: ourgot <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2020/07/28 02:14:32 by ourgot #+# #+# */
/* Updated: 2020/07/28 02:14:32 by ourgot ### ########.fr */
/* */
/* ************************************************************************** */
#include "common/func.h"
#include "libft.h"
#include "workqueuedecl.h"
/*
** TODO max/min threads
*/
t_workqueue *workqueue_new(size_t nthreads, const pthread_attr_t *attr)
{
t_workqueue *wq;
pthread_t th;
wq = xcalloc(1, sizeof(*wq));
pthread_mutex_init(&wq->lock, NULL);
pthread_cond_init(&wq->notify, NULL);
pthread_cond_init(&wq->wait, NULL);
pthread_cond_init(&wq->empty, NULL);
wq->queue = fifo_new(sizeof(t_task));
wq->threads = nthreads;
while (nthreads--)
{
pthread_create(&th, attr, (t_f1)workqueue_loop, wq);
pthread_detach(th);
}
return (wq);
}
| 36.725 | 80 | 0.338325 |
aec47c8e8a3723dcc72dd3f78c24947cf0a1f57b | 1,497 | c | C | app/jni/opus/opusfile/internal.c | grevity/Yahala-Messenger | a50501c20090947e1fcdc72c1955952e07b513f8 | [
"MIT"
] | 17 | 2016-05-19T01:31:59.000Z | 2020-08-19T10:30:22.000Z | app/jni/opus/opusfile/internal.c | grevity/Yahala-Messenger | a50501c20090947e1fcdc72c1955952e07b513f8 | [
"MIT"
] | 1 | 2017-03-17T06:46:34.000Z | 2019-01-11T14:09:29.000Z | app/jni/opus/opusfile/internal.c | wmhameed/Yahala-Messenger | a50501c20090947e1fcdc72c1955952e07b513f8 | [
"MIT"
] | 15 | 2016-05-19T01:32:00.000Z | 2020-09-28T08:22:50.000Z | /********************************************************************
* *
* THIS FILE IS PART OF THE libopusfile SOFTWARE CODEC SOURCE CODE. *
* USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
* GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
* IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
* *
* THE libopusfile SOURCE CODE IS (C) COPYRIGHT 2012 *
* by the Xiph.Org Foundation and contributors http://www.xiph.org/ *
* *
********************************************************************/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "internal.h"
#if defined(OP_ENABLE_ASSERTIONS)
void op_fatal_impl(const char *_str,const char *_file,int _line){
fprintf(stderr,"Fatal (internal) error in %s, line %i: %s\n",
_file,_line,_str);
abort();
}
#endif
/*A version of strncasecmp() that is guaranteed to only ignore the case of
ASCII characters.*/
int op_strncasecmp(const char *_a, const char *_b, int _n) {
int i;
for (i = 0; i < _n; i++) {
int a;
int b;
int d;
a = _a[i];
b = _b[i];
if (a >= 'a' && a <= 'z')a -= 'a' - 'A';
if (b >= 'a' && b <= 'z')b -= 'a' - 'A';
d = a - b;
if (d)return d;
}
return 0;
}
| 34.813953 | 74 | 0.456246 |
aec5e7d0a18746d6a2a1236b7146e4bea48f57aa | 9,927 | c | C | gsl-2.6/gsl-randist.c | ielomariala/Hex-Game | 2c2e7c85f8414cb0e654cb82e9686cce5e75c63a | [
"MIT"
] | 14 | 2015-01-11T02:53:04.000Z | 2021-11-25T17:31:22.000Z | Source/BaselineMethods/MNE/C++/gsl-2.4/gsl-randist.c | Brian-ning/HMNE | 1b4ee4c146f526ea6e2f4f8607df7e9687204a9e | [
"Apache-2.0"
] | 6 | 2019-12-16T17:41:24.000Z | 2019-12-22T00:00:16.000Z | Source/BaselineMethods/MNE/C++/gsl-2.4/gsl-randist.c | Brian-ning/HMNE | 1b4ee4c146f526ea6e2f4f8607df7e9687204a9e | [
"Apache-2.0"
] | 14 | 2015-07-21T04:47:52.000Z | 2020-03-12T12:31:25.000Z | /* randist/gsl-randist.c
*
* Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 James Theiler, Brian Gough
*
* 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, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#include <config.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <gsl/gsl_randist.h>
#include <gsl/gsl_rng.h>
#include <gsl/gsl_test.h>
void error (const char * s);
int
main (int argc, char *argv[])
{
size_t i,j;
size_t n = 0;
double mu = 0, nu = 0, nu1 = 0, nu2 = 0, sigma = 0, a = 0, b = 0, c = 0;
double zeta = 0, sigmax = 0, sigmay = 0, rho = 0;
double p = 0;
double x = 0, y =0, z=0 ;
unsigned int N = 0, t = 0, n1 = 0, n2 = 0 ;
unsigned long int seed = 0 ;
const char * name ;
gsl_rng * r ;
if (argc < 4)
{
printf (
"Usage: gsl-randist seed n DIST param1 param2 ...\n"
"Generates n samples from the distribution DIST with parameters param1,\n"
"param2, etc. Valid distributions are,\n\n");
printf(
" beta\n"
" binomial\n"
" bivariate-gaussian\n"
" cauchy\n"
" chisq\n"
" dir-2d\n"
" dir-3d\n"
" dir-nd\n"
" erlang\n"
" exponential\n"
" exppow\n"
" fdist\n"
" flat\n"
" gamma\n"
" gaussian-tail\n"
" gaussian\n"
" geometric\n"
" gumbel1\n"
" gumbel2\n"
" hypergeometric\n"
" laplace\n"
" landau\n"
" levy\n"
" levy-skew\n"
" logarithmic\n"
" logistic\n"
" lognormal\n"
" negative-binomial\n"
" pareto\n"
" pascal\n"
" poisson\n"
" rayleigh-tail\n"
" rayleigh\n"
" tdist\n"
" ugaussian-tail\n"
" ugaussian\n"
" weibull\n") ;
exit (0);
}
argv++ ; seed = atol (argv[0]); argc-- ;
argv++ ; n = atol (argv[0]); argc-- ;
argv++ ; name = argv[0] ; argc-- ; argc-- ;
gsl_rng_env_setup() ;
if (gsl_rng_default_seed != 0) {
fprintf(stderr,
"overriding GSL_RNG_SEED with command line value, seed = %ld\n",
seed) ;
}
gsl_rng_default_seed = seed ;
r = gsl_rng_alloc(gsl_rng_default) ;
#define NAME(x) !strcmp(name,(x))
#define OUTPUT(x) for (i = 0; i < n; i++) { printf("%g\n", (x)) ; }
#define OUTPUT1(a,x) for(i = 0; i < n; i++) { a ; printf("%g\n", x) ; }
#define OUTPUT2(a,x,y) for(i = 0; i < n; i++) { a ; printf("%g %g\n", x, y) ; }
#define OUTPUT3(a,x,y,z) for(i = 0; i < n; i++) { a ; printf("%g %g %g\n", x, y, z) ; }
#define INT_OUTPUT(x) for (i = 0; i < n; i++) { printf("%d\n", (x)) ; }
#define ARGS(x,y) if (argc != x) error(y) ;
#define DBL_ARG(x) if (argc) { x=atof((++argv)[0]);argc--;} else {error( #x);};
#define INT_ARG(x) if (argc) { x=atoi((++argv)[0]);argc--;} else {error( #x);};
if (NAME("bernoulli"))
{
ARGS(1, "p = probability of success");
DBL_ARG(p)
INT_OUTPUT(gsl_ran_bernoulli (r, p));
}
else if (NAME("beta"))
{
ARGS(2, "a,b = shape parameters");
DBL_ARG(a)
DBL_ARG(b)
OUTPUT(gsl_ran_beta (r, a, b));
}
else if (NAME("binomial"))
{
ARGS(2, "p = probability, N = number of trials");
DBL_ARG(p)
INT_ARG(N)
INT_OUTPUT(gsl_ran_binomial (r, p, N));
}
else if (NAME("cauchy"))
{
ARGS(1, "a = scale parameter");
DBL_ARG(a)
OUTPUT(gsl_ran_cauchy (r, a));
}
else if (NAME("chisq"))
{
ARGS(1, "nu = degrees of freedom");
DBL_ARG(nu)
OUTPUT(gsl_ran_chisq (r, nu));
}
else if (NAME("erlang"))
{
ARGS(2, "a = scale parameter, b = order");
DBL_ARG(a)
DBL_ARG(b)
OUTPUT(gsl_ran_erlang (r, a, b));
}
else if (NAME("exponential"))
{
ARGS(1, "mu = mean value");
DBL_ARG(mu) ;
OUTPUT(gsl_ran_exponential (r, mu));
}
else if (NAME("exppow"))
{
ARGS(2, "a = scale parameter, b = power (1=exponential, 2=gaussian)");
DBL_ARG(a) ;
DBL_ARG(b) ;
OUTPUT(gsl_ran_exppow (r, a, b));
}
else if (NAME("fdist"))
{
ARGS(2, "nu1, nu2 = degrees of freedom parameters");
DBL_ARG(nu1) ;
DBL_ARG(nu2) ;
OUTPUT(gsl_ran_fdist (r, nu1, nu2));
}
else if (NAME("flat"))
{
ARGS(2, "a = lower limit, b = upper limit");
DBL_ARG(a) ;
DBL_ARG(b) ;
OUTPUT(gsl_ran_flat (r, a, b));
}
else if (NAME("gamma"))
{
ARGS(2, "a = order, b = scale");
DBL_ARG(a) ;
DBL_ARG(b) ;
OUTPUT(gsl_ran_gamma (r, a, b));
}
else if (NAME("gaussian"))
{
ARGS(1, "sigma = standard deviation");
DBL_ARG(sigma) ;
OUTPUT(gsl_ran_gaussian (r, sigma));
}
else if (NAME("gaussian-tail"))
{
ARGS(2, "a = lower limit, sigma = standard deviation");
DBL_ARG(a) ;
DBL_ARG(sigma) ;
OUTPUT(gsl_ran_gaussian_tail (r, a, sigma));
}
else if (NAME("ugaussian"))
{
ARGS(0, "unit gaussian, no parameters required");
OUTPUT(gsl_ran_ugaussian (r));
}
else if (NAME("ugaussian-tail"))
{
ARGS(1, "a = lower limit");
DBL_ARG(a) ;
OUTPUT(gsl_ran_ugaussian_tail (r, a));
}
else if (NAME("bivariate-gaussian"))
{
ARGS(3, "sigmax = x std.dev., sigmay = y std.dev., rho = correlation");
DBL_ARG(sigmax) ;
DBL_ARG(sigmay) ;
DBL_ARG(rho) ;
OUTPUT2(gsl_ran_bivariate_gaussian (r, sigmax, sigmay, rho, &x, &y),
x, y);
}
else if (NAME("dir-2d"))
{
OUTPUT2(gsl_ran_dir_2d (r, &x, &y), x, y);
}
else if (NAME("dir-3d"))
{
OUTPUT3(gsl_ran_dir_3d (r, &x, &y, &z), x, y, z);
}
else if (NAME("dir-nd"))
{
double *xarr;
ARGS(1, "n1 = number of dimensions of hypersphere");
INT_ARG(n1) ;
xarr = (double *)malloc(n1*sizeof(double));
for(i = 0; i < n; i++) {
gsl_ran_dir_nd (r, n1, xarr) ;
for (j = 0; j < n1; j++) {
if (j) putchar(' ');
printf("%g", xarr[j]) ;
}
putchar('\n');
} ;
free(xarr);
}
else if (NAME("geometric"))
{
ARGS(1, "p = bernoulli trial probability of success");
DBL_ARG(p) ;
INT_OUTPUT(gsl_ran_geometric (r, p));
}
else if (NAME("gumbel1"))
{
ARGS(2, "a = order, b = scale parameter");
DBL_ARG(a) ;
DBL_ARG(b) ;
OUTPUT(gsl_ran_gumbel1 (r, a, b));
}
else if (NAME("gumbel2"))
{
ARGS(2, "a = order, b = scale parameter");
DBL_ARG(a) ;
DBL_ARG(b) ;
OUTPUT(gsl_ran_gumbel2 (r, a, b));
}
else if (NAME("hypergeometric"))
{
ARGS(3, "n1 = tagged population, n2 = untagged population, t = number of trials");
INT_ARG(n1) ;
INT_ARG(n2) ;
INT_ARG(t) ;
INT_OUTPUT(gsl_ran_hypergeometric (r, n1, n2, t));
}
else if (NAME("laplace"))
{
ARGS(1, "a = scale parameter");
DBL_ARG(a) ;
OUTPUT(gsl_ran_laplace (r, a));
}
else if (NAME("landau"))
{
ARGS(0, "no arguments required");
OUTPUT(gsl_ran_landau (r));
}
else if (NAME("levy"))
{
ARGS(2, "c = scale, a = power (1=cauchy, 2=gaussian)");
DBL_ARG(c) ;
DBL_ARG(a) ;
OUTPUT(gsl_ran_levy (r, c, a));
}
else if (NAME("levy-skew"))
{
ARGS(3, "c = scale, a = power (1=cauchy, 2=gaussian), b = skew");
DBL_ARG(c) ;
DBL_ARG(a) ;
DBL_ARG(b) ;
OUTPUT(gsl_ran_levy_skew (r, c, a, b));
}
else if (NAME("logarithmic"))
{
ARGS(1, "p = probability");
DBL_ARG(p) ;
INT_OUTPUT(gsl_ran_logarithmic (r, p));
}
else if (NAME("logistic"))
{
ARGS(1, "a = scale parameter");
DBL_ARG(a) ;
OUTPUT(gsl_ran_logistic (r, a));
}
else if (NAME("lognormal"))
{
ARGS(2, "zeta = location parameter, sigma = scale parameter");
DBL_ARG(zeta) ;
DBL_ARG(sigma) ;
OUTPUT(gsl_ran_lognormal (r, zeta, sigma));
}
else if (NAME("negative-binomial"))
{
ARGS(2, "p = probability, a = order");
DBL_ARG(p) ;
DBL_ARG(a) ;
INT_OUTPUT(gsl_ran_negative_binomial (r, p, a));
}
else if (NAME("pareto"))
{
ARGS(2, "a = power, b = scale parameter");
DBL_ARG(a) ;
DBL_ARG(b) ;
OUTPUT(gsl_ran_pareto (r, a, b));
}
else if (NAME("pascal"))
{
ARGS(2, "p = probability, n = order (integer)");
DBL_ARG(p) ;
INT_ARG(N) ;
INT_OUTPUT(gsl_ran_pascal (r, p, N));
}
else if (NAME("poisson"))
{
ARGS(1, "mu = scale parameter");
DBL_ARG(mu) ;
INT_OUTPUT(gsl_ran_poisson (r, mu));
}
else if (NAME("rayleigh"))
{
ARGS(1, "sigma = scale parameter");
DBL_ARG(sigma) ;
OUTPUT(gsl_ran_rayleigh (r, sigma));
}
else if (NAME("rayleigh-tail"))
{
ARGS(2, "a = lower limit, sigma = scale parameter");
DBL_ARG(a) ;
DBL_ARG(sigma) ;
OUTPUT(gsl_ran_rayleigh_tail (r, a, sigma));
}
else if (NAME("tdist"))
{
ARGS(1, "nu = degrees of freedom");
DBL_ARG(nu) ;
OUTPUT(gsl_ran_tdist (r, nu));
}
else if (NAME("weibull"))
{
ARGS(2, "a = scale parameter, b = exponent");
DBL_ARG(a) ;
DBL_ARG(b) ;
OUTPUT(gsl_ran_weibull (r, a, b));
}
else
{
fprintf(stderr,"Error: unrecognized distribution: %s\n", name) ;
}
return 0 ;
}
void
error (const char * s)
{
fprintf(stderr, "Error: arguments should be %s\n",s) ;
exit (EXIT_FAILURE) ;
}
| 25.131646 | 88 | 0.547698 |
aec5fe678f82aa8448e5e0d1e720ddfe6f1ebf8d | 488 | h | C | TST.h | madhu-GG/TST | 1cacc3bac698925f2ace4159d64a0b5d966b8add | [
"MIT"
] | null | null | null | TST.h | madhu-GG/TST | 1cacc3bac698925f2ace4159d64a0b5d966b8add | [
"MIT"
] | null | null | null | TST.h | madhu-GG/TST | 1cacc3bac698925f2ace4159d64a0b5d966b8add | [
"MIT"
] | null | null | null | #ifndef TST_H
#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
typedef uint8_t type;
typedef struct Node Node;
typedef struct TST TST;
TST* tst_alloc(void);
void tst_free(TST* tst_ptr);
bool tst_insert(TST* tst_ptr, type* key, size_t key_len, void* value);
void* tst_get(TST* tst_ptr, type* key);
void* tst_remove(TST* tst_ptr, type* key);
type* tst_longestPrefix(TST* tst_ptr, size_t* ret_len, type* key, size_t key_len);
size_t tst_count(TST *tst_ptr);
#endif /* TST_H */
| 27.111111 | 82 | 0.739754 |
aec7ab7f80af8fe2f2dc2aa25cea3050a160d1ac | 19,462 | c | C | ccs/cp861.c | opensmarty/apr-iconv | 4db97bcdfc51a701f5cef98599d2566f774669d8 | [
"Apache-2.0"
] | 13 | 2015-04-04T08:45:12.000Z | 2021-11-10T16:26:25.000Z | ccs/cp861.c | opensmarty/apr-iconv | 4db97bcdfc51a701f5cef98599d2566f774669d8 | [
"Apache-2.0"
] | null | null | null | ccs/cp861.c | opensmarty/apr-iconv | 4db97bcdfc51a701f5cef98599d2566f774669d8 | [
"Apache-2.0"
] | 20 | 2015-03-05T11:22:08.000Z | 2021-11-10T16:26:15.000Z | #define ICONV_INTERNAL
#include "iconv.h"
static const iconv_ccs_convtable_8bit to_ucs = { {
0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E5, 0x00E7,
0x00EA, 0x00EB, 0x00E8, 0x00D0, 0x00F0, 0x00DE, 0x00C4, 0x00C5,
0x00C9, 0x00E6, 0x00C6, 0x00F4, 0x00F6, 0x00FE, 0x00FB, 0x00DD,
0x00FD, 0x00D6, 0x00DC, 0x00F8, 0x00A3, 0x00D8, 0x20A7, 0x0192,
0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00C1, 0x00CD, 0x00D3, 0x00DA,
0x00BF, 0x2310, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F,
0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B,
0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
0x03B1, 0x00DF, 0x0393, 0x03C0, 0x03A3, 0x03C3, 0x00B5, 0x03C4,
0x03A6, 0x0398, 0x03A9, 0x03B4, 0x221E, 0x03C6, 0x03B5, 0x2229,
0x2261, 0x00B1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00F7, 0x2248,
0x00B0, 0x2219, 0x00B7, 0x221A, 0x207F, 0x00B2, 0x25A0, 0x00A0
} };
static const iconv_ccs_convtable_8bit from_ucs_00 = { {
0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0x00FF, 0x00AD, 0xFFFE, 0x009C, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0x00AE, 0x00AA, 0xFFFE, 0xFFFE, 0xFFFE,
0x00F8, 0x00F1, 0x00FD, 0xFFFE, 0xFFFE, 0x00E6, 0xFFFE, 0x00FA,
0xFFFE, 0xFFFE, 0xFFFE, 0x00AF, 0x00AC, 0x00AB, 0xFFFE, 0x00A8,
0xFFFE, 0x00A4, 0xFFFE, 0xFFFE, 0x008E, 0x008F, 0x0092, 0x0080,
0xFFFE, 0x0090, 0xFFFE, 0xFFFE, 0xFFFE, 0x00A5, 0xFFFE, 0xFFFE,
0x008B, 0xFFFE, 0xFFFE, 0x00A6, 0xFFFE, 0xFFFE, 0x0099, 0xFFFE,
0x009D, 0xFFFE, 0x00A7, 0xFFFE, 0x009A, 0x0097, 0x008D, 0x00E1,
0x0085, 0x00A0, 0x0083, 0xFFFE, 0x0084, 0x0086, 0x0091, 0x0087,
0x008A, 0x0082, 0x0088, 0x0089, 0xFFFE, 0x00A1, 0xFFFE, 0xFFFE,
0x008C, 0xFFFE, 0xFFFE, 0x00A2, 0x0093, 0xFFFE, 0x0094, 0x00F6,
0x009B, 0xFFFE, 0x00A3, 0x0096, 0x0081, 0x0098, 0x0095, 0xFFFE
} };
static const iconv_ccs_convtable_8bit from_ucs_01 = { {
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0x009F, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE
} };
static const iconv_ccs_convtable_8bit from_ucs_03 = { {
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0x00E2, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0x00E9, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0x00E4, 0xFFFE, 0xFFFE, 0x00E8, 0xFFFE,
0xFFFE, 0x00EA, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0x00E0, 0xFFFE, 0xFFFE, 0x00EB, 0x00EE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0x00E3, 0xFFFE, 0xFFFE, 0x00E5, 0x00E7, 0xFFFE, 0x00ED, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE
} };
static const iconv_ccs_convtable_8bit from_ucs_20 = { {
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0x00FC,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0x009E,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE
} };
static const iconv_ccs_convtable_8bit from_ucs_22 = { {
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0x00F9, 0x00FB, 0xFFFE, 0xFFFE, 0xFFFE, 0x00EC, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0x00EF, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0x00F7, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0x00F0, 0xFFFE, 0xFFFE, 0x00F3, 0x00F2, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE
} };
static const iconv_ccs_convtable_8bit from_ucs_23 = { {
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0x00A9, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0x00F4, 0x00F5, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE
} };
static const iconv_ccs_convtable_8bit from_ucs_25 = { {
0x00C4, 0xFFFE, 0x00B3, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0x00DA, 0xFFFE, 0xFFFE, 0xFFFE,
0x00BF, 0xFFFE, 0xFFFE, 0xFFFE, 0x00C0, 0xFFFE, 0xFFFE, 0xFFFE,
0x00D9, 0xFFFE, 0xFFFE, 0xFFFE, 0x00C3, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0x00B4, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0x00C2, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0x00C1, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0x00C5, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0x00CD, 0x00BA, 0x00D5, 0x00D6, 0x00C9, 0x00B8, 0x00B7, 0x00BB,
0x00D4, 0x00D3, 0x00C8, 0x00BE, 0x00BD, 0x00BC, 0x00C6, 0x00C7,
0x00CC, 0x00B5, 0x00B6, 0x00B9, 0x00D1, 0x00D2, 0x00CB, 0x00CF,
0x00D0, 0x00CA, 0x00D8, 0x00D7, 0x00CE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0x00DF, 0xFFFE, 0xFFFE, 0xFFFE, 0x00DC, 0xFFFE, 0xFFFE, 0xFFFE,
0x00DB, 0xFFFE, 0xFFFE, 0xFFFE, 0x00DD, 0xFFFE, 0xFFFE, 0xFFFE,
0x00DE, 0x00B0, 0x00B1, 0x00B2, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0x00FE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE,
0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE
} };
static const iconv_ccs_convtable_16bit from_ucs = { {
&from_ucs_00, &from_ucs_01, NULL, &from_ucs_03, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
&from_ucs_20, NULL, &from_ucs_22, &from_ucs_23, NULL, &from_ucs_25, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
} };
#define NBITS 8
static ucs2_t convert_from_ucs(ucs2_t ch)
{
return iconv_ccs_convert_16bit((const iconv_ccs_convtable *)&from_ucs, ch);
}
static ucs2_t convert_to_ucs(ucs2_t ch)
{
return iconv_ccs_convert_8bit((const iconv_ccs_convtable *)&to_ucs, ch);
}
static const char * const names[] = {
"cp861", NULL
};
static const struct iconv_ccs_desc iconv_ccs_desc = {
names, NBITS,
(const iconv_ccs_convtable *)&from_ucs,
(const iconv_ccs_convtable *)&to_ucs,
convert_from_ucs, convert_to_ucs,
};
struct iconv_module_desc iconv_module = {
ICMOD_UC_CCS,
apr_iconv_mod_noevent,
NULL,
&iconv_ccs_desc
};
| 55.925287 | 80 | 0.733378 |
aec96c86b7bb9d4d4889df8c3c813266a98745fd | 1,535 | h | C | include/micro1-as/lexer.h | Kenta11/micro1-as | 23b09dacb479b9e9a203cc99ac843e5a3504e4aa | [
"MIT"
] | null | null | null | include/micro1-as/lexer.h | Kenta11/micro1-as | 23b09dacb479b9e9a203cc99ac843e5a3504e4aa | [
"MIT"
] | null | null | null | include/micro1-as/lexer.h | Kenta11/micro1-as | 23b09dacb479b9e9a203cc99ac843e5a3504e4aa | [
"MIT"
] | null | null | null | // Copyright (c) 2020 Kenta Arai
//
// 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.
/**
* @file lexer.h
* @brief Declaration for lexical analyzer for MICRO-1 assembly program
* @author Kenta Arai
* @date 2020/05/24
*/
#ifndef LEXER_H
#define LEXER_H
#include "token.h"
#include <fstream>
namespace micro1 {
/**
* @brief tokenize a source program
* @param[in] ifs a source program
* @return Tokens lexical tokens
*/
Tokens
tokenize(std::ifstream& ifs);
} // namespace micro1
#endif // LEXER_H
| 31.979167 | 78 | 0.744625 |
aeca5a3ad45a20898367d01bc00ee8b4452f8f1a | 3,634 | h | C | Ambit/Source/Ambit/Mode/ConfigImportExportInterface.h | brhook-aws/aws-ambit-scenario-designer-ue4 | 4f1fea7d4ac27a4fad792607a1d6dbf2aa237747 | [
"Apache-2.0"
] | null | null | null | Ambit/Source/Ambit/Mode/ConfigImportExportInterface.h | brhook-aws/aws-ambit-scenario-designer-ue4 | 4f1fea7d4ac27a4fad792607a1d6dbf2aa237747 | [
"Apache-2.0"
] | null | null | null | Ambit/Source/Ambit/Mode/ConfigImportExportInterface.h | brhook-aws/aws-ambit-scenario-designer-ue4 | 4f1fea7d4ac27a4fad792607a1d6dbf2aa237747 | [
"Apache-2.0"
] | null | null | null | // Copyright Amazon.com, Inc. or its affiliates. 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 "ConfigImportExportInterface.generated.h"
class FJsonObject;
class FReply;
class FString;
/**
* Interface for ConfigImportExport.h and ConfigImportExportMock.h
*/
UINTERFACE()
class UConfigImportExportInterface : public UInterface
{
GENERATED_BODY()
};
class IConfigImportExportInterface
{
GENERATED_BODY()
public:
/**
* Starts the process to import an SDF file specified on screen.
*
* @return FReply When the process has finished.
*/
virtual FReply OnImportSdf() = 0;
/**
* Starts the process to export the SDF file specified. This process triggers asynchronous functions
* to handle the exporting, and does not actually export itself.
*
* @return FReply::Finished When the process has been started for the asynchronous handlings.
*/
virtual FReply OnExportSdf() = 0;
/**
* Based on the config settings from screen or the queued config settings from QueuedSdfConfigToExport,
* will combine those with the passed AmbitSpawnerArray into a standardized SDF format, and then
* writes the file.
* This function will attempt to create the S3 bucket, if bToS3 is selected.
* At the end of this function, if there are any more items in QueuedSdfConfigToExport, it will call
* PrepareAllSpawnersObjectConfigs to continue to the process of the queue.
*
*
* @param AmbitSpawnerArray A Mapping of FJsonValue (coming from SpawnerObjects), and the name of their JSON
* format to output for their location in the array.
* @param bToS3 Specifies whether the file should attempt to upload to S3 or save to disk.
*
* @return Boolean to indicate if the write was successful or not.
*/
virtual bool ProcessSdfForExport(const TMap<FString, TSharedPtr<FJsonObject>>& AmbitSpawnerArray, bool bToS3) = 0;
// Generate Permutations
/**
* Imports on a BSC file on disk.
*
* @return FReply::Finished When the process has finished.
*/
virtual FReply OnImportBsc() = 0;
/**
* Starts the process to export a BSC file and all permutations of
* it to a SDF into the on-screen specified S3 bucket location. The BSC
* process is synchronous, but the SDF process is asynchronous.
*
* @return FReply When the process has either finished (through error)
* or when the process was successful and the SDF has started.
*/
virtual FReply OnGeneratePermutations() = 0;
/**
* Imports on a BSC file in the specified Amazon S3.
*
* @return FReply::Finished when the process has finished (success or failure).
*/
virtual FReply OnReadFromS3Bucket() = 0;
/**
* Exports the current map into the Amazon S3 account specified.
*/
virtual FReply OnExportMap() = 0;
/**
* Exports the current scene as a glTF file (*.gltf or *.glb) into the Amazon S3 account specified.
*/
virtual FReply OnExportGltf() = 0;
};
| 35.281553 | 118 | 0.695102 |
aecaa679b105402aec641a19777afe6e84ab6a27 | 13,612 | c | C | lib/external/wolfssl/wolfcrypt/src/signature.c | Koneeee1/ms-tpm-20-ref | d99419bd30a4dad7ae5bfad3c1c0d5962c188913 | [
"BSD-2-Clause"
] | null | null | null | lib/external/wolfssl/wolfcrypt/src/signature.c | Koneeee1/ms-tpm-20-ref | d99419bd30a4dad7ae5bfad3c1c0d5962c188913 | [
"BSD-2-Clause"
] | null | null | null | lib/external/wolfssl/wolfcrypt/src/signature.c | Koneeee1/ms-tpm-20-ref | d99419bd30a4dad7ae5bfad3c1c0d5962c188913 | [
"BSD-2-Clause"
] | null | null | null | /* signature.c
*
* Copyright (C) 2006-2017 wolfSSL Inc.
*
* This file is part of wolfSSL.
*
* wolfSSL 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 2 of the License, or
* (at your option) any later version.
*
* wolfSSL 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, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <wolfssl/wolfcrypt/settings.h>
#include <wolfssl/wolfcrypt/signature.h>
#include <wolfssl/wolfcrypt/error-crypt.h>
#include <wolfssl/wolfcrypt/logging.h>
#ifndef NO_ASN
#include <wolfssl/wolfcrypt/asn.h>
#endif
#ifdef HAVE_ECC
#include <wolfssl/wolfcrypt/ecc.h>
#endif
#ifndef NO_RSA
#include <wolfssl/wolfcrypt/rsa.h>
#endif
/* If ECC and RSA are disabled then disable signature wrapper */
#if (!defined(HAVE_ECC) || (defined(HAVE_ECC) && !defined(HAVE_ECC_SIGN) \
&& !defined(HAVE_ECC_VERIFY))) && defined(NO_RSA)
#undef NO_SIG_WRAPPER
#define NO_SIG_WRAPPER
#endif
/* Signature wrapper disabled check */
#ifndef NO_SIG_WRAPPER
#if !defined(NO_RSA) && !defined(NO_ASN)
static int wc_SignatureDerEncode(enum wc_HashType hash_type, byte* hash_data,
word32 hash_len, word32* hash_enc_len)
{
int ret, oid;
ret = wc_HashGetOID(hash_type);
if (ret < 0) {
return ret;
}
oid = ret;
ret = wc_EncodeSignature(hash_data, hash_data, hash_len, oid);
if (ret > 0) {
*hash_enc_len = ret;
ret = 0;
}
return ret;
}
#endif /* !NO_RSA && !NO_ASN */
int wc_SignatureGetSize(enum wc_SignatureType sig_type,
const void* key, word32 key_len)
{
int sig_len = BAD_FUNC_ARG;
/* Suppress possible unused args if all signature types are disabled */
(void)key;
(void)key_len;
switch(sig_type) {
case WC_SIGNATURE_TYPE_ECC:
#ifdef HAVE_ECC
/* Sanity check that void* key is at least ecc_key in size */
if (key_len >= sizeof(ecc_key)) {
sig_len = wc_ecc_sig_size((ecc_key*)key);
}
else {
WOLFSSL_MSG("wc_SignatureGetSize: Invalid ECC key size");
}
#else
sig_len = SIG_TYPE_E;
#endif
break;
case WC_SIGNATURE_TYPE_RSA_W_ENC:
case WC_SIGNATURE_TYPE_RSA:
#ifndef NO_RSA
/* Sanity check that void* key is at least RsaKey in size */
if (key_len >= sizeof(RsaKey)) {
sig_len = wc_RsaEncryptSize((RsaKey*)key);
}
else {
WOLFSSL_MSG("wc_SignatureGetSize: Invalid RsaKey key size");
}
#else
sig_len = SIG_TYPE_E;
#endif
break;
case WC_SIGNATURE_TYPE_NONE:
default:
sig_len = BAD_FUNC_ARG;
break;
}
return sig_len;
}
int wc_SignatureVerifyHash(
enum wc_HashType hash_type, enum wc_SignatureType sig_type,
const byte* hash_data, word32 hash_len,
const byte* sig, word32 sig_len,
const void* key, word32 key_len)
{
int ret;
/* Check arguments */
if (hash_data == NULL || hash_len <= 0 ||
sig == NULL || sig_len <= 0 ||
key == NULL || key_len <= 0) {
return BAD_FUNC_ARG;
}
/* Validate signature len (1 to max is okay) */
if ((int)sig_len > wc_SignatureGetSize(sig_type, key, key_len)) {
WOLFSSL_MSG("wc_SignatureVerify: Invalid sig type/len");
return BAD_FUNC_ARG;
}
/* Validate hash size */
ret = wc_HashGetDigestSize(hash_type);
if (ret < 0) {
WOLFSSL_MSG("wc_SignatureVerify: Invalid hash type/len");
return ret;
}
ret = 0;
/* Verify signature using hash */
switch (sig_type) {
case WC_SIGNATURE_TYPE_ECC:
{
#if defined(HAVE_ECC) && defined(HAVE_ECC_VERIFY)
int is_valid_sig = 0;
/* Perform verification of signature using provided ECC key */
do {
#ifdef WOLFSSL_ASYNC_CRYPT
ret = wc_AsyncWait(ret, &((ecc_key*)key)->asyncDev,
WC_ASYNC_FLAG_CALL_AGAIN);
#endif
if (ret >= 0)
ret = wc_ecc_verify_hash(sig, sig_len, hash_data, hash_len,
&is_valid_sig, (ecc_key*)key);
} while (ret == WC_PENDING_E);
if (ret != 0 || is_valid_sig != 1) {
ret = SIG_VERIFY_E;
}
#else
ret = SIG_TYPE_E;
#endif
break;
}
case WC_SIGNATURE_TYPE_RSA_W_ENC:
case WC_SIGNATURE_TYPE_RSA:
{
#ifndef NO_RSA
word32 plain_len = hash_len;
byte *plain_data;
/* Make sure the plain text output is at least key size */
if (plain_len < sig_len) {
plain_len = sig_len;
}
plain_data = (byte*)XMALLOC(plain_len, NULL, DYNAMIC_TYPE_TMP_BUFFER);
if (plain_data) {
/* Perform verification of signature using provided RSA key */
do {
#ifdef WOLFSSL_ASYNC_CRYPT
ret = wc_AsyncWait(ret, &((RsaKey*)key)->asyncDev,
WC_ASYNC_FLAG_CALL_AGAIN);
#endif
if (ret >= 0)
ret = wc_RsaSSL_Verify(sig, sig_len, plain_data,
plain_len, (RsaKey*)key);
} while (ret == WC_PENDING_E);
if (ret >= 0) {
if ((word32)ret == hash_len &&
XMEMCMP(plain_data, hash_data, hash_len) == 0) {
ret = 0; /* Success */
}
else {
WOLFSSL_MSG("RSA Signature Verify difference!");
ret = SIG_VERIFY_E;
}
}
XFREE(plain_data, NULL, DYNAMIC_TYPE_TMP_BUFFER);
}
else {
ret = MEMORY_E;
}
#else
ret = SIG_TYPE_E;
#endif
break;
}
case WC_SIGNATURE_TYPE_NONE:
default:
ret = BAD_FUNC_ARG;
break;
}
return ret;
}
int wc_SignatureVerify(
enum wc_HashType hash_type, enum wc_SignatureType sig_type,
const byte* data, word32 data_len,
const byte* sig, word32 sig_len,
const void* key, word32 key_len)
{
int ret;
word32 hash_len, hash_enc_len;
#ifdef WOLFSSL_SMALL_STACK
byte *hash_data;
#else
byte hash_data[MAX_DER_DIGEST_SZ];
#endif
/* Check arguments */
if (data == NULL || data_len <= 0 ||
sig == NULL || sig_len <= 0 ||
key == NULL || key_len <= 0) {
return BAD_FUNC_ARG;
}
/* Validate signature len (1 to max is okay) */
if ((int)sig_len > wc_SignatureGetSize(sig_type, key, key_len)) {
WOLFSSL_MSG("wc_SignatureVerify: Invalid sig type/len");
return BAD_FUNC_ARG;
}
/* Validate hash size */
ret = wc_HashGetDigestSize(hash_type);
if (ret < 0) {
WOLFSSL_MSG("wc_SignatureVerify: Invalid hash type/len");
return ret;
}
hash_enc_len = hash_len = ret;
#ifndef NO_RSA
if (sig_type == WC_SIGNATURE_TYPE_RSA_W_ENC) {
/* For RSA with ASN.1 encoding include room */
hash_enc_len += MAX_DER_DIGEST_ASN_SZ;
}
#endif
#ifdef WOLFSSL_SMALL_STACK
/* Allocate temporary buffer for hash data */
hash_data = (byte*)XMALLOC(hash_enc_len, NULL, DYNAMIC_TYPE_TMP_BUFFER);
if (hash_data == NULL) {
return MEMORY_E;
}
#endif
/* Perform hash of data */
ret = wc_Hash(hash_type, data, data_len, hash_data, hash_len);
if (ret == 0) {
/* Handle RSA with DER encoding */
if (sig_type == WC_SIGNATURE_TYPE_RSA_W_ENC) {
#if defined(NO_RSA) || defined(NO_ASN)
ret = SIG_TYPE_E;
#else
ret = wc_SignatureDerEncode(hash_type, hash_data, hash_len,
&hash_enc_len);
#endif
}
if (ret == 0) {
/* Verify signature using hash */
ret = wc_SignatureVerifyHash(hash_type, sig_type,
hash_data, hash_enc_len, sig, sig_len, key, key_len);
}
}
#ifdef WOLFSSL_SMALL_STACK
XFREE(hash_data, NULL, DYNAMIC_TYPE_TMP_BUFFER);
#endif
return ret;
}
int wc_SignatureGenerateHash(
enum wc_HashType hash_type, enum wc_SignatureType sig_type,
const byte* hash_data, word32 hash_len,
byte* sig, word32 *sig_len,
const void* key, word32 key_len, WC_RNG* rng)
{
int ret;
/* Suppress possible unused arg if all signature types are disabled */
(void)rng;
/* Check arguments */
if (hash_data == NULL || hash_len <= 0 ||
sig == NULL || sig_len == NULL || *sig_len <= 0 ||
key == NULL || key_len <= 0) {
return BAD_FUNC_ARG;
}
/* Validate signature len (needs to be at least max) */
if ((int)*sig_len < wc_SignatureGetSize(sig_type, key, key_len)) {
WOLFSSL_MSG("wc_SignatureGenerate: Invalid sig type/len");
return BAD_FUNC_ARG;
}
/* Validate hash size */
ret = wc_HashGetDigestSize(hash_type);
if (ret < 0) {
WOLFSSL_MSG("wc_SignatureGenerate: Invalid hash type/len");
return ret;
}
ret = 0;
/* Create signature using hash as data */
switch (sig_type) {
case WC_SIGNATURE_TYPE_ECC:
#if defined(HAVE_ECC) && defined(HAVE_ECC_SIGN)
/* Create signature using provided ECC key */
do {
#ifdef WOLFSSL_ASYNC_CRYPT
ret = wc_AsyncWait(ret, &((ecc_key*)key)->asyncDev,
WC_ASYNC_FLAG_CALL_AGAIN);
#endif
if (ret >= 0)
ret = wc_ecc_sign_hash(hash_data, hash_len, sig, sig_len,
rng, (ecc_key*)key);
} while (ret == WC_PENDING_E);
#else
ret = SIG_TYPE_E;
#endif
break;
case WC_SIGNATURE_TYPE_RSA_W_ENC:
case WC_SIGNATURE_TYPE_RSA:
#if !defined(NO_RSA) && !defined(WOLFSSL_RSA_PUBLIC_ONLY)
/* Create signature using provided RSA key */
do {
#ifdef WOLFSSL_ASYNC_CRYPT
ret = wc_AsyncWait(ret, &((RsaKey*)key)->asyncDev,
WC_ASYNC_FLAG_CALL_AGAIN);
#endif
if (ret >= 0)
ret = wc_RsaSSL_Sign(hash_data, hash_len, sig, *sig_len,
(RsaKey*)key, rng);
} while (ret == WC_PENDING_E);
if (ret >= 0) {
*sig_len = ret;
ret = 0; /* Success */
}
#else
ret = SIG_TYPE_E;
#endif
break;
case WC_SIGNATURE_TYPE_NONE:
default:
ret = BAD_FUNC_ARG;
break;
}
return ret;
}
int wc_SignatureGenerate(
enum wc_HashType hash_type, enum wc_SignatureType sig_type,
const byte* data, word32 data_len,
byte* sig, word32 *sig_len,
const void* key, word32 key_len, WC_RNG* rng)
{
int ret;
word32 hash_len, hash_enc_len;
#ifdef WOLFSSL_SMALL_STACK
byte *hash_data;
#else
byte hash_data[MAX_DER_DIGEST_SZ];
#endif
/* Check arguments */
if (data == NULL || data_len <= 0 ||
sig == NULL || sig_len == NULL || *sig_len <= 0 ||
key == NULL || key_len <= 0) {
return BAD_FUNC_ARG;
}
/* Validate signature len (needs to be at least max) */
if ((int)*sig_len < wc_SignatureGetSize(sig_type, key, key_len)) {
WOLFSSL_MSG("wc_SignatureGenerate: Invalid sig type/len");
return BAD_FUNC_ARG;
}
/* Validate hash size */
ret = wc_HashGetDigestSize(hash_type);
if (ret < 0) {
WOLFSSL_MSG("wc_SignatureGenerate: Invalid hash type/len");
return ret;
}
hash_enc_len = hash_len = ret;
#if !defined(NO_RSA) && !defined(WOLFSSL_RSA_PUBLIC_ONLY)
if (sig_type == WC_SIGNATURE_TYPE_RSA_W_ENC) {
/* For RSA with ASN.1 encoding include room */
hash_enc_len += MAX_DER_DIGEST_ASN_SZ;
}
#endif
#ifdef WOLFSSL_SMALL_STACK
/* Allocate temporary buffer for hash data */
hash_data = (byte*)XMALLOC(hash_enc_len, NULL, DYNAMIC_TYPE_TMP_BUFFER);
if (hash_data == NULL) {
return MEMORY_E;
}
#endif
/* Perform hash of data */
ret = wc_Hash(hash_type, data, data_len, hash_data, hash_len);
if (ret == 0) {
/* Handle RSA with DER encoding */
if (sig_type == WC_SIGNATURE_TYPE_RSA_W_ENC) {
#if defined(NO_RSA) || defined(NO_ASN) || \
defined(WOLFSSL_RSA_PUBLIC_ONLY)
ret = SIG_TYPE_E;
#else
ret = wc_SignatureDerEncode(hash_type, hash_data, hash_len,
&hash_enc_len);
#endif
}
if (ret == 0) {
/* Generate signature using hash */
ret = wc_SignatureGenerateHash(hash_type, sig_type,
hash_data, hash_enc_len, sig, sig_len, key, key_len, rng);
}
}
#ifdef WOLFSSL_SMALL_STACK
XFREE(hash_data, NULL, DYNAMIC_TYPE_TMP_BUFFER);
#endif
return ret;
}
#endif /* NO_SIG_WRAPPER */
| 29.147752 | 82 | 0.582868 |
aecc7ba1cb0139a4aa904bcfff6d80b8c7d57100 | 294 | h | C | include/vdtnet/platform.h | vitodtagliente/vdtnet | c5f43db256a1ba9e69bc38ee149d5d75f732c154 | [
"MIT"
] | null | null | null | include/vdtnet/platform.h | vitodtagliente/vdtnet | c5f43db256a1ba9e69bc38ee149d5d75f732c154 | [
"MIT"
] | null | null | null | include/vdtnet/platform.h | vitodtagliente/vdtnet | c5f43db256a1ba9e69bc38ee149d5d75f732c154 | [
"MIT"
] | null | null | null | /// Copyright (c) Vito Domenico Tagliente
#pragma once
namespace net
{
#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(__MINGW32__)
#define PLATFORM_WINDOWS 1
#elif defined( __linux__ )
#define PLATFORM_LINUX 1
#elif defined( __APPLE__ )
#define PLATFORM_OSX 1
#endif
} | 21 | 83 | 0.755102 |
aecee69006bd3439df5b19488e72226a3da64f52 | 201,591 | h | C | test/aarch32/traces/assembler-cond-rd-operand-rn-shift-amount-1to31-mvn-t32.h | capablevms/VIXL | 769c8e46a09bb077e9a2148b86a2093addce8233 | [
"BSD-3-Clause"
] | 573 | 2016-08-31T20:21:20.000Z | 2021-08-29T14:01:11.000Z | test/aarch32/traces/assembler-cond-rd-operand-rn-shift-amount-1to31-mvn-t32.h | capablevms/VIXL | 769c8e46a09bb077e9a2148b86a2093addce8233 | [
"BSD-3-Clause"
] | 366 | 2016-09-02T06:37:43.000Z | 2021-08-11T18:38:24.000Z | test/aarch32/traces/assembler-cond-rd-operand-rn-shift-amount-1to31-mvn-t32.h | capablevms/VIXL | 769c8e46a09bb077e9a2148b86a2093addce8233 | [
"BSD-3-Clause"
] | 135 | 2016-09-01T02:02:58.000Z | 2021-08-13T01:25:22.000Z | // Copyright 2015, VIXL 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:
//
// * 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 ARM Limited 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 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.
// ---------------------------------------------------------------------
// This file is auto generated using tools/generate_simulator_traces.py.
//
// PLEASE DO NOT EDIT.
// ---------------------------------------------------------------------
#ifndef VIXL_ASSEMBLER_COND_RD_OPERAND_RN_SHIFT_AMOUNT_1TO31_MVN_T32_H_
#define VIXL_ASSEMBLER_COND_RD_OPERAND_RN_SHIFT_AMOUNT_1TO31_MVN_T32_H_
const byte kInstruction_mvn_al_r14_r8_ROR_21[] = {
0x6f, 0xea, 0x78, 0x5e // mvn al r14 r8 ROR 21
};
const byte kInstruction_mvn_al_r5_r13_ROR_4[] = {
0x6f, 0xea, 0x3d, 0x15 // mvn al r5 r13 ROR 4
};
const byte kInstruction_mvn_al_r0_r3_ROR_4[] = {
0x6f, 0xea, 0x33, 0x10 // mvn al r0 r3 ROR 4
};
const byte kInstruction_mvn_al_r3_r14_ROR_7[] = {
0x6f, 0xea, 0xfe, 0x13 // mvn al r3 r14 ROR 7
};
const byte kInstruction_mvn_al_r2_r6_LSL_30[] = {
0x6f, 0xea, 0x86, 0x72 // mvn al r2 r6 LSL 30
};
const byte kInstruction_mvn_al_r11_r4_LSL_26[] = {
0x6f, 0xea, 0x84, 0x6b // mvn al r11 r4 LSL 26
};
const byte kInstruction_mvn_al_r7_r0_LSL_30[] = {
0x6f, 0xea, 0x80, 0x77 // mvn al r7 r0 LSL 30
};
const byte kInstruction_mvn_al_r0_r9_ROR_17[] = {
0x6f, 0xea, 0x79, 0x40 // mvn al r0 r9 ROR 17
};
const byte kInstruction_mvn_al_r11_r3_ROR_31[] = {
0x6f, 0xea, 0xf3, 0x7b // mvn al r11 r3 ROR 31
};
const byte kInstruction_mvn_al_r8_r8_ROR_20[] = {
0x6f, 0xea, 0x38, 0x58 // mvn al r8 r8 ROR 20
};
const byte kInstruction_mvn_al_r11_r13_LSL_24[] = {
0x6f, 0xea, 0x0d, 0x6b // mvn al r11 r13 LSL 24
};
const byte kInstruction_mvn_al_r1_r3_ROR_27[] = {
0x6f, 0xea, 0xf3, 0x61 // mvn al r1 r3 ROR 27
};
const byte kInstruction_mvn_al_r9_r10_ROR_5[] = {
0x6f, 0xea, 0x7a, 0x19 // mvn al r9 r10 ROR 5
};
const byte kInstruction_mvn_al_r3_r11_ROR_25[] = {
0x6f, 0xea, 0x7b, 0x63 // mvn al r3 r11 ROR 25
};
const byte kInstruction_mvn_al_r2_r6_LSL_7[] = {
0x6f, 0xea, 0xc6, 0x12 // mvn al r2 r6 LSL 7
};
const byte kInstruction_mvn_al_r3_r12_ROR_8[] = {
0x6f, 0xea, 0x3c, 0x23 // mvn al r3 r12 ROR 8
};
const byte kInstruction_mvn_al_r0_r0_LSL_14[] = {
0x6f, 0xea, 0x80, 0x30 // mvn al r0 r0 LSL 14
};
const byte kInstruction_mvn_al_r8_r10_ROR_2[] = {
0x6f, 0xea, 0xba, 0x08 // mvn al r8 r10 ROR 2
};
const byte kInstruction_mvn_al_r0_r8_LSL_31[] = {
0x6f, 0xea, 0xc8, 0x70 // mvn al r0 r8 LSL 31
};
const byte kInstruction_mvn_al_r1_r14_ROR_27[] = {
0x6f, 0xea, 0xfe, 0x61 // mvn al r1 r14 ROR 27
};
const byte kInstruction_mvn_al_r14_r2_ROR_27[] = {
0x6f, 0xea, 0xf2, 0x6e // mvn al r14 r2 ROR 27
};
const byte kInstruction_mvn_al_r3_r10_LSL_25[] = {
0x6f, 0xea, 0x4a, 0x63 // mvn al r3 r10 LSL 25
};
const byte kInstruction_mvn_al_r13_r8_ROR_6[] = {
0x6f, 0xea, 0xb8, 0x1d // mvn al r13 r8 ROR 6
};
const byte kInstruction_mvn_al_r5_r12_ROR_7[] = {
0x6f, 0xea, 0xfc, 0x15 // mvn al r5 r12 ROR 7
};
const byte kInstruction_mvn_al_r7_r8_LSL_10[] = {
0x6f, 0xea, 0x88, 0x27 // mvn al r7 r8 LSL 10
};
const byte kInstruction_mvn_al_r9_r12_ROR_10[] = {
0x6f, 0xea, 0xbc, 0x29 // mvn al r9 r12 ROR 10
};
const byte kInstruction_mvn_al_r8_r6_ROR_12[] = {
0x6f, 0xea, 0x36, 0x38 // mvn al r8 r6 ROR 12
};
const byte kInstruction_mvn_al_r8_r10_LSL_7[] = {
0x6f, 0xea, 0xca, 0x18 // mvn al r8 r10 LSL 7
};
const byte kInstruction_mvn_al_r5_r12_ROR_8[] = {
0x6f, 0xea, 0x3c, 0x25 // mvn al r5 r12 ROR 8
};
const byte kInstruction_mvn_al_r0_r13_LSL_21[] = {
0x6f, 0xea, 0x4d, 0x50 // mvn al r0 r13 LSL 21
};
const byte kInstruction_mvn_al_r2_r0_LSL_7[] = {
0x6f, 0xea, 0xc0, 0x12 // mvn al r2 r0 LSL 7
};
const byte kInstruction_mvn_al_r10_r2_LSL_22[] = {
0x6f, 0xea, 0x82, 0x5a // mvn al r10 r2 LSL 22
};
const byte kInstruction_mvn_al_r4_r11_ROR_2[] = {
0x6f, 0xea, 0xbb, 0x04 // mvn al r4 r11 ROR 2
};
const byte kInstruction_mvn_al_r11_r14_LSL_14[] = {
0x6f, 0xea, 0x8e, 0x3b // mvn al r11 r14 LSL 14
};
const byte kInstruction_mvn_al_r8_r0_LSL_23[] = {
0x6f, 0xea, 0xc0, 0x58 // mvn al r8 r0 LSL 23
};
const byte kInstruction_mvn_al_r10_r4_LSL_12[] = {
0x6f, 0xea, 0x04, 0x3a // mvn al r10 r4 LSL 12
};
const byte kInstruction_mvn_al_r4_r5_ROR_28[] = {
0x6f, 0xea, 0x35, 0x74 // mvn al r4 r5 ROR 28
};
const byte kInstruction_mvn_al_r1_r5_LSL_25[] = {
0x6f, 0xea, 0x45, 0x61 // mvn al r1 r5 LSL 25
};
const byte kInstruction_mvn_al_r7_r10_ROR_16[] = {
0x6f, 0xea, 0x3a, 0x47 // mvn al r7 r10 ROR 16
};
const byte kInstruction_mvn_al_r3_r0_LSL_31[] = {
0x6f, 0xea, 0xc0, 0x73 // mvn al r3 r0 LSL 31
};
const byte kInstruction_mvn_al_r2_r2_LSL_2[] = {
0x6f, 0xea, 0x82, 0x02 // mvn al r2 r2 LSL 2
};
const byte kInstruction_mvn_al_r8_r1_LSL_9[] = {
0x6f, 0xea, 0x41, 0x28 // mvn al r8 r1 LSL 9
};
const byte kInstruction_mvn_al_r13_r6_LSL_6[] = {
0x6f, 0xea, 0x86, 0x1d // mvn al r13 r6 LSL 6
};
const byte kInstruction_mvn_al_r0_r8_LSL_13[] = {
0x6f, 0xea, 0x48, 0x30 // mvn al r0 r8 LSL 13
};
const byte kInstruction_mvn_al_r11_r8_ROR_3[] = {
0x6f, 0xea, 0xf8, 0x0b // mvn al r11 r8 ROR 3
};
const byte kInstruction_mvn_al_r8_r1_LSL_13[] = {
0x6f, 0xea, 0x41, 0x38 // mvn al r8 r1 LSL 13
};
const byte kInstruction_mvn_al_r6_r2_LSL_13[] = {
0x6f, 0xea, 0x42, 0x36 // mvn al r6 r2 LSL 13
};
const byte kInstruction_mvn_al_r4_r1_LSL_16[] = {
0x6f, 0xea, 0x01, 0x44 // mvn al r4 r1 LSL 16
};
const byte kInstruction_mvn_al_r0_r4_LSL_9[] = {
0x6f, 0xea, 0x44, 0x20 // mvn al r0 r4 LSL 9
};
const byte kInstruction_mvn_al_r11_r8_ROR_8[] = {
0x6f, 0xea, 0x38, 0x2b // mvn al r11 r8 ROR 8
};
const byte kInstruction_mvn_al_r9_r12_LSL_5[] = {
0x6f, 0xea, 0x4c, 0x19 // mvn al r9 r12 LSL 5
};
const byte kInstruction_mvn_al_r13_r9_ROR_13[] = {
0x6f, 0xea, 0x79, 0x3d // mvn al r13 r9 ROR 13
};
const byte kInstruction_mvn_al_r2_r0_ROR_23[] = {
0x6f, 0xea, 0xf0, 0x52 // mvn al r2 r0 ROR 23
};
const byte kInstruction_mvn_al_r7_r8_ROR_6[] = {
0x6f, 0xea, 0xb8, 0x17 // mvn al r7 r8 ROR 6
};
const byte kInstruction_mvn_al_r2_r6_LSL_11[] = {
0x6f, 0xea, 0xc6, 0x22 // mvn al r2 r6 LSL 11
};
const byte kInstruction_mvn_al_r2_r13_LSL_12[] = {
0x6f, 0xea, 0x0d, 0x32 // mvn al r2 r13 LSL 12
};
const byte kInstruction_mvn_al_r7_r4_LSL_13[] = {
0x6f, 0xea, 0x44, 0x37 // mvn al r7 r4 LSL 13
};
const byte kInstruction_mvn_al_r8_r4_LSL_1[] = {
0x6f, 0xea, 0x44, 0x08 // mvn al r8 r4 LSL 1
};
const byte kInstruction_mvn_al_r14_r4_LSL_8[] = {
0x6f, 0xea, 0x04, 0x2e // mvn al r14 r4 LSL 8
};
const byte kInstruction_mvn_al_r7_r9_ROR_20[] = {
0x6f, 0xea, 0x39, 0x57 // mvn al r7 r9 ROR 20
};
const byte kInstruction_mvn_al_r4_r3_ROR_6[] = {
0x6f, 0xea, 0xb3, 0x14 // mvn al r4 r3 ROR 6
};
const byte kInstruction_mvn_al_r3_r12_LSL_2[] = {
0x6f, 0xea, 0x8c, 0x03 // mvn al r3 r12 LSL 2
};
const byte kInstruction_mvn_al_r12_r9_ROR_7[] = {
0x6f, 0xea, 0xf9, 0x1c // mvn al r12 r9 ROR 7
};
const byte kInstruction_mvn_al_r0_r2_LSL_17[] = {
0x6f, 0xea, 0x42, 0x40 // mvn al r0 r2 LSL 17
};
const byte kInstruction_mvn_al_r14_r3_LSL_28[] = {
0x6f, 0xea, 0x03, 0x7e // mvn al r14 r3 LSL 28
};
const byte kInstruction_mvn_al_r14_r12_ROR_15[] = {
0x6f, 0xea, 0xfc, 0x3e // mvn al r14 r12 ROR 15
};
const byte kInstruction_mvn_al_r8_r0_ROR_8[] = {
0x6f, 0xea, 0x30, 0x28 // mvn al r8 r0 ROR 8
};
const byte kInstruction_mvn_al_r2_r11_LSL_20[] = {
0x6f, 0xea, 0x0b, 0x52 // mvn al r2 r11 LSL 20
};
const byte kInstruction_mvn_al_r8_r13_LSL_30[] = {
0x6f, 0xea, 0x8d, 0x78 // mvn al r8 r13 LSL 30
};
const byte kInstruction_mvn_al_r2_r9_LSL_24[] = {
0x6f, 0xea, 0x09, 0x62 // mvn al r2 r9 LSL 24
};
const byte kInstruction_mvn_al_r12_r1_LSL_2[] = {
0x6f, 0xea, 0x81, 0x0c // mvn al r12 r1 LSL 2
};
const byte kInstruction_mvn_al_r7_r1_ROR_7[] = {
0x6f, 0xea, 0xf1, 0x17 // mvn al r7 r1 ROR 7
};
const byte kInstruction_mvn_al_r11_r7_ROR_30[] = {
0x6f, 0xea, 0xb7, 0x7b // mvn al r11 r7 ROR 30
};
const byte kInstruction_mvn_al_r0_r9_ROR_22[] = {
0x6f, 0xea, 0xb9, 0x50 // mvn al r0 r9 ROR 22
};
const byte kInstruction_mvn_al_r14_r9_ROR_17[] = {
0x6f, 0xea, 0x79, 0x4e // mvn al r14 r9 ROR 17
};
const byte kInstruction_mvn_al_r3_r14_LSL_3[] = {
0x6f, 0xea, 0xce, 0x03 // mvn al r3 r14 LSL 3
};
const byte kInstruction_mvn_al_r0_r0_ROR_30[] = {
0x6f, 0xea, 0xb0, 0x70 // mvn al r0 r0 ROR 30
};
const byte kInstruction_mvn_al_r9_r8_LSL_4[] = {
0x6f, 0xea, 0x08, 0x19 // mvn al r9 r8 LSL 4
};
const byte kInstruction_mvn_al_r8_r13_LSL_16[] = {
0x6f, 0xea, 0x0d, 0x48 // mvn al r8 r13 LSL 16
};
const byte kInstruction_mvn_al_r0_r8_ROR_28[] = {
0x6f, 0xea, 0x38, 0x70 // mvn al r0 r8 ROR 28
};
const byte kInstruction_mvn_al_r11_r10_LSL_23[] = {
0x6f, 0xea, 0xca, 0x5b // mvn al r11 r10 LSL 23
};
const byte kInstruction_mvn_al_r11_r4_LSL_27[] = {
0x6f, 0xea, 0xc4, 0x6b // mvn al r11 r4 LSL 27
};
const byte kInstruction_mvn_al_r2_r2_LSL_30[] = {
0x6f, 0xea, 0x82, 0x72 // mvn al r2 r2 LSL 30
};
const byte kInstruction_mvn_al_r5_r4_LSL_17[] = {
0x6f, 0xea, 0x44, 0x45 // mvn al r5 r4 LSL 17
};
const byte kInstruction_mvn_al_r11_r12_LSL_1[] = {
0x6f, 0xea, 0x4c, 0x0b // mvn al r11 r12 LSL 1
};
const byte kInstruction_mvn_al_r0_r14_ROR_21[] = {
0x6f, 0xea, 0x7e, 0x50 // mvn al r0 r14 ROR 21
};
const byte kInstruction_mvn_al_r11_r5_ROR_21[] = {
0x6f, 0xea, 0x75, 0x5b // mvn al r11 r5 ROR 21
};
const byte kInstruction_mvn_al_r6_r14_LSL_14[] = {
0x6f, 0xea, 0x8e, 0x36 // mvn al r6 r14 LSL 14
};
const byte kInstruction_mvn_al_r1_r9_LSL_24[] = {
0x6f, 0xea, 0x09, 0x61 // mvn al r1 r9 LSL 24
};
const byte kInstruction_mvn_al_r5_r2_LSL_22[] = {
0x6f, 0xea, 0x82, 0x55 // mvn al r5 r2 LSL 22
};
const byte kInstruction_mvn_al_r3_r5_LSL_4[] = {
0x6f, 0xea, 0x05, 0x13 // mvn al r3 r5 LSL 4
};
const byte kInstruction_mvn_al_r8_r0_LSL_5[] = {
0x6f, 0xea, 0x40, 0x18 // mvn al r8 r0 LSL 5
};
const byte kInstruction_mvn_al_r5_r14_ROR_13[] = {
0x6f, 0xea, 0x7e, 0x35 // mvn al r5 r14 ROR 13
};
const byte kInstruction_mvn_al_r12_r11_LSL_27[] = {
0x6f, 0xea, 0xcb, 0x6c // mvn al r12 r11 LSL 27
};
const byte kInstruction_mvn_al_r10_r14_LSL_20[] = {
0x6f, 0xea, 0x0e, 0x5a // mvn al r10 r14 LSL 20
};
const byte kInstruction_mvn_al_r5_r9_ROR_4[] = {
0x6f, 0xea, 0x39, 0x15 // mvn al r5 r9 ROR 4
};
const byte kInstruction_mvn_al_r8_r11_ROR_11[] = {
0x6f, 0xea, 0xfb, 0x28 // mvn al r8 r11 ROR 11
};
const byte kInstruction_mvn_al_r4_r1_LSL_24[] = {
0x6f, 0xea, 0x01, 0x64 // mvn al r4 r1 LSL 24
};
const byte kInstruction_mvn_al_r7_r10_ROR_4[] = {
0x6f, 0xea, 0x3a, 0x17 // mvn al r7 r10 ROR 4
};
const byte kInstruction_mvn_al_r3_r0_ROR_11[] = {
0x6f, 0xea, 0xf0, 0x23 // mvn al r3 r0 ROR 11
};
const byte kInstruction_mvn_al_r3_r10_ROR_23[] = {
0x6f, 0xea, 0xfa, 0x53 // mvn al r3 r10 ROR 23
};
const byte kInstruction_mvn_al_r2_r8_LSL_15[] = {
0x6f, 0xea, 0xc8, 0x32 // mvn al r2 r8 LSL 15
};
const byte kInstruction_mvn_al_r3_r6_LSL_18[] = {
0x6f, 0xea, 0x86, 0x43 // mvn al r3 r6 LSL 18
};
const byte kInstruction_mvn_al_r10_r2_ROR_7[] = {
0x6f, 0xea, 0xf2, 0x1a // mvn al r10 r2 ROR 7
};
const byte kInstruction_mvn_al_r6_r6_ROR_14[] = {
0x6f, 0xea, 0xb6, 0x36 // mvn al r6 r6 ROR 14
};
const byte kInstruction_mvn_al_r1_r8_LSL_25[] = {
0x6f, 0xea, 0x48, 0x61 // mvn al r1 r8 LSL 25
};
const byte kInstruction_mvn_al_r0_r14_LSL_13[] = {
0x6f, 0xea, 0x4e, 0x30 // mvn al r0 r14 LSL 13
};
const byte kInstruction_mvn_al_r14_r1_LSL_13[] = {
0x6f, 0xea, 0x41, 0x3e // mvn al r14 r1 LSL 13
};
const byte kInstruction_mvn_al_r8_r11_ROR_8[] = {
0x6f, 0xea, 0x3b, 0x28 // mvn al r8 r11 ROR 8
};
const byte kInstruction_mvn_al_r0_r12_ROR_6[] = {
0x6f, 0xea, 0xbc, 0x10 // mvn al r0 r12 ROR 6
};
const byte kInstruction_mvn_al_r0_r12_LSL_26[] = {
0x6f, 0xea, 0x8c, 0x60 // mvn al r0 r12 LSL 26
};
const byte kInstruction_mvn_al_r11_r2_LSL_10[] = {
0x6f, 0xea, 0x82, 0x2b // mvn al r11 r2 LSL 10
};
const byte kInstruction_mvn_al_r12_r7_LSL_3[] = {
0x6f, 0xea, 0xc7, 0x0c // mvn al r12 r7 LSL 3
};
const byte kInstruction_mvn_al_r6_r10_LSL_25[] = {
0x6f, 0xea, 0x4a, 0x66 // mvn al r6 r10 LSL 25
};
const byte kInstruction_mvn_al_r12_r7_ROR_8[] = {
0x6f, 0xea, 0x37, 0x2c // mvn al r12 r7 ROR 8
};
const byte kInstruction_mvn_al_r3_r3_ROR_24[] = {
0x6f, 0xea, 0x33, 0x63 // mvn al r3 r3 ROR 24
};
const byte kInstruction_mvn_al_r9_r12_LSL_24[] = {
0x6f, 0xea, 0x0c, 0x69 // mvn al r9 r12 LSL 24
};
const byte kInstruction_mvn_al_r14_r10_LSL_27[] = {
0x6f, 0xea, 0xca, 0x6e // mvn al r14 r10 LSL 27
};
const byte kInstruction_mvn_al_r6_r5_ROR_4[] = {
0x6f, 0xea, 0x35, 0x16 // mvn al r6 r5 ROR 4
};
const byte kInstruction_mvn_al_r7_r4_LSL_21[] = {
0x6f, 0xea, 0x44, 0x57 // mvn al r7 r4 LSL 21
};
const byte kInstruction_mvn_al_r2_r4_ROR_31[] = {
0x6f, 0xea, 0xf4, 0x72 // mvn al r2 r4 ROR 31
};
const byte kInstruction_mvn_al_r11_r7_ROR_8[] = {
0x6f, 0xea, 0x37, 0x2b // mvn al r11 r7 ROR 8
};
const byte kInstruction_mvn_al_r5_r2_ROR_17[] = {
0x6f, 0xea, 0x72, 0x45 // mvn al r5 r2 ROR 17
};
const byte kInstruction_mvn_al_r1_r11_LSL_13[] = {
0x6f, 0xea, 0x4b, 0x31 // mvn al r1 r11 LSL 13
};
const byte kInstruction_mvn_al_r7_r11_ROR_2[] = {
0x6f, 0xea, 0xbb, 0x07 // mvn al r7 r11 ROR 2
};
const byte kInstruction_mvn_al_r1_r7_ROR_29[] = {
0x6f, 0xea, 0x77, 0x71 // mvn al r1 r7 ROR 29
};
const byte kInstruction_mvn_al_r4_r1_LSL_31[] = {
0x6f, 0xea, 0xc1, 0x74 // mvn al r4 r1 LSL 31
};
const byte kInstruction_mvn_al_r11_r13_ROR_11[] = {
0x6f, 0xea, 0xfd, 0x2b // mvn al r11 r13 ROR 11
};
const byte kInstruction_mvn_al_r13_r1_ROR_14[] = {
0x6f, 0xea, 0xb1, 0x3d // mvn al r13 r1 ROR 14
};
const byte kInstruction_mvn_al_r1_r14_ROR_21[] = {
0x6f, 0xea, 0x7e, 0x51 // mvn al r1 r14 ROR 21
};
const byte kInstruction_mvn_al_r7_r12_LSL_5[] = {
0x6f, 0xea, 0x4c, 0x17 // mvn al r7 r12 LSL 5
};
const byte kInstruction_mvn_al_r10_r3_LSL_2[] = {
0x6f, 0xea, 0x83, 0x0a // mvn al r10 r3 LSL 2
};
const byte kInstruction_mvn_al_r12_r10_ROR_25[] = {
0x6f, 0xea, 0x7a, 0x6c // mvn al r12 r10 ROR 25
};
const byte kInstruction_mvn_al_r2_r7_LSL_6[] = {
0x6f, 0xea, 0x87, 0x12 // mvn al r2 r7 LSL 6
};
const byte kInstruction_mvn_al_r5_r0_LSL_23[] = {
0x6f, 0xea, 0xc0, 0x55 // mvn al r5 r0 LSL 23
};
const byte kInstruction_mvn_al_r2_r8_ROR_18[] = {
0x6f, 0xea, 0xb8, 0x42 // mvn al r2 r8 ROR 18
};
const byte kInstruction_mvn_al_r0_r1_ROR_15[] = {
0x6f, 0xea, 0xf1, 0x30 // mvn al r0 r1 ROR 15
};
const byte kInstruction_mvn_al_r14_r4_ROR_20[] = {
0x6f, 0xea, 0x34, 0x5e // mvn al r14 r4 ROR 20
};
const byte kInstruction_mvn_al_r5_r10_LSL_15[] = {
0x6f, 0xea, 0xca, 0x35 // mvn al r5 r10 LSL 15
};
const byte kInstruction_mvn_al_r0_r1_ROR_28[] = {
0x6f, 0xea, 0x31, 0x70 // mvn al r0 r1 ROR 28
};
const byte kInstruction_mvn_al_r11_r2_LSL_9[] = {
0x6f, 0xea, 0x42, 0x2b // mvn al r11 r2 LSL 9
};
const byte kInstruction_mvn_al_r9_r10_LSL_19[] = {
0x6f, 0xea, 0xca, 0x49 // mvn al r9 r10 LSL 19
};
const byte kInstruction_mvn_al_r4_r11_LSL_8[] = {
0x6f, 0xea, 0x0b, 0x24 // mvn al r4 r11 LSL 8
};
const byte kInstruction_mvn_al_r12_r14_LSL_12[] = {
0x6f, 0xea, 0x0e, 0x3c // mvn al r12 r14 LSL 12
};
const byte kInstruction_mvn_al_r5_r9_LSL_8[] = {
0x6f, 0xea, 0x09, 0x25 // mvn al r5 r9 LSL 8
};
const byte kInstruction_mvn_al_r12_r14_LSL_16[] = {
0x6f, 0xea, 0x0e, 0x4c // mvn al r12 r14 LSL 16
};
const byte kInstruction_mvn_al_r13_r13_LSL_23[] = {
0x6f, 0xea, 0xcd, 0x5d // mvn al r13 r13 LSL 23
};
const byte kInstruction_mvn_al_r3_r12_ROR_19[] = {
0x6f, 0xea, 0xfc, 0x43 // mvn al r3 r12 ROR 19
};
const byte kInstruction_mvn_al_r2_r5_ROR_24[] = {
0x6f, 0xea, 0x35, 0x62 // mvn al r2 r5 ROR 24
};
const byte kInstruction_mvn_al_r3_r2_ROR_11[] = {
0x6f, 0xea, 0xf2, 0x23 // mvn al r3 r2 ROR 11
};
const byte kInstruction_mvn_al_r1_r13_ROR_1[] = {
0x6f, 0xea, 0x7d, 0x01 // mvn al r1 r13 ROR 1
};
const byte kInstruction_mvn_al_r6_r7_LSL_11[] = {
0x6f, 0xea, 0xc7, 0x26 // mvn al r6 r7 LSL 11
};
const byte kInstruction_mvn_al_r3_r14_LSL_2[] = {
0x6f, 0xea, 0x8e, 0x03 // mvn al r3 r14 LSL 2
};
const byte kInstruction_mvn_al_r0_r10_LSL_20[] = {
0x6f, 0xea, 0x0a, 0x50 // mvn al r0 r10 LSL 20
};
const byte kInstruction_mvn_al_r3_r0_LSL_19[] = {
0x6f, 0xea, 0xc0, 0x43 // mvn al r3 r0 LSL 19
};
const byte kInstruction_mvn_al_r14_r0_ROR_21[] = {
0x6f, 0xea, 0x70, 0x5e // mvn al r14 r0 ROR 21
};
const byte kInstruction_mvn_al_r12_r13_LSL_16[] = {
0x6f, 0xea, 0x0d, 0x4c // mvn al r12 r13 LSL 16
};
const byte kInstruction_mvn_al_r8_r5_ROR_28[] = {
0x6f, 0xea, 0x35, 0x78 // mvn al r8 r5 ROR 28
};
const byte kInstruction_mvn_al_r8_r1_LSL_25[] = {
0x6f, 0xea, 0x41, 0x68 // mvn al r8 r1 LSL 25
};
const byte kInstruction_mvn_al_r6_r4_LSL_25[] = {
0x6f, 0xea, 0x44, 0x66 // mvn al r6 r4 LSL 25
};
const byte kInstruction_mvn_al_r7_r12_ROR_26[] = {
0x6f, 0xea, 0xbc, 0x67 // mvn al r7 r12 ROR 26
};
const byte kInstruction_mvn_al_r8_r14_LSL_12[] = {
0x6f, 0xea, 0x0e, 0x38 // mvn al r8 r14 LSL 12
};
const byte kInstruction_mvn_al_r6_r6_ROR_2[] = {
0x6f, 0xea, 0xb6, 0x06 // mvn al r6 r6 ROR 2
};
const byte kInstruction_mvn_al_r11_r11_LSL_13[] = {
0x6f, 0xea, 0x4b, 0x3b // mvn al r11 r11 LSL 13
};
const byte kInstruction_mvn_al_r1_r12_ROR_25[] = {
0x6f, 0xea, 0x7c, 0x61 // mvn al r1 r12 ROR 25
};
const byte kInstruction_mvn_al_r9_r5_LSL_20[] = {
0x6f, 0xea, 0x05, 0x59 // mvn al r9 r5 LSL 20
};
const byte kInstruction_mvn_al_r12_r11_LSL_20[] = {
0x6f, 0xea, 0x0b, 0x5c // mvn al r12 r11 LSL 20
};
const byte kInstruction_mvn_al_r8_r3_ROR_31[] = {
0x6f, 0xea, 0xf3, 0x78 // mvn al r8 r3 ROR 31
};
const byte kInstruction_mvn_al_r0_r14_ROR_3[] = {
0x6f, 0xea, 0xfe, 0x00 // mvn al r0 r14 ROR 3
};
const byte kInstruction_mvn_al_r13_r14_LSL_30[] = {
0x6f, 0xea, 0x8e, 0x7d // mvn al r13 r14 LSL 30
};
const byte kInstruction_mvn_al_r3_r6_ROR_24[] = {
0x6f, 0xea, 0x36, 0x63 // mvn al r3 r6 ROR 24
};
const byte kInstruction_mvn_al_r10_r10_LSL_23[] = {
0x6f, 0xea, 0xca, 0x5a // mvn al r10 r10 LSL 23
};
const byte kInstruction_mvn_al_r9_r1_LSL_7[] = {
0x6f, 0xea, 0xc1, 0x19 // mvn al r9 r1 LSL 7
};
const byte kInstruction_mvn_al_r6_r13_ROR_27[] = {
0x6f, 0xea, 0xfd, 0x66 // mvn al r6 r13 ROR 27
};
const byte kInstruction_mvn_al_r1_r14_LSL_21[] = {
0x6f, 0xea, 0x4e, 0x51 // mvn al r1 r14 LSL 21
};
const byte kInstruction_mvn_al_r9_r14_ROR_12[] = {
0x6f, 0xea, 0x3e, 0x39 // mvn al r9 r14 ROR 12
};
const byte kInstruction_mvn_al_r14_r2_LSL_17[] = {
0x6f, 0xea, 0x42, 0x4e // mvn al r14 r2 LSL 17
};
const byte kInstruction_mvn_al_r11_r14_LSL_11[] = {
0x6f, 0xea, 0xce, 0x2b // mvn al r11 r14 LSL 11
};
const byte kInstruction_mvn_al_r11_r7_ROR_2[] = {
0x6f, 0xea, 0xb7, 0x0b // mvn al r11 r7 ROR 2
};
const byte kInstruction_mvn_al_r8_r7_ROR_20[] = {
0x6f, 0xea, 0x37, 0x58 // mvn al r8 r7 ROR 20
};
const byte kInstruction_mvn_al_r10_r11_LSL_5[] = {
0x6f, 0xea, 0x4b, 0x1a // mvn al r10 r11 LSL 5
};
const byte kInstruction_mvn_al_r5_r11_ROR_16[] = {
0x6f, 0xea, 0x3b, 0x45 // mvn al r5 r11 ROR 16
};
const byte kInstruction_mvn_al_r8_r3_LSL_23[] = {
0x6f, 0xea, 0xc3, 0x58 // mvn al r8 r3 LSL 23
};
const byte kInstruction_mvn_al_r2_r8_LSL_23[] = {
0x6f, 0xea, 0xc8, 0x52 // mvn al r2 r8 LSL 23
};
const byte kInstruction_mvn_al_r2_r13_LSL_28[] = {
0x6f, 0xea, 0x0d, 0x72 // mvn al r2 r13 LSL 28
};
const byte kInstruction_mvn_al_r1_r0_LSL_20[] = {
0x6f, 0xea, 0x00, 0x51 // mvn al r1 r0 LSL 20
};
const byte kInstruction_mvn_al_r9_r8_ROR_21[] = {
0x6f, 0xea, 0x78, 0x59 // mvn al r9 r8 ROR 21
};
const byte kInstruction_mvn_al_r5_r14_LSL_22[] = {
0x6f, 0xea, 0x8e, 0x55 // mvn al r5 r14 LSL 22
};
const byte kInstruction_mvn_al_r4_r9_ROR_7[] = {
0x6f, 0xea, 0xf9, 0x14 // mvn al r4 r9 ROR 7
};
const byte kInstruction_mvn_al_r2_r12_ROR_9[] = {
0x6f, 0xea, 0x7c, 0x22 // mvn al r2 r12 ROR 9
};
const byte kInstruction_mvn_al_r4_r10_LSL_31[] = {
0x6f, 0xea, 0xca, 0x74 // mvn al r4 r10 LSL 31
};
const byte kInstruction_mvn_al_r4_r2_LSL_8[] = {
0x6f, 0xea, 0x02, 0x24 // mvn al r4 r2 LSL 8
};
const byte kInstruction_mvn_al_r10_r6_LSL_27[] = {
0x6f, 0xea, 0xc6, 0x6a // mvn al r10 r6 LSL 27
};
const byte kInstruction_mvn_al_r12_r7_ROR_7[] = {
0x6f, 0xea, 0xf7, 0x1c // mvn al r12 r7 ROR 7
};
const byte kInstruction_mvn_al_r5_r1_ROR_9[] = {
0x6f, 0xea, 0x71, 0x25 // mvn al r5 r1 ROR 9
};
const byte kInstruction_mvn_al_r13_r13_LSL_29[] = {
0x6f, 0xea, 0x4d, 0x7d // mvn al r13 r13 LSL 29
};
const byte kInstruction_mvn_al_r0_r12_ROR_28[] = {
0x6f, 0xea, 0x3c, 0x70 // mvn al r0 r12 ROR 28
};
const byte kInstruction_mvn_al_r9_r6_ROR_26[] = {
0x6f, 0xea, 0xb6, 0x69 // mvn al r9 r6 ROR 26
};
const byte kInstruction_mvn_al_r1_r8_ROR_14[] = {
0x6f, 0xea, 0xb8, 0x31 // mvn al r1 r8 ROR 14
};
const byte kInstruction_mvn_al_r9_r5_LSL_19[] = {
0x6f, 0xea, 0xc5, 0x49 // mvn al r9 r5 LSL 19
};
const byte kInstruction_mvn_al_r10_r5_LSL_23[] = {
0x6f, 0xea, 0xc5, 0x5a // mvn al r10 r5 LSL 23
};
const byte kInstruction_mvn_al_r2_r12_ROR_2[] = {
0x6f, 0xea, 0xbc, 0x02 // mvn al r2 r12 ROR 2
};
const byte kInstruction_mvn_al_r5_r10_ROR_18[] = {
0x6f, 0xea, 0xba, 0x45 // mvn al r5 r10 ROR 18
};
const byte kInstruction_mvn_al_r13_r12_ROR_12[] = {
0x6f, 0xea, 0x3c, 0x3d // mvn al r13 r12 ROR 12
};
const byte kInstruction_mvn_al_r9_r10_LSL_15[] = {
0x6f, 0xea, 0xca, 0x39 // mvn al r9 r10 LSL 15
};
const byte kInstruction_mvn_al_r9_r2_LSL_26[] = {
0x6f, 0xea, 0x82, 0x69 // mvn al r9 r2 LSL 26
};
const byte kInstruction_mvn_al_r2_r3_LSL_19[] = {
0x6f, 0xea, 0xc3, 0x42 // mvn al r2 r3 LSL 19
};
const byte kInstruction_mvn_al_r7_r10_ROR_28[] = {
0x6f, 0xea, 0x3a, 0x77 // mvn al r7 r10 ROR 28
};
const byte kInstruction_mvn_al_r14_r6_ROR_6[] = {
0x6f, 0xea, 0xb6, 0x1e // mvn al r14 r6 ROR 6
};
const byte kInstruction_mvn_al_r5_r1_ROR_16[] = {
0x6f, 0xea, 0x31, 0x45 // mvn al r5 r1 ROR 16
};
const byte kInstruction_mvn_al_r4_r6_ROR_10[] = {
0x6f, 0xea, 0xb6, 0x24 // mvn al r4 r6 ROR 10
};
const byte kInstruction_mvn_al_r7_r12_LSL_10[] = {
0x6f, 0xea, 0x8c, 0x27 // mvn al r7 r12 LSL 10
};
const byte kInstruction_mvn_al_r0_r14_LSL_28[] = {
0x6f, 0xea, 0x0e, 0x70 // mvn al r0 r14 LSL 28
};
const byte kInstruction_mvn_al_r8_r2_LSL_27[] = {
0x6f, 0xea, 0xc2, 0x68 // mvn al r8 r2 LSL 27
};
const byte kInstruction_mvn_al_r8_r12_ROR_1[] = {
0x6f, 0xea, 0x7c, 0x08 // mvn al r8 r12 ROR 1
};
const byte kInstruction_mvn_al_r8_r4_ROR_4[] = {
0x6f, 0xea, 0x34, 0x18 // mvn al r8 r4 ROR 4
};
const byte kInstruction_mvn_al_r3_r5_ROR_20[] = {
0x6f, 0xea, 0x35, 0x53 // mvn al r3 r5 ROR 20
};
const byte kInstruction_mvn_al_r6_r13_LSL_5[] = {
0x6f, 0xea, 0x4d, 0x16 // mvn al r6 r13 LSL 5
};
const byte kInstruction_mvn_al_r9_r9_LSL_4[] = {
0x6f, 0xea, 0x09, 0x19 // mvn al r9 r9 LSL 4
};
const byte kInstruction_mvn_al_r13_r13_ROR_7[] = {
0x6f, 0xea, 0xfd, 0x1d // mvn al r13 r13 ROR 7
};
const byte kInstruction_mvn_al_r3_r7_LSL_11[] = {
0x6f, 0xea, 0xc7, 0x23 // mvn al r3 r7 LSL 11
};
const byte kInstruction_mvn_al_r1_r3_ROR_15[] = {
0x6f, 0xea, 0xf3, 0x31 // mvn al r1 r3 ROR 15
};
const byte kInstruction_mvn_al_r2_r0_LSL_30[] = {
0x6f, 0xea, 0x80, 0x72 // mvn al r2 r0 LSL 30
};
const byte kInstruction_mvn_al_r11_r13_ROR_16[] = {
0x6f, 0xea, 0x3d, 0x4b // mvn al r11 r13 ROR 16
};
const byte kInstruction_mvn_al_r3_r0_LSL_15[] = {
0x6f, 0xea, 0xc0, 0x33 // mvn al r3 r0 LSL 15
};
const byte kInstruction_mvn_al_r2_r0_LSL_8[] = {
0x6f, 0xea, 0x00, 0x22 // mvn al r2 r0 LSL 8
};
const byte kInstruction_mvn_al_r4_r13_ROR_5[] = {
0x6f, 0xea, 0x7d, 0x14 // mvn al r4 r13 ROR 5
};
const byte kInstruction_mvn_al_r13_r0_ROR_29[] = {
0x6f, 0xea, 0x70, 0x7d // mvn al r13 r0 ROR 29
};
const byte kInstruction_mvn_al_r6_r2_ROR_18[] = {
0x6f, 0xea, 0xb2, 0x46 // mvn al r6 r2 ROR 18
};
const byte kInstruction_mvn_al_r1_r2_LSL_2[] = {
0x6f, 0xea, 0x82, 0x01 // mvn al r1 r2 LSL 2
};
const byte kInstruction_mvn_al_r7_r4_ROR_12[] = {
0x6f, 0xea, 0x34, 0x37 // mvn al r7 r4 ROR 12
};
const byte kInstruction_mvn_al_r9_r11_ROR_6[] = {
0x6f, 0xea, 0xbb, 0x19 // mvn al r9 r11 ROR 6
};
const byte kInstruction_mvn_al_r8_r2_ROR_12[] = {
0x6f, 0xea, 0x32, 0x38 // mvn al r8 r2 ROR 12
};
const byte kInstruction_mvn_al_r12_r2_LSL_19[] = {
0x6f, 0xea, 0xc2, 0x4c // mvn al r12 r2 LSL 19
};
const byte kInstruction_mvn_al_r13_r0_ROR_30[] = {
0x6f, 0xea, 0xb0, 0x7d // mvn al r13 r0 ROR 30
};
const byte kInstruction_mvn_al_r7_r6_ROR_16[] = {
0x6f, 0xea, 0x36, 0x47 // mvn al r7 r6 ROR 16
};
const byte kInstruction_mvn_al_r6_r13_ROR_19[] = {
0x6f, 0xea, 0xfd, 0x46 // mvn al r6 r13 ROR 19
};
const byte kInstruction_mvn_al_r14_r3_LSL_19[] = {
0x6f, 0xea, 0xc3, 0x4e // mvn al r14 r3 LSL 19
};
const byte kInstruction_mvn_al_r14_r5_ROR_24[] = {
0x6f, 0xea, 0x35, 0x6e // mvn al r14 r5 ROR 24
};
const byte kInstruction_mvn_al_r10_r12_LSL_8[] = {
0x6f, 0xea, 0x0c, 0x2a // mvn al r10 r12 LSL 8
};
const byte kInstruction_mvn_al_r14_r7_LSL_11[] = {
0x6f, 0xea, 0xc7, 0x2e // mvn al r14 r7 LSL 11
};
const byte kInstruction_mvn_al_r10_r14_LSL_30[] = {
0x6f, 0xea, 0x8e, 0x7a // mvn al r10 r14 LSL 30
};
const byte kInstruction_mvn_al_r7_r13_ROR_7[] = {
0x6f, 0xea, 0xfd, 0x17 // mvn al r7 r13 ROR 7
};
const byte kInstruction_mvn_al_r11_r0_LSL_23[] = {
0x6f, 0xea, 0xc0, 0x5b // mvn al r11 r0 LSL 23
};
const byte kInstruction_mvn_al_r0_r12_LSL_30[] = {
0x6f, 0xea, 0x8c, 0x70 // mvn al r0 r12 LSL 30
};
const byte kInstruction_mvn_al_r5_r12_LSL_7[] = {
0x6f, 0xea, 0xcc, 0x15 // mvn al r5 r12 LSL 7
};
const byte kInstruction_mvn_al_r12_r12_ROR_14[] = {
0x6f, 0xea, 0xbc, 0x3c // mvn al r12 r12 ROR 14
};
const byte kInstruction_mvn_al_r8_r11_LSL_4[] = {
0x6f, 0xea, 0x0b, 0x18 // mvn al r8 r11 LSL 4
};
const byte kInstruction_mvn_al_r14_r2_ROR_24[] = {
0x6f, 0xea, 0x32, 0x6e // mvn al r14 r2 ROR 24
};
const byte kInstruction_mvn_al_r10_r2_ROR_31[] = {
0x6f, 0xea, 0xf2, 0x7a // mvn al r10 r2 ROR 31
};
const byte kInstruction_mvn_al_r11_r5_LSL_1[] = {
0x6f, 0xea, 0x45, 0x0b // mvn al r11 r5 LSL 1
};
const byte kInstruction_mvn_al_r8_r6_LSL_24[] = {
0x6f, 0xea, 0x06, 0x68 // mvn al r8 r6 LSL 24
};
const byte kInstruction_mvn_al_r14_r1_ROR_8[] = {
0x6f, 0xea, 0x31, 0x2e // mvn al r14 r1 ROR 8
};
const byte kInstruction_mvn_al_r11_r2_ROR_19[] = {
0x6f, 0xea, 0xf2, 0x4b // mvn al r11 r2 ROR 19
};
const byte kInstruction_mvn_al_r1_r12_LSL_14[] = {
0x6f, 0xea, 0x8c, 0x31 // mvn al r1 r12 LSL 14
};
const byte kInstruction_mvn_al_r6_r10_LSL_30[] = {
0x6f, 0xea, 0x8a, 0x76 // mvn al r6 r10 LSL 30
};
const byte kInstruction_mvn_al_r8_r1_ROR_6[] = {
0x6f, 0xea, 0xb1, 0x18 // mvn al r8 r1 ROR 6
};
const byte kInstruction_mvn_al_r13_r11_ROR_6[] = {
0x6f, 0xea, 0xbb, 0x1d // mvn al r13 r11 ROR 6
};
const byte kInstruction_mvn_al_r5_r13_LSL_30[] = {
0x6f, 0xea, 0x8d, 0x75 // mvn al r5 r13 LSL 30
};
const byte kInstruction_mvn_al_r0_r13_ROR_26[] = {
0x6f, 0xea, 0xbd, 0x60 // mvn al r0 r13 ROR 26
};
const byte kInstruction_mvn_al_r4_r10_LSL_30[] = {
0x6f, 0xea, 0x8a, 0x74 // mvn al r4 r10 LSL 30
};
const byte kInstruction_mvn_al_r8_r4_LSL_16[] = {
0x6f, 0xea, 0x04, 0x48 // mvn al r8 r4 LSL 16
};
const byte kInstruction_mvn_al_r11_r12_LSL_11[] = {
0x6f, 0xea, 0xcc, 0x2b // mvn al r11 r12 LSL 11
};
const byte kInstruction_mvn_al_r9_r3_ROR_2[] = {
0x6f, 0xea, 0xb3, 0x09 // mvn al r9 r3 ROR 2
};
const byte kInstruction_mvn_al_r11_r7_LSL_26[] = {
0x6f, 0xea, 0x87, 0x6b // mvn al r11 r7 LSL 26
};
const byte kInstruction_mvn_al_r14_r2_ROR_22[] = {
0x6f, 0xea, 0xb2, 0x5e // mvn al r14 r2 ROR 22
};
const byte kInstruction_mvn_al_r8_r2_ROR_10[] = {
0x6f, 0xea, 0xb2, 0x28 // mvn al r8 r2 ROR 10
};
const byte kInstruction_mvn_al_r5_r2_ROR_28[] = {
0x6f, 0xea, 0x32, 0x75 // mvn al r5 r2 ROR 28
};
const byte kInstruction_mvn_al_r14_r3_ROR_11[] = {
0x6f, 0xea, 0xf3, 0x2e // mvn al r14 r3 ROR 11
};
const byte kInstruction_mvn_al_r3_r14_LSL_5[] = {
0x6f, 0xea, 0x4e, 0x13 // mvn al r3 r14 LSL 5
};
const byte kInstruction_mvn_al_r12_r3_ROR_15[] = {
0x6f, 0xea, 0xf3, 0x3c // mvn al r12 r3 ROR 15
};
const byte kInstruction_mvn_al_r4_r1_ROR_30[] = {
0x6f, 0xea, 0xb1, 0x74 // mvn al r4 r1 ROR 30
};
const byte kInstruction_mvn_al_r13_r8_ROR_11[] = {
0x6f, 0xea, 0xf8, 0x2d // mvn al r13 r8 ROR 11
};
const byte kInstruction_mvn_al_r6_r9_ROR_9[] = {
0x6f, 0xea, 0x79, 0x26 // mvn al r6 r9 ROR 9
};
const byte kInstruction_mvn_al_r8_r13_ROR_15[] = {
0x6f, 0xea, 0xfd, 0x38 // mvn al r8 r13 ROR 15
};
const byte kInstruction_mvn_al_r0_r14_ROR_12[] = {
0x6f, 0xea, 0x3e, 0x30 // mvn al r0 r14 ROR 12
};
const byte kInstruction_mvn_al_r0_r10_LSL_6[] = {
0x6f, 0xea, 0x8a, 0x10 // mvn al r0 r10 LSL 6
};
const byte kInstruction_mvn_al_r8_r7_LSL_5[] = {
0x6f, 0xea, 0x47, 0x18 // mvn al r8 r7 LSL 5
};
const byte kInstruction_mvn_al_r3_r7_ROR_11[] = {
0x6f, 0xea, 0xf7, 0x23 // mvn al r3 r7 ROR 11
};
const byte kInstruction_mvn_al_r5_r1_LSL_20[] = {
0x6f, 0xea, 0x01, 0x55 // mvn al r5 r1 LSL 20
};
const byte kInstruction_mvn_al_r6_r7_LSL_10[] = {
0x6f, 0xea, 0x87, 0x26 // mvn al r6 r7 LSL 10
};
const byte kInstruction_mvn_al_r14_r0_ROR_27[] = {
0x6f, 0xea, 0xf0, 0x6e // mvn al r14 r0 ROR 27
};
const byte kInstruction_mvn_al_r6_r12_LSL_5[] = {
0x6f, 0xea, 0x4c, 0x16 // mvn al r6 r12 LSL 5
};
const byte kInstruction_mvn_al_r4_r8_LSL_28[] = {
0x6f, 0xea, 0x08, 0x74 // mvn al r4 r8 LSL 28
};
const byte kInstruction_mvn_al_r7_r6_ROR_15[] = {
0x6f, 0xea, 0xf6, 0x37 // mvn al r7 r6 ROR 15
};
const byte kInstruction_mvn_al_r0_r6_LSL_27[] = {
0x6f, 0xea, 0xc6, 0x60 // mvn al r0 r6 LSL 27
};
const byte kInstruction_mvn_al_r1_r6_ROR_19[] = {
0x6f, 0xea, 0xf6, 0x41 // mvn al r1 r6 ROR 19
};
const byte kInstruction_mvn_al_r11_r14_ROR_21[] = {
0x6f, 0xea, 0x7e, 0x5b // mvn al r11 r14 ROR 21
};
const byte kInstruction_mvn_al_r4_r13_LSL_5[] = {
0x6f, 0xea, 0x4d, 0x14 // mvn al r4 r13 LSL 5
};
const byte kInstruction_mvn_al_r4_r7_ROR_2[] = {
0x6f, 0xea, 0xb7, 0x04 // mvn al r4 r7 ROR 2
};
const byte kInstruction_mvn_al_r8_r1_ROR_29[] = {
0x6f, 0xea, 0x71, 0x78 // mvn al r8 r1 ROR 29
};
const byte kInstruction_mvn_al_r14_r2_LSL_24[] = {
0x6f, 0xea, 0x02, 0x6e // mvn al r14 r2 LSL 24
};
const byte kInstruction_mvn_al_r5_r12_ROR_27[] = {
0x6f, 0xea, 0xfc, 0x65 // mvn al r5 r12 ROR 27
};
const byte kInstruction_mvn_al_r11_r4_ROR_14[] = {
0x6f, 0xea, 0xb4, 0x3b // mvn al r11 r4 ROR 14
};
const byte kInstruction_mvn_al_r4_r7_LSL_28[] = {
0x6f, 0xea, 0x07, 0x74 // mvn al r4 r7 LSL 28
};
const byte kInstruction_mvn_al_r3_r6_LSL_9[] = {
0x6f, 0xea, 0x46, 0x23 // mvn al r3 r6 LSL 9
};
const byte kInstruction_mvn_al_r11_r13_LSL_12[] = {
0x6f, 0xea, 0x0d, 0x3b // mvn al r11 r13 LSL 12
};
const byte kInstruction_mvn_al_r10_r7_ROR_20[] = {
0x6f, 0xea, 0x37, 0x5a // mvn al r10 r7 ROR 20
};
const byte kInstruction_mvn_al_r2_r8_LSL_12[] = {
0x6f, 0xea, 0x08, 0x32 // mvn al r2 r8 LSL 12
};
const byte kInstruction_mvn_al_r4_r13_LSL_28[] = {
0x6f, 0xea, 0x0d, 0x74 // mvn al r4 r13 LSL 28
};
const byte kInstruction_mvn_al_r1_r12_LSL_28[] = {
0x6f, 0xea, 0x0c, 0x71 // mvn al r1 r12 LSL 28
};
const byte kInstruction_mvn_al_r7_r14_LSL_6[] = {
0x6f, 0xea, 0x8e, 0x17 // mvn al r7 r14 LSL 6
};
const byte kInstruction_mvn_al_r11_r2_ROR_10[] = {
0x6f, 0xea, 0xb2, 0x2b // mvn al r11 r2 ROR 10
};
const byte kInstruction_mvn_al_r3_r9_ROR_7[] = {
0x6f, 0xea, 0xf9, 0x13 // mvn al r3 r9 ROR 7
};
const byte kInstruction_mvn_al_r2_r12_LSL_11[] = {
0x6f, 0xea, 0xcc, 0x22 // mvn al r2 r12 LSL 11
};
const byte kInstruction_mvn_al_r4_r2_ROR_19[] = {
0x6f, 0xea, 0xf2, 0x44 // mvn al r4 r2 ROR 19
};
const byte kInstruction_mvn_al_r13_r0_LSL_5[] = {
0x6f, 0xea, 0x40, 0x1d // mvn al r13 r0 LSL 5
};
const byte kInstruction_mvn_al_r14_r11_ROR_29[] = {
0x6f, 0xea, 0x7b, 0x7e // mvn al r14 r11 ROR 29
};
const byte kInstruction_mvn_al_r9_r6_LSL_11[] = {
0x6f, 0xea, 0xc6, 0x29 // mvn al r9 r6 LSL 11
};
const byte kInstruction_mvn_al_r2_r10_ROR_30[] = {
0x6f, 0xea, 0xba, 0x72 // mvn al r2 r10 ROR 30
};
const byte kInstruction_mvn_al_r3_r14_ROR_4[] = {
0x6f, 0xea, 0x3e, 0x13 // mvn al r3 r14 ROR 4
};
const byte kInstruction_mvn_al_r9_r6_LSL_24[] = {
0x6f, 0xea, 0x06, 0x69 // mvn al r9 r6 LSL 24
};
const byte kInstruction_mvn_al_r9_r8_LSL_2[] = {
0x6f, 0xea, 0x88, 0x09 // mvn al r9 r8 LSL 2
};
const byte kInstruction_mvn_al_r12_r5_ROR_7[] = {
0x6f, 0xea, 0xf5, 0x1c // mvn al r12 r5 ROR 7
};
const byte kInstruction_mvn_al_r1_r11_ROR_20[] = {
0x6f, 0xea, 0x3b, 0x51 // mvn al r1 r11 ROR 20
};
const byte kInstruction_mvn_al_r6_r12_LSL_6[] = {
0x6f, 0xea, 0x8c, 0x16 // mvn al r6 r12 LSL 6
};
const byte kInstruction_mvn_al_r14_r11_ROR_26[] = {
0x6f, 0xea, 0xbb, 0x6e // mvn al r14 r11 ROR 26
};
const byte kInstruction_mvn_al_r5_r8_ROR_6[] = {
0x6f, 0xea, 0xb8, 0x15 // mvn al r5 r8 ROR 6
};
const byte kInstruction_mvn_al_r10_r4_LSL_8[] = {
0x6f, 0xea, 0x04, 0x2a // mvn al r10 r4 LSL 8
};
const byte kInstruction_mvn_al_r5_r0_ROR_24[] = {
0x6f, 0xea, 0x30, 0x65 // mvn al r5 r0 ROR 24
};
const byte kInstruction_mvn_al_r10_r3_LSL_20[] = {
0x6f, 0xea, 0x03, 0x5a // mvn al r10 r3 LSL 20
};
const byte kInstruction_mvn_al_r14_r4_LSL_22[] = {
0x6f, 0xea, 0x84, 0x5e // mvn al r14 r4 LSL 22
};
const byte kInstruction_mvn_al_r8_r8_ROR_1[] = {
0x6f, 0xea, 0x78, 0x08 // mvn al r8 r8 ROR 1
};
const byte kInstruction_mvn_al_r12_r9_ROR_8[] = {
0x6f, 0xea, 0x39, 0x2c // mvn al r12 r9 ROR 8
};
const byte kInstruction_mvn_al_r6_r13_ROR_15[] = {
0x6f, 0xea, 0xfd, 0x36 // mvn al r6 r13 ROR 15
};
const byte kInstruction_mvn_al_r9_r5_LSL_2[] = {
0x6f, 0xea, 0x85, 0x09 // mvn al r9 r5 LSL 2
};
const byte kInstruction_mvn_al_r13_r8_LSL_17[] = {
0x6f, 0xea, 0x48, 0x4d // mvn al r13 r8 LSL 17
};
const byte kInstruction_mvn_al_r2_r5_ROR_27[] = {
0x6f, 0xea, 0xf5, 0x62 // mvn al r2 r5 ROR 27
};
const byte kInstruction_mvn_al_r13_r12_ROR_10[] = {
0x6f, 0xea, 0xbc, 0x2d // mvn al r13 r12 ROR 10
};
const byte kInstruction_mvn_al_r13_r2_LSL_30[] = {
0x6f, 0xea, 0x82, 0x7d // mvn al r13 r2 LSL 30
};
const byte kInstruction_mvn_al_r10_r11_LSL_20[] = {
0x6f, 0xea, 0x0b, 0x5a // mvn al r10 r11 LSL 20
};
const byte kInstruction_mvn_al_r6_r1_ROR_22[] = {
0x6f, 0xea, 0xb1, 0x56 // mvn al r6 r1 ROR 22
};
const byte kInstruction_mvn_al_r0_r4_ROR_18[] = {
0x6f, 0xea, 0xb4, 0x40 // mvn al r0 r4 ROR 18
};
const byte kInstruction_mvn_al_r11_r14_ROR_19[] = {
0x6f, 0xea, 0xfe, 0x4b // mvn al r11 r14 ROR 19
};
const byte kInstruction_mvn_al_r0_r7_ROR_4[] = {
0x6f, 0xea, 0x37, 0x10 // mvn al r0 r7 ROR 4
};
const byte kInstruction_mvn_al_r1_r5_LSL_13[] = {
0x6f, 0xea, 0x45, 0x31 // mvn al r1 r5 LSL 13
};
const byte kInstruction_mvn_al_r11_r14_LSL_6[] = {
0x6f, 0xea, 0x8e, 0x1b // mvn al r11 r14 LSL 6
};
const byte kInstruction_mvn_al_r6_r11_LSL_10[] = {
0x6f, 0xea, 0x8b, 0x26 // mvn al r6 r11 LSL 10
};
const byte kInstruction_mvn_al_r10_r14_LSL_1[] = {
0x6f, 0xea, 0x4e, 0x0a // mvn al r10 r14 LSL 1
};
const byte kInstruction_mvn_al_r13_r4_ROR_29[] = {
0x6f, 0xea, 0x74, 0x7d // mvn al r13 r4 ROR 29
};
const byte kInstruction_mvn_al_r9_r8_ROR_28[] = {
0x6f, 0xea, 0x38, 0x79 // mvn al r9 r8 ROR 28
};
const byte kInstruction_mvn_al_r7_r12_ROR_22[] = {
0x6f, 0xea, 0xbc, 0x57 // mvn al r7 r12 ROR 22
};
const byte kInstruction_mvn_al_r1_r12_ROR_10[] = {
0x6f, 0xea, 0xbc, 0x21 // mvn al r1 r12 ROR 10
};
const byte kInstruction_mvn_al_r7_r8_ROR_31[] = {
0x6f, 0xea, 0xf8, 0x77 // mvn al r7 r8 ROR 31
};
const byte kInstruction_mvn_al_r0_r2_ROR_25[] = {
0x6f, 0xea, 0x72, 0x60 // mvn al r0 r2 ROR 25
};
const byte kInstruction_mvn_al_r3_r5_LSL_24[] = {
0x6f, 0xea, 0x05, 0x63 // mvn al r3 r5 LSL 24
};
const byte kInstruction_mvn_al_r11_r10_LSL_25[] = {
0x6f, 0xea, 0x4a, 0x6b // mvn al r11 r10 LSL 25
};
const byte kInstruction_mvn_al_r11_r1_LSL_9[] = {
0x6f, 0xea, 0x41, 0x2b // mvn al r11 r1 LSL 9
};
const byte kInstruction_mvn_al_r2_r7_LSL_3[] = {
0x6f, 0xea, 0xc7, 0x02 // mvn al r2 r7 LSL 3
};
const byte kInstruction_mvn_al_r0_r10_ROR_20[] = {
0x6f, 0xea, 0x3a, 0x50 // mvn al r0 r10 ROR 20
};
const byte kInstruction_mvn_al_r7_r0_LSL_2[] = {
0x6f, 0xea, 0x80, 0x07 // mvn al r7 r0 LSL 2
};
const byte kInstruction_mvn_al_r12_r5_LSL_8[] = {
0x6f, 0xea, 0x05, 0x2c // mvn al r12 r5 LSL 8
};
const byte kInstruction_mvn_al_r11_r1_ROR_16[] = {
0x6f, 0xea, 0x31, 0x4b // mvn al r11 r1 ROR 16
};
const byte kInstruction_mvn_al_r3_r3_LSL_30[] = {
0x6f, 0xea, 0x83, 0x73 // mvn al r3 r3 LSL 30
};
const byte kInstruction_mvn_al_r4_r9_LSL_16[] = {
0x6f, 0xea, 0x09, 0x44 // mvn al r4 r9 LSL 16
};
const byte kInstruction_mvn_al_r9_r8_LSL_27[] = {
0x6f, 0xea, 0xc8, 0x69 // mvn al r9 r8 LSL 27
};
const byte kInstruction_mvn_al_r4_r2_LSL_15[] = {
0x6f, 0xea, 0xc2, 0x34 // mvn al r4 r2 LSL 15
};
const byte kInstruction_mvn_al_r12_r13_LSL_3[] = {
0x6f, 0xea, 0xcd, 0x0c // mvn al r12 r13 LSL 3
};
const byte kInstruction_mvn_al_r11_r3_LSL_29[] = {
0x6f, 0xea, 0x43, 0x7b // mvn al r11 r3 LSL 29
};
const byte kInstruction_mvn_al_r4_r6_ROR_23[] = {
0x6f, 0xea, 0xf6, 0x54 // mvn al r4 r6 ROR 23
};
const byte kInstruction_mvn_al_r5_r8_LSL_3[] = {
0x6f, 0xea, 0xc8, 0x05 // mvn al r5 r8 LSL 3
};
const byte kInstruction_mvn_al_r1_r9_ROR_4[] = {
0x6f, 0xea, 0x39, 0x11 // mvn al r1 r9 ROR 4
};
const byte kInstruction_mvn_al_r13_r6_LSL_12[] = {
0x6f, 0xea, 0x06, 0x3d // mvn al r13 r6 LSL 12
};
const byte kInstruction_mvn_al_r12_r6_ROR_17[] = {
0x6f, 0xea, 0x76, 0x4c // mvn al r12 r6 ROR 17
};
const byte kInstruction_mvn_al_r2_r1_LSL_22[] = {
0x6f, 0xea, 0x81, 0x52 // mvn al r2 r1 LSL 22
};
const byte kInstruction_mvn_al_r9_r2_LSL_10[] = {
0x6f, 0xea, 0x82, 0x29 // mvn al r9 r2 LSL 10
};
const byte kInstruction_mvn_al_r11_r10_LSL_21[] = {
0x6f, 0xea, 0x4a, 0x5b // mvn al r11 r10 LSL 21
};
const byte kInstruction_mvn_al_r8_r12_LSL_31[] = {
0x6f, 0xea, 0xcc, 0x78 // mvn al r8 r12 LSL 31
};
const byte kInstruction_mvn_al_r5_r2_LSL_11[] = {
0x6f, 0xea, 0xc2, 0x25 // mvn al r5 r2 LSL 11
};
const byte kInstruction_mvn_al_r9_r6_LSL_31[] = {
0x6f, 0xea, 0xc6, 0x79 // mvn al r9 r6 LSL 31
};
const byte kInstruction_mvn_al_r6_r6_ROR_23[] = {
0x6f, 0xea, 0xf6, 0x56 // mvn al r6 r6 ROR 23
};
const byte kInstruction_mvn_al_r14_r3_LSL_5[] = {
0x6f, 0xea, 0x43, 0x1e // mvn al r14 r3 LSL 5
};
const byte kInstruction_mvn_al_r14_r9_ROR_26[] = {
0x6f, 0xea, 0xb9, 0x6e // mvn al r14 r9 ROR 26
};
const byte kInstruction_mvn_al_r13_r1_ROR_15[] = {
0x6f, 0xea, 0xf1, 0x3d // mvn al r13 r1 ROR 15
};
const byte kInstruction_mvn_al_r2_r13_LSL_13[] = {
0x6f, 0xea, 0x4d, 0x32 // mvn al r2 r13 LSL 13
};
const byte kInstruction_mvn_al_r14_r7_LSL_8[] = {
0x6f, 0xea, 0x07, 0x2e // mvn al r14 r7 LSL 8
};
const byte kInstruction_mvn_al_r9_r4_LSL_8[] = {
0x6f, 0xea, 0x04, 0x29 // mvn al r9 r4 LSL 8
};
const byte kInstruction_mvn_al_r0_r13_LSL_26[] = {
0x6f, 0xea, 0x8d, 0x60 // mvn al r0 r13 LSL 26
};
const byte kInstruction_mvn_al_r11_r1_LSL_12[] = {
0x6f, 0xea, 0x01, 0x3b // mvn al r11 r1 LSL 12
};
const byte kInstruction_mvn_al_r7_r6_LSL_5[] = {
0x6f, 0xea, 0x46, 0x17 // mvn al r7 r6 LSL 5
};
const byte kInstruction_mvn_al_r4_r9_LSL_15[] = {
0x6f, 0xea, 0xc9, 0x34 // mvn al r4 r9 LSL 15
};
const byte kInstruction_mvn_al_r2_r14_ROR_19[] = {
0x6f, 0xea, 0xfe, 0x42 // mvn al r2 r14 ROR 19
};
const byte kInstruction_mvn_al_r12_r4_LSL_21[] = {
0x6f, 0xea, 0x44, 0x5c // mvn al r12 r4 LSL 21
};
const byte kInstruction_mvn_al_r0_r9_ROR_23[] = {
0x6f, 0xea, 0xf9, 0x50 // mvn al r0 r9 ROR 23
};
const byte kInstruction_mvn_al_r5_r13_ROR_31[] = {
0x6f, 0xea, 0xfd, 0x75 // mvn al r5 r13 ROR 31
};
const byte kInstruction_mvn_al_r8_r1_ROR_19[] = {
0x6f, 0xea, 0xf1, 0x48 // mvn al r8 r1 ROR 19
};
const byte kInstruction_mvn_al_r1_r11_ROR_10[] = {
0x6f, 0xea, 0xbb, 0x21 // mvn al r1 r11 ROR 10
};
const byte kInstruction_mvn_al_r10_r7_ROR_22[] = {
0x6f, 0xea, 0xb7, 0x5a // mvn al r10 r7 ROR 22
};
const byte kInstruction_mvn_al_r10_r11_LSL_26[] = {
0x6f, 0xea, 0x8b, 0x6a // mvn al r10 r11 LSL 26
};
const byte kInstruction_mvn_al_r0_r14_ROR_15[] = {
0x6f, 0xea, 0xfe, 0x30 // mvn al r0 r14 ROR 15
};
const byte kInstruction_mvn_al_r1_r9_LSL_20[] = {
0x6f, 0xea, 0x09, 0x51 // mvn al r1 r9 LSL 20
};
const byte kInstruction_mvn_al_r7_r0_LSL_11[] = {
0x6f, 0xea, 0xc0, 0x27 // mvn al r7 r0 LSL 11
};
const byte kInstruction_mvn_al_r10_r14_ROR_15[] = {
0x6f, 0xea, 0xfe, 0x3a // mvn al r10 r14 ROR 15
};
const byte kInstruction_mvn_al_r1_r11_LSL_2[] = {
0x6f, 0xea, 0x8b, 0x01 // mvn al r1 r11 LSL 2
};
const byte kInstruction_mvn_al_r1_r13_ROR_2[] = {
0x6f, 0xea, 0xbd, 0x01 // mvn al r1 r13 ROR 2
};
const byte kInstruction_mvn_al_r12_r1_ROR_13[] = {
0x6f, 0xea, 0x71, 0x3c // mvn al r12 r1 ROR 13
};
const byte kInstruction_mvn_al_r1_r4_LSL_17[] = {
0x6f, 0xea, 0x44, 0x41 // mvn al r1 r4 LSL 17
};
const byte kInstruction_mvn_al_r11_r4_ROR_16[] = {
0x6f, 0xea, 0x34, 0x4b // mvn al r11 r4 ROR 16
};
const byte kInstruction_mvn_al_r1_r1_LSL_31[] = {
0x6f, 0xea, 0xc1, 0x71 // mvn al r1 r1 LSL 31
};
const byte kInstruction_mvn_al_r11_r0_ROR_15[] = {
0x6f, 0xea, 0xf0, 0x3b // mvn al r11 r0 ROR 15
};
const byte kInstruction_mvn_al_r1_r12_LSL_10[] = {
0x6f, 0xea, 0x8c, 0x21 // mvn al r1 r12 LSL 10
};
const byte kInstruction_mvn_al_r0_r12_LSL_11[] = {
0x6f, 0xea, 0xcc, 0x20 // mvn al r0 r12 LSL 11
};
const byte kInstruction_mvn_al_r10_r10_ROR_8[] = {
0x6f, 0xea, 0x3a, 0x2a // mvn al r10 r10 ROR 8
};
const byte kInstruction_mvn_al_r2_r5_ROR_29[] = {
0x6f, 0xea, 0x75, 0x72 // mvn al r2 r5 ROR 29
};
const byte kInstruction_mvn_al_r7_r7_LSL_9[] = {
0x6f, 0xea, 0x47, 0x27 // mvn al r7 r7 LSL 9
};
const byte kInstruction_mvn_al_r9_r1_LSL_11[] = {
0x6f, 0xea, 0xc1, 0x29 // mvn al r9 r1 LSL 11
};
const byte kInstruction_mvn_al_r5_r8_ROR_14[] = {
0x6f, 0xea, 0xb8, 0x35 // mvn al r5 r8 ROR 14
};
const byte kInstruction_mvn_al_r1_r6_ROR_25[] = {
0x6f, 0xea, 0x76, 0x61 // mvn al r1 r6 ROR 25
};
const byte kInstruction_mvn_al_r13_r2_LSL_7[] = {
0x6f, 0xea, 0xc2, 0x1d // mvn al r13 r2 LSL 7
};
const byte kInstruction_mvn_al_r0_r3_ROR_24[] = {
0x6f, 0xea, 0x33, 0x60 // mvn al r0 r3 ROR 24
};
const byte kInstruction_mvn_al_r4_r5_ROR_31[] = {
0x6f, 0xea, 0xf5, 0x74 // mvn al r4 r5 ROR 31
};
const byte kInstruction_mvn_al_r0_r13_ROR_28[] = {
0x6f, 0xea, 0x3d, 0x70 // mvn al r0 r13 ROR 28
};
const byte kInstruction_mvn_al_r11_r3_LSL_5[] = {
0x6f, 0xea, 0x43, 0x1b // mvn al r11 r3 LSL 5
};
const byte kInstruction_mvn_al_r3_r1_LSL_1[] = {
0x6f, 0xea, 0x41, 0x03 // mvn al r3 r1 LSL 1
};
const byte kInstruction_mvn_al_r10_r7_ROR_8[] = {
0x6f, 0xea, 0x37, 0x2a // mvn al r10 r7 ROR 8
};
const byte kInstruction_mvn_al_r0_r13_LSL_17[] = {
0x6f, 0xea, 0x4d, 0x40 // mvn al r0 r13 LSL 17
};
const byte kInstruction_mvn_al_r10_r3_LSL_16[] = {
0x6f, 0xea, 0x03, 0x4a // mvn al r10 r3 LSL 16
};
const byte kInstruction_mvn_al_r14_r14_LSL_21[] = {
0x6f, 0xea, 0x4e, 0x5e // mvn al r14 r14 LSL 21
};
const byte kInstruction_mvn_al_r0_r7_ROR_12[] = {
0x6f, 0xea, 0x37, 0x30 // mvn al r0 r7 ROR 12
};
const byte kInstruction_mvn_al_r4_r11_LSL_1[] = {
0x6f, 0xea, 0x4b, 0x04 // mvn al r4 r11 LSL 1
};
const byte kInstruction_mvn_al_r4_r10_ROR_25[] = {
0x6f, 0xea, 0x7a, 0x64 // mvn al r4 r10 ROR 25
};
const byte kInstruction_mvn_al_r11_r7_LSL_10[] = {
0x6f, 0xea, 0x87, 0x2b // mvn al r11 r7 LSL 10
};
const byte kInstruction_mvn_al_r4_r13_LSL_13[] = {
0x6f, 0xea, 0x4d, 0x34 // mvn al r4 r13 LSL 13
};
const byte kInstruction_mvn_al_r11_r4_ROR_9[] = {
0x6f, 0xea, 0x74, 0x2b // mvn al r11 r4 ROR 9
};
const byte kInstruction_mvn_al_r8_r3_LSL_4[] = {
0x6f, 0xea, 0x03, 0x18 // mvn al r8 r3 LSL 4
};
const byte kInstruction_mvn_al_r0_r3_LSL_22[] = {
0x6f, 0xea, 0x83, 0x50 // mvn al r0 r3 LSL 22
};
const byte kInstruction_mvn_al_r9_r3_LSL_16[] = {
0x6f, 0xea, 0x03, 0x49 // mvn al r9 r3 LSL 16
};
const byte kInstruction_mvn_al_r1_r11_LSL_24[] = {
0x6f, 0xea, 0x0b, 0x61 // mvn al r1 r11 LSL 24
};
const byte kInstruction_mvn_al_r0_r7_LSL_11[] = {
0x6f, 0xea, 0xc7, 0x20 // mvn al r0 r7 LSL 11
};
const byte kInstruction_mvn_al_r13_r8_LSL_29[] = {
0x6f, 0xea, 0x48, 0x7d // mvn al r13 r8 LSL 29
};
const byte kInstruction_mvn_al_r8_r8_LSL_1[] = {
0x6f, 0xea, 0x48, 0x08 // mvn al r8 r8 LSL 1
};
const byte kInstruction_mvn_al_r8_r1_LSL_21[] = {
0x6f, 0xea, 0x41, 0x58 // mvn al r8 r1 LSL 21
};
const byte kInstruction_mvn_al_r1_r3_LSL_27[] = {
0x6f, 0xea, 0xc3, 0x61 // mvn al r1 r3 LSL 27
};
const byte kInstruction_mvn_al_r1_r8_ROR_2[] = {
0x6f, 0xea, 0xb8, 0x01 // mvn al r1 r8 ROR 2
};
const byte kInstruction_mvn_al_r9_r4_ROR_9[] = {
0x6f, 0xea, 0x74, 0x29 // mvn al r9 r4 ROR 9
};
const byte kInstruction_mvn_al_r10_r3_ROR_28[] = {
0x6f, 0xea, 0x33, 0x7a // mvn al r10 r3 ROR 28
};
const byte kInstruction_mvn_al_r4_r8_ROR_11[] = {
0x6f, 0xea, 0xf8, 0x24 // mvn al r4 r8 ROR 11
};
const byte kInstruction_mvn_al_r2_r3_LSL_17[] = {
0x6f, 0xea, 0x43, 0x42 // mvn al r2 r3 LSL 17
};
const byte kInstruction_mvn_al_r5_r6_ROR_17[] = {
0x6f, 0xea, 0x76, 0x45 // mvn al r5 r6 ROR 17
};
const byte kInstruction_mvn_al_r8_r9_LSL_6[] = {
0x6f, 0xea, 0x89, 0x18 // mvn al r8 r9 LSL 6
};
const byte kInstruction_mvn_al_r9_r11_ROR_29[] = {
0x6f, 0xea, 0x7b, 0x79 // mvn al r9 r11 ROR 29
};
const byte kInstruction_mvn_al_r11_r12_ROR_20[] = {
0x6f, 0xea, 0x3c, 0x5b // mvn al r11 r12 ROR 20
};
const byte kInstruction_mvn_al_r8_r13_LSL_21[] = {
0x6f, 0xea, 0x4d, 0x58 // mvn al r8 r13 LSL 21
};
const byte kInstruction_mvn_al_r8_r9_LSL_22[] = {
0x6f, 0xea, 0x89, 0x58 // mvn al r8 r9 LSL 22
};
const byte kInstruction_mvn_al_r11_r1_ROR_14[] = {
0x6f, 0xea, 0xb1, 0x3b // mvn al r11 r1 ROR 14
};
const byte kInstruction_mvn_al_r13_r3_LSL_15[] = {
0x6f, 0xea, 0xc3, 0x3d // mvn al r13 r3 LSL 15
};
const byte kInstruction_mvn_al_r3_r7_LSL_9[] = {
0x6f, 0xea, 0x47, 0x23 // mvn al r3 r7 LSL 9
};
const byte kInstruction_mvn_al_r5_r4_ROR_10[] = {
0x6f, 0xea, 0xb4, 0x25 // mvn al r5 r4 ROR 10
};
const byte kInstruction_mvn_al_r11_r10_LSL_24[] = {
0x6f, 0xea, 0x0a, 0x6b // mvn al r11 r10 LSL 24
};
const byte kInstruction_mvn_al_r1_r9_ROR_25[] = {
0x6f, 0xea, 0x79, 0x61 // mvn al r1 r9 ROR 25
};
const byte kInstruction_mvn_al_r9_r2_ROR_5[] = {
0x6f, 0xea, 0x72, 0x19 // mvn al r9 r2 ROR 5
};
const byte kInstruction_mvn_al_r5_r4_ROR_19[] = {
0x6f, 0xea, 0xf4, 0x45 // mvn al r5 r4 ROR 19
};
const byte kInstruction_mvn_al_r1_r14_ROR_19[] = {
0x6f, 0xea, 0xfe, 0x41 // mvn al r1 r14 ROR 19
};
const byte kInstruction_mvn_al_r10_r9_LSL_30[] = {
0x6f, 0xea, 0x89, 0x7a // mvn al r10 r9 LSL 30
};
const byte kInstruction_mvn_al_r9_r4_ROR_24[] = {
0x6f, 0xea, 0x34, 0x69 // mvn al r9 r4 ROR 24
};
const byte kInstruction_mvn_al_r6_r6_LSL_23[] = {
0x6f, 0xea, 0xc6, 0x56 // mvn al r6 r6 LSL 23
};
const byte kInstruction_mvn_al_r5_r7_LSL_29[] = {
0x6f, 0xea, 0x47, 0x75 // mvn al r5 r7 LSL 29
};
const byte kInstruction_mvn_al_r10_r5_LSL_10[] = {
0x6f, 0xea, 0x85, 0x2a // mvn al r10 r5 LSL 10
};
const byte kInstruction_mvn_al_r13_r8_LSL_15[] = {
0x6f, 0xea, 0xc8, 0x3d // mvn al r13 r8 LSL 15
};
const byte kInstruction_mvn_al_r5_r2_ROR_14[] = {
0x6f, 0xea, 0xb2, 0x35 // mvn al r5 r2 ROR 14
};
const byte kInstruction_mvn_al_r11_r3_ROR_6[] = {
0x6f, 0xea, 0xb3, 0x1b // mvn al r11 r3 ROR 6
};
const byte kInstruction_mvn_al_r12_r7_ROR_9[] = {
0x6f, 0xea, 0x77, 0x2c // mvn al r12 r7 ROR 9
};
const byte kInstruction_mvn_al_r1_r3_ROR_23[] = {
0x6f, 0xea, 0xf3, 0x51 // mvn al r1 r3 ROR 23
};
const byte kInstruction_mvn_al_r10_r13_LSL_30[] = {
0x6f, 0xea, 0x8d, 0x7a // mvn al r10 r13 LSL 30
};
const byte kInstruction_mvn_al_r3_r2_LSL_15[] = {
0x6f, 0xea, 0xc2, 0x33 // mvn al r3 r2 LSL 15
};
const byte kInstruction_mvn_al_r6_r0_LSL_31[] = {
0x6f, 0xea, 0xc0, 0x76 // mvn al r6 r0 LSL 31
};
const byte kInstruction_mvn_al_r13_r12_LSL_12[] = {
0x6f, 0xea, 0x0c, 0x3d // mvn al r13 r12 LSL 12
};
const byte kInstruction_mvn_al_r7_r8_ROR_9[] = {
0x6f, 0xea, 0x78, 0x27 // mvn al r7 r8 ROR 9
};
const byte kInstruction_mvn_al_r7_r13_LSL_16[] = {
0x6f, 0xea, 0x0d, 0x47 // mvn al r7 r13 LSL 16
};
const byte kInstruction_mvn_al_r3_r6_LSL_17[] = {
0x6f, 0xea, 0x46, 0x43 // mvn al r3 r6 LSL 17
};
const byte kInstruction_mvn_al_r13_r4_ROR_14[] = {
0x6f, 0xea, 0xb4, 0x3d // mvn al r13 r4 ROR 14
};
const byte kInstruction_mvn_al_r2_r5_ROR_7[] = {
0x6f, 0xea, 0xf5, 0x12 // mvn al r2 r5 ROR 7
};
const byte kInstruction_mvn_al_r7_r10_ROR_18[] = {
0x6f, 0xea, 0xba, 0x47 // mvn al r7 r10 ROR 18
};
const byte kInstruction_mvn_al_r7_r12_LSL_26[] = {
0x6f, 0xea, 0x8c, 0x67 // mvn al r7 r12 LSL 26
};
const byte kInstruction_mvn_al_r13_r13_ROR_25[] = {
0x6f, 0xea, 0x7d, 0x6d // mvn al r13 r13 ROR 25
};
const byte kInstruction_mvn_al_r11_r2_ROR_5[] = {
0x6f, 0xea, 0x72, 0x1b // mvn al r11 r2 ROR 5
};
const byte kInstruction_mvn_al_r0_r14_ROR_8[] = {
0x6f, 0xea, 0x3e, 0x20 // mvn al r0 r14 ROR 8
};
const byte kInstruction_mvn_al_r6_r2_ROR_27[] = {
0x6f, 0xea, 0xf2, 0x66 // mvn al r6 r2 ROR 27
};
const byte kInstruction_mvn_al_r4_r14_LSL_31[] = {
0x6f, 0xea, 0xce, 0x74 // mvn al r4 r14 LSL 31
};
const byte kInstruction_mvn_al_r1_r0_LSL_7[] = {
0x6f, 0xea, 0xc0, 0x11 // mvn al r1 r0 LSL 7
};
const byte kInstruction_mvn_al_r0_r8_LSL_10[] = {
0x6f, 0xea, 0x88, 0x20 // mvn al r0 r8 LSL 10
};
const byte kInstruction_mvn_al_r9_r0_LSL_13[] = {
0x6f, 0xea, 0x40, 0x39 // mvn al r9 r0 LSL 13
};
const byte kInstruction_mvn_al_r11_r11_ROR_11[] = {
0x6f, 0xea, 0xfb, 0x2b // mvn al r11 r11 ROR 11
};
const byte kInstruction_mvn_al_r11_r4_ROR_7[] = {
0x6f, 0xea, 0xf4, 0x1b // mvn al r11 r4 ROR 7
};
const byte kInstruction_mvn_al_r10_r4_ROR_19[] = {
0x6f, 0xea, 0xf4, 0x4a // mvn al r10 r4 ROR 19
};
const byte kInstruction_mvn_al_r1_r13_ROR_4[] = {
0x6f, 0xea, 0x3d, 0x11 // mvn al r1 r13 ROR 4
};
const byte kInstruction_mvn_al_r9_r14_ROR_5[] = {
0x6f, 0xea, 0x7e, 0x19 // mvn al r9 r14 ROR 5
};
const byte kInstruction_mvn_al_r14_r11_LSL_22[] = {
0x6f, 0xea, 0x8b, 0x5e // mvn al r14 r11 LSL 22
};
const byte kInstruction_mvn_al_r2_r4_LSL_17[] = {
0x6f, 0xea, 0x44, 0x42 // mvn al r2 r4 LSL 17
};
const byte kInstruction_mvn_al_r2_r6_LSL_15[] = {
0x6f, 0xea, 0xc6, 0x32 // mvn al r2 r6 LSL 15
};
const byte kInstruction_mvn_al_r10_r5_ROR_28[] = {
0x6f, 0xea, 0x35, 0x7a // mvn al r10 r5 ROR 28
};
const byte kInstruction_mvn_al_r6_r4_ROR_13[] = {
0x6f, 0xea, 0x74, 0x36 // mvn al r6 r4 ROR 13
};
const byte kInstruction_mvn_al_r3_r4_ROR_10[] = {
0x6f, 0xea, 0xb4, 0x23 // mvn al r3 r4 ROR 10
};
const byte kInstruction_mvn_al_r3_r7_ROR_15[] = {
0x6f, 0xea, 0xf7, 0x33 // mvn al r3 r7 ROR 15
};
const byte kInstruction_mvn_al_r7_r14_LSL_28[] = {
0x6f, 0xea, 0x0e, 0x77 // mvn al r7 r14 LSL 28
};
const byte kInstruction_mvn_al_r10_r6_ROR_23[] = {
0x6f, 0xea, 0xf6, 0x5a // mvn al r10 r6 ROR 23
};
const byte kInstruction_mvn_al_r4_r5_ROR_4[] = {
0x6f, 0xea, 0x35, 0x14 // mvn al r4 r5 ROR 4
};
const byte kInstruction_mvn_al_r9_r3_ROR_8[] = {
0x6f, 0xea, 0x33, 0x29 // mvn al r9 r3 ROR 8
};
const byte kInstruction_mvn_al_r2_r1_LSL_14[] = {
0x6f, 0xea, 0x81, 0x32 // mvn al r2 r1 LSL 14
};
const byte kInstruction_mvn_al_r10_r7_LSL_4[] = {
0x6f, 0xea, 0x07, 0x1a // mvn al r10 r7 LSL 4
};
const byte kInstruction_mvn_al_r0_r0_LSL_18[] = {
0x6f, 0xea, 0x80, 0x40 // mvn al r0 r0 LSL 18
};
const byte kInstruction_mvn_al_r12_r3_ROR_18[] = {
0x6f, 0xea, 0xb3, 0x4c // mvn al r12 r3 ROR 18
};
const byte kInstruction_mvn_al_r5_r5_LSL_4[] = {
0x6f, 0xea, 0x05, 0x15 // mvn al r5 r5 LSL 4
};
const byte kInstruction_mvn_al_r11_r4_ROR_12[] = {
0x6f, 0xea, 0x34, 0x3b // mvn al r11 r4 ROR 12
};
const byte kInstruction_mvn_al_r5_r14_ROR_23[] = {
0x6f, 0xea, 0xfe, 0x55 // mvn al r5 r14 ROR 23
};
const byte kInstruction_mvn_al_r7_r6_LSL_31[] = {
0x6f, 0xea, 0xc6, 0x77 // mvn al r7 r6 LSL 31
};
const byte kInstruction_mvn_al_r14_r2_ROR_7[] = {
0x6f, 0xea, 0xf2, 0x1e // mvn al r14 r2 ROR 7
};
const byte kInstruction_mvn_al_r10_r0_ROR_23[] = {
0x6f, 0xea, 0xf0, 0x5a // mvn al r10 r0 ROR 23
};
const byte kInstruction_mvn_al_r6_r0_LSL_25[] = {
0x6f, 0xea, 0x40, 0x66 // mvn al r6 r0 LSL 25
};
const byte kInstruction_mvn_al_r7_r4_ROR_16[] = {
0x6f, 0xea, 0x34, 0x47 // mvn al r7 r4 ROR 16
};
const byte kInstruction_mvn_al_r9_r0_LSL_19[] = {
0x6f, 0xea, 0xc0, 0x49 // mvn al r9 r0 LSL 19
};
const byte kInstruction_mvn_al_r7_r2_LSL_23[] = {
0x6f, 0xea, 0xc2, 0x57 // mvn al r7 r2 LSL 23
};
const byte kInstruction_mvn_al_r7_r10_LSL_17[] = {
0x6f, 0xea, 0x4a, 0x47 // mvn al r7 r10 LSL 17
};
const byte kInstruction_mvn_al_r8_r10_ROR_19[] = {
0x6f, 0xea, 0xfa, 0x48 // mvn al r8 r10 ROR 19
};
const byte kInstruction_mvn_al_r6_r9_LSL_19[] = {
0x6f, 0xea, 0xc9, 0x46 // mvn al r6 r9 LSL 19
};
const byte kInstruction_mvn_al_r12_r6_LSL_14[] = {
0x6f, 0xea, 0x86, 0x3c // mvn al r12 r6 LSL 14
};
const byte kInstruction_mvn_al_r4_r12_ROR_24[] = {
0x6f, 0xea, 0x3c, 0x64 // mvn al r4 r12 ROR 24
};
const byte kInstruction_mvn_al_r3_r6_LSL_6[] = {
0x6f, 0xea, 0x86, 0x13 // mvn al r3 r6 LSL 6
};
const byte kInstruction_mvn_al_r11_r6_ROR_4[] = {
0x6f, 0xea, 0x36, 0x1b // mvn al r11 r6 ROR 4
};
const byte kInstruction_mvn_al_r14_r3_LSL_10[] = {
0x6f, 0xea, 0x83, 0x2e // mvn al r14 r3 LSL 10
};
const byte kInstruction_mvn_al_r1_r1_LSL_12[] = {
0x6f, 0xea, 0x01, 0x31 // mvn al r1 r1 LSL 12
};
const byte kInstruction_mvn_al_r7_r8_LSL_19[] = {
0x6f, 0xea, 0xc8, 0x47 // mvn al r7 r8 LSL 19
};
const byte kInstruction_mvn_al_r5_r5_LSL_22[] = {
0x6f, 0xea, 0x85, 0x55 // mvn al r5 r5 LSL 22
};
const byte kInstruction_mvn_al_r14_r8_ROR_29[] = {
0x6f, 0xea, 0x78, 0x7e // mvn al r14 r8 ROR 29
};
const byte kInstruction_mvn_al_r3_r14_LSL_24[] = {
0x6f, 0xea, 0x0e, 0x63 // mvn al r3 r14 LSL 24
};
const byte kInstruction_mvn_al_r11_r14_ROR_5[] = {
0x6f, 0xea, 0x7e, 0x1b // mvn al r11 r14 ROR 5
};
const byte kInstruction_mvn_al_r12_r4_ROR_15[] = {
0x6f, 0xea, 0xf4, 0x3c // mvn al r12 r4 ROR 15
};
const byte kInstruction_mvn_al_r3_r5_LSL_12[] = {
0x6f, 0xea, 0x05, 0x33 // mvn al r3 r5 LSL 12
};
const byte kInstruction_mvn_al_r0_r12_ROR_26[] = {
0x6f, 0xea, 0xbc, 0x60 // mvn al r0 r12 ROR 26
};
const byte kInstruction_mvn_al_r5_r7_ROR_12[] = {
0x6f, 0xea, 0x37, 0x35 // mvn al r5 r7 ROR 12
};
const byte kInstruction_mvn_al_r8_r9_LSL_17[] = {
0x6f, 0xea, 0x49, 0x48 // mvn al r8 r9 LSL 17
};
const byte kInstruction_mvn_al_r1_r2_ROR_13[] = {
0x6f, 0xea, 0x72, 0x31 // mvn al r1 r2 ROR 13
};
const byte kInstruction_mvn_al_r0_r13_ROR_8[] = {
0x6f, 0xea, 0x3d, 0x20 // mvn al r0 r13 ROR 8
};
const byte kInstruction_mvn_al_r4_r0_LSL_9[] = {
0x6f, 0xea, 0x40, 0x24 // mvn al r4 r0 LSL 9
};
const byte kInstruction_mvn_al_r6_r2_LSL_21[] = {
0x6f, 0xea, 0x42, 0x56 // mvn al r6 r2 LSL 21
};
const byte kInstruction_mvn_al_r5_r3_ROR_29[] = {
0x6f, 0xea, 0x73, 0x75 // mvn al r5 r3 ROR 29
};
const byte kInstruction_mvn_al_r14_r6_LSL_7[] = {
0x6f, 0xea, 0xc6, 0x1e // mvn al r14 r6 LSL 7
};
const byte kInstruction_mvn_al_r9_r4_ROR_11[] = {
0x6f, 0xea, 0xf4, 0x29 // mvn al r9 r4 ROR 11
};
const byte kInstruction_mvn_al_r4_r0_LSL_14[] = {
0x6f, 0xea, 0x80, 0x34 // mvn al r4 r0 LSL 14
};
const byte kInstruction_mvn_al_r10_r14_ROR_3[] = {
0x6f, 0xea, 0xfe, 0x0a // mvn al r10 r14 ROR 3
};
const byte kInstruction_mvn_al_r0_r11_LSL_31[] = {
0x6f, 0xea, 0xcb, 0x70 // mvn al r0 r11 LSL 31
};
const byte kInstruction_mvn_al_r5_r2_LSL_17[] = {
0x6f, 0xea, 0x42, 0x45 // mvn al r5 r2 LSL 17
};
const byte kInstruction_mvn_al_r2_r6_ROR_26[] = {
0x6f, 0xea, 0xb6, 0x62 // mvn al r2 r6 ROR 26
};
const byte kInstruction_mvn_al_r9_r9_LSL_8[] = {
0x6f, 0xea, 0x09, 0x29 // mvn al r9 r9 LSL 8
};
const byte kInstruction_mvn_al_r12_r12_LSL_19[] = {
0x6f, 0xea, 0xcc, 0x4c // mvn al r12 r12 LSL 19
};
const byte kInstruction_mvn_al_r2_r11_LSL_10[] = {
0x6f, 0xea, 0x8b, 0x22 // mvn al r2 r11 LSL 10
};
const byte kInstruction_mvn_al_r4_r7_ROR_6[] = {
0x6f, 0xea, 0xb7, 0x14 // mvn al r4 r7 ROR 6
};
const byte kInstruction_mvn_al_r2_r3_ROR_14[] = {
0x6f, 0xea, 0xb3, 0x32 // mvn al r2 r3 ROR 14
};
const byte kInstruction_mvn_al_r4_r12_ROR_16[] = {
0x6f, 0xea, 0x3c, 0x44 // mvn al r4 r12 ROR 16
};
const byte kInstruction_mvn_al_r12_r12_LSL_2[] = {
0x6f, 0xea, 0x8c, 0x0c // mvn al r12 r12 LSL 2
};
const byte kInstruction_mvn_al_r10_r5_ROR_23[] = {
0x6f, 0xea, 0xf5, 0x5a // mvn al r10 r5 ROR 23
};
const byte kInstruction_mvn_al_r8_r14_ROR_24[] = {
0x6f, 0xea, 0x3e, 0x68 // mvn al r8 r14 ROR 24
};
const byte kInstruction_mvn_al_r7_r1_LSL_15[] = {
0x6f, 0xea, 0xc1, 0x37 // mvn al r7 r1 LSL 15
};
const byte kInstruction_mvn_al_r13_r10_LSL_8[] = {
0x6f, 0xea, 0x0a, 0x2d // mvn al r13 r10 LSL 8
};
const byte kInstruction_mvn_al_r1_r9_ROR_5[] = {
0x6f, 0xea, 0x79, 0x11 // mvn al r1 r9 ROR 5
};
const byte kInstruction_mvn_al_r1_r2_ROR_17[] = {
0x6f, 0xea, 0x72, 0x41 // mvn al r1 r2 ROR 17
};
const byte kInstruction_mvn_al_r12_r3_ROR_30[] = {
0x6f, 0xea, 0xb3, 0x7c // mvn al r12 r3 ROR 30
};
const byte kInstruction_mvn_al_r0_r5_LSL_18[] = {
0x6f, 0xea, 0x85, 0x40 // mvn al r0 r5 LSL 18
};
const byte kInstruction_mvn_al_r5_r7_LSL_2[] = {
0x6f, 0xea, 0x87, 0x05 // mvn al r5 r7 LSL 2
};
const byte kInstruction_mvn_al_r13_r4_LSL_30[] = {
0x6f, 0xea, 0x84, 0x7d // mvn al r13 r4 LSL 30
};
const byte kInstruction_mvn_al_r2_r14_ROR_31[] = {
0x6f, 0xea, 0xfe, 0x72 // mvn al r2 r14 ROR 31
};
const byte kInstruction_mvn_al_r12_r8_LSL_30[] = {
0x6f, 0xea, 0x88, 0x7c // mvn al r12 r8 LSL 30
};
const byte kInstruction_mvn_al_r3_r5_ROR_4[] = {
0x6f, 0xea, 0x35, 0x13 // mvn al r3 r5 ROR 4
};
const byte kInstruction_mvn_al_r11_r11_ROR_3[] = {
0x6f, 0xea, 0xfb, 0x0b // mvn al r11 r11 ROR 3
};
const byte kInstruction_mvn_al_r4_r2_ROR_17[] = {
0x6f, 0xea, 0x72, 0x44 // mvn al r4 r2 ROR 17
};
const byte kInstruction_mvn_al_r6_r9_LSL_15[] = {
0x6f, 0xea, 0xc9, 0x36 // mvn al r6 r9 LSL 15
};
const byte kInstruction_mvn_al_r5_r6_ROR_25[] = {
0x6f, 0xea, 0x76, 0x65 // mvn al r5 r6 ROR 25
};
const byte kInstruction_mvn_al_r6_r3_LSL_19[] = {
0x6f, 0xea, 0xc3, 0x46 // mvn al r6 r3 LSL 19
};
const byte kInstruction_mvn_al_r3_r7_LSL_6[] = {
0x6f, 0xea, 0x87, 0x13 // mvn al r3 r7 LSL 6
};
const byte kInstruction_mvn_al_r12_r1_LSL_13[] = {
0x6f, 0xea, 0x41, 0x3c // mvn al r12 r1 LSL 13
};
const byte kInstruction_mvn_al_r2_r1_ROR_9[] = {
0x6f, 0xea, 0x71, 0x22 // mvn al r2 r1 ROR 9
};
const byte kInstruction_mvn_al_r12_r4_LSL_28[] = {
0x6f, 0xea, 0x04, 0x7c // mvn al r12 r4 LSL 28
};
const byte kInstruction_mvn_al_r14_r13_ROR_12[] = {
0x6f, 0xea, 0x3d, 0x3e // mvn al r14 r13 ROR 12
};
const byte kInstruction_mvn_al_r11_r12_LSL_16[] = {
0x6f, 0xea, 0x0c, 0x4b // mvn al r11 r12 LSL 16
};
const byte kInstruction_mvn_al_r8_r7_LSL_29[] = {
0x6f, 0xea, 0x47, 0x78 // mvn al r8 r7 LSL 29
};
const byte kInstruction_mvn_al_r0_r10_ROR_25[] = {
0x6f, 0xea, 0x7a, 0x60 // mvn al r0 r10 ROR 25
};
const byte kInstruction_mvn_al_r9_r6_LSL_3[] = {
0x6f, 0xea, 0xc6, 0x09 // mvn al r9 r6 LSL 3
};
const byte kInstruction_mvn_al_r9_r12_LSL_18[] = {
0x6f, 0xea, 0x8c, 0x49 // mvn al r9 r12 LSL 18
};
const byte kInstruction_mvn_al_r1_r14_LSL_9[] = {
0x6f, 0xea, 0x4e, 0x21 // mvn al r1 r14 LSL 9
};
const byte kInstruction_mvn_al_r3_r2_ROR_7[] = {
0x6f, 0xea, 0xf2, 0x13 // mvn al r3 r2 ROR 7
};
const byte kInstruction_mvn_al_r14_r9_ROR_16[] = {
0x6f, 0xea, 0x39, 0x4e // mvn al r14 r9 ROR 16
};
const byte kInstruction_mvn_al_r6_r12_LSL_2[] = {
0x6f, 0xea, 0x8c, 0x06 // mvn al r6 r12 LSL 2
};
const byte kInstruction_mvn_al_r12_r7_LSL_14[] = {
0x6f, 0xea, 0x87, 0x3c // mvn al r12 r7 LSL 14
};
const byte kInstruction_mvn_al_r12_r10_LSL_8[] = {
0x6f, 0xea, 0x0a, 0x2c // mvn al r12 r10 LSL 8
};
const byte kInstruction_mvn_al_r4_r13_ROR_27[] = {
0x6f, 0xea, 0xfd, 0x64 // mvn al r4 r13 ROR 27
};
const byte kInstruction_mvn_al_r5_r5_ROR_20[] = {
0x6f, 0xea, 0x35, 0x55 // mvn al r5 r5 ROR 20
};
const byte kInstruction_mvn_al_r1_r5_ROR_14[] = {
0x6f, 0xea, 0xb5, 0x31 // mvn al r1 r5 ROR 14
};
const byte kInstruction_mvn_al_r6_r2_ROR_28[] = {
0x6f, 0xea, 0x32, 0x76 // mvn al r6 r2 ROR 28
};
const byte kInstruction_mvn_al_r1_r8_LSL_9[] = {
0x6f, 0xea, 0x48, 0x21 // mvn al r1 r8 LSL 9
};
const byte kInstruction_mvn_al_r2_r10_LSL_16[] = {
0x6f, 0xea, 0x0a, 0x42 // mvn al r2 r10 LSL 16
};
const byte kInstruction_mvn_al_r5_r1_LSL_30[] = {
0x6f, 0xea, 0x81, 0x75 // mvn al r5 r1 LSL 30
};
const byte kInstruction_mvn_al_r5_r3_ROR_19[] = {
0x6f, 0xea, 0xf3, 0x45 // mvn al r5 r3 ROR 19
};
const byte kInstruction_mvn_al_r1_r2_LSL_7[] = {
0x6f, 0xea, 0xc2, 0x11 // mvn al r1 r2 LSL 7
};
const byte kInstruction_mvn_al_r7_r10_ROR_11[] = {
0x6f, 0xea, 0xfa, 0x27 // mvn al r7 r10 ROR 11
};
const byte kInstruction_mvn_al_r0_r10_LSL_10[] = {
0x6f, 0xea, 0x8a, 0x20 // mvn al r0 r10 LSL 10
};
const byte kInstruction_mvn_al_r7_r5_ROR_1[] = {
0x6f, 0xea, 0x75, 0x07 // mvn al r7 r5 ROR 1
};
const byte kInstruction_mvn_al_r0_r1_LSL_3[] = {
0x6f, 0xea, 0xc1, 0x00 // mvn al r0 r1 LSL 3
};
const byte kInstruction_mvn_al_r11_r0_LSL_24[] = {
0x6f, 0xea, 0x00, 0x6b // mvn al r11 r0 LSL 24
};
const byte kInstruction_mvn_al_r3_r7_LSL_29[] = {
0x6f, 0xea, 0x47, 0x73 // mvn al r3 r7 LSL 29
};
const byte kInstruction_mvn_al_r5_r3_ROR_28[] = {
0x6f, 0xea, 0x33, 0x75 // mvn al r5 r3 ROR 28
};
const byte kInstruction_mvn_al_r3_r4_LSL_26[] = {
0x6f, 0xea, 0x84, 0x63 // mvn al r3 r4 LSL 26
};
const byte kInstruction_mvn_al_r8_r10_LSL_30[] = {
0x6f, 0xea, 0x8a, 0x78 // mvn al r8 r10 LSL 30
};
const byte kInstruction_mvn_al_r5_r5_ROR_7[] = {
0x6f, 0xea, 0xf5, 0x15 // mvn al r5 r5 ROR 7
};
const byte kInstruction_mvn_al_r6_r7_ROR_13[] = {
0x6f, 0xea, 0x77, 0x36 // mvn al r6 r7 ROR 13
};
const byte kInstruction_mvn_al_r7_r1_ROR_20[] = {
0x6f, 0xea, 0x31, 0x57 // mvn al r7 r1 ROR 20
};
const byte kInstruction_mvn_al_r11_r11_LSL_1[] = {
0x6f, 0xea, 0x4b, 0x0b // mvn al r11 r11 LSL 1
};
const byte kInstruction_mvn_al_r10_r13_LSL_1[] = {
0x6f, 0xea, 0x4d, 0x0a // mvn al r10 r13 LSL 1
};
const byte kInstruction_mvn_al_r6_r11_LSL_9[] = {
0x6f, 0xea, 0x4b, 0x26 // mvn al r6 r11 LSL 9
};
const byte kInstruction_mvn_al_r2_r3_LSL_18[] = {
0x6f, 0xea, 0x83, 0x42 // mvn al r2 r3 LSL 18
};
const byte kInstruction_mvn_al_r3_r4_ROR_16[] = {
0x6f, 0xea, 0x34, 0x43 // mvn al r3 r4 ROR 16
};
const byte kInstruction_mvn_al_r4_r10_LSL_1[] = {
0x6f, 0xea, 0x4a, 0x04 // mvn al r4 r10 LSL 1
};
const byte kInstruction_mvn_al_r1_r5_LSL_31[] = {
0x6f, 0xea, 0xc5, 0x71 // mvn al r1 r5 LSL 31
};
const byte kInstruction_mvn_al_r6_r6_LSL_29[] = {
0x6f, 0xea, 0x46, 0x76 // mvn al r6 r6 LSL 29
};
const byte kInstruction_mvn_al_r10_r13_LSL_5[] = {
0x6f, 0xea, 0x4d, 0x1a // mvn al r10 r13 LSL 5
};
const byte kInstruction_mvn_al_r14_r6_LSL_24[] = {
0x6f, 0xea, 0x06, 0x6e // mvn al r14 r6 LSL 24
};
const byte kInstruction_mvn_al_r4_r12_LSL_31[] = {
0x6f, 0xea, 0xcc, 0x74 // mvn al r4 r12 LSL 31
};
const byte kInstruction_mvn_al_r12_r7_ROR_6[] = {
0x6f, 0xea, 0xb7, 0x1c // mvn al r12 r7 ROR 6
};
const byte kInstruction_mvn_al_r14_r10_LSL_26[] = {
0x6f, 0xea, 0x8a, 0x6e // mvn al r14 r10 LSL 26
};
const byte kInstruction_mvn_al_r9_r9_ROR_24[] = {
0x6f, 0xea, 0x39, 0x69 // mvn al r9 r9 ROR 24
};
const byte kInstruction_mvn_al_r8_r13_LSL_5[] = {
0x6f, 0xea, 0x4d, 0x18 // mvn al r8 r13 LSL 5
};
const byte kInstruction_mvn_al_r4_r11_LSL_17[] = {
0x6f, 0xea, 0x4b, 0x44 // mvn al r4 r11 LSL 17
};
const byte kInstruction_mvn_al_r2_r14_LSL_9[] = {
0x6f, 0xea, 0x4e, 0x22 // mvn al r2 r14 LSL 9
};
const byte kInstruction_mvn_al_r1_r0_ROR_29[] = {
0x6f, 0xea, 0x70, 0x71 // mvn al r1 r0 ROR 29
};
const byte kInstruction_mvn_al_r10_r2_ROR_9[] = {
0x6f, 0xea, 0x72, 0x2a // mvn al r10 r2 ROR 9
};
const byte kInstruction_mvn_al_r3_r7_ROR_29[] = {
0x6f, 0xea, 0x77, 0x73 // mvn al r3 r7 ROR 29
};
const byte kInstruction_mvn_al_r1_r12_ROR_1[] = {
0x6f, 0xea, 0x7c, 0x01 // mvn al r1 r12 ROR 1
};
const byte kInstruction_mvn_al_r7_r2_ROR_8[] = {
0x6f, 0xea, 0x32, 0x27 // mvn al r7 r2 ROR 8
};
const byte kInstruction_mvn_al_r7_r1_LSL_24[] = {
0x6f, 0xea, 0x01, 0x67 // mvn al r7 r1 LSL 24
};
const byte kInstruction_mvn_al_r4_r1_LSL_17[] = {
0x6f, 0xea, 0x41, 0x44 // mvn al r4 r1 LSL 17
};
const byte kInstruction_mvn_al_r12_r11_ROR_22[] = {
0x6f, 0xea, 0xbb, 0x5c // mvn al r12 r11 ROR 22
};
const byte kInstruction_mvn_al_r0_r4_ROR_20[] = {
0x6f, 0xea, 0x34, 0x50 // mvn al r0 r4 ROR 20
};
const byte kInstruction_mvn_al_r5_r12_LSL_11[] = {
0x6f, 0xea, 0xcc, 0x25 // mvn al r5 r12 LSL 11
};
const byte kInstruction_mvn_al_r11_r2_ROR_31[] = {
0x6f, 0xea, 0xf2, 0x7b // mvn al r11 r2 ROR 31
};
const byte kInstruction_mvn_al_r14_r11_LSL_4[] = {
0x6f, 0xea, 0x0b, 0x1e // mvn al r14 r11 LSL 4
};
const byte kInstruction_mvn_al_r6_r8_LSL_12[] = {
0x6f, 0xea, 0x08, 0x36 // mvn al r6 r8 LSL 12
};
const byte kInstruction_mvn_al_r14_r0_LSL_30[] = {
0x6f, 0xea, 0x80, 0x7e // mvn al r14 r0 LSL 30
};
const byte kInstruction_mvn_al_r6_r11_LSL_29[] = {
0x6f, 0xea, 0x4b, 0x76 // mvn al r6 r11 LSL 29
};
const byte kInstruction_mvn_al_r6_r12_LSL_21[] = {
0x6f, 0xea, 0x4c, 0x56 // mvn al r6 r12 LSL 21
};
const byte kInstruction_mvn_al_r9_r6_LSL_29[] = {
0x6f, 0xea, 0x46, 0x79 // mvn al r9 r6 LSL 29
};
const byte kInstruction_mvn_al_r10_r13_ROR_29[] = {
0x6f, 0xea, 0x7d, 0x7a // mvn al r10 r13 ROR 29
};
const byte kInstruction_mvn_al_r5_r7_ROR_16[] = {
0x6f, 0xea, 0x37, 0x45 // mvn al r5 r7 ROR 16
};
const byte kInstruction_mvn_al_r0_r14_LSL_27[] = {
0x6f, 0xea, 0xce, 0x60 // mvn al r0 r14 LSL 27
};
const byte kInstruction_mvn_al_r14_r4_ROR_18[] = {
0x6f, 0xea, 0xb4, 0x4e // mvn al r14 r4 ROR 18
};
const byte kInstruction_mvn_al_r14_r2_LSL_28[] = {
0x6f, 0xea, 0x02, 0x7e // mvn al r14 r2 LSL 28
};
const byte kInstruction_mvn_al_r13_r3_LSL_29[] = {
0x6f, 0xea, 0x43, 0x7d // mvn al r13 r3 LSL 29
};
const byte kInstruction_mvn_al_r8_r7_LSL_19[] = {
0x6f, 0xea, 0xc7, 0x48 // mvn al r8 r7 LSL 19
};
const byte kInstruction_mvn_al_r14_r1_LSL_1[] = {
0x6f, 0xea, 0x41, 0x0e // mvn al r14 r1 LSL 1
};
const byte kInstruction_mvn_al_r1_r11_ROR_2[] = {
0x6f, 0xea, 0xbb, 0x01 // mvn al r1 r11 ROR 2
};
const byte kInstruction_mvn_al_r7_r4_ROR_14[] = {
0x6f, 0xea, 0xb4, 0x37 // mvn al r7 r4 ROR 14
};
const byte kInstruction_mvn_al_r6_r3_ROR_22[] = {
0x6f, 0xea, 0xb3, 0x56 // mvn al r6 r3 ROR 22
};
const byte kInstruction_mvn_al_r5_r4_LSL_1[] = {
0x6f, 0xea, 0x44, 0x05 // mvn al r5 r4 LSL 1
};
const byte kInstruction_mvn_al_r11_r11_LSL_6[] = {
0x6f, 0xea, 0x8b, 0x1b // mvn al r11 r11 LSL 6
};
const byte kInstruction_mvn_al_r13_r5_LSL_21[] = {
0x6f, 0xea, 0x45, 0x5d // mvn al r13 r5 LSL 21
};
const byte kInstruction_mvn_al_r7_r5_ROR_10[] = {
0x6f, 0xea, 0xb5, 0x27 // mvn al r7 r5 ROR 10
};
const byte kInstruction_mvn_al_r13_r10_LSL_17[] = {
0x6f, 0xea, 0x4a, 0x4d // mvn al r13 r10 LSL 17
};
const byte kInstruction_mvn_al_r7_r1_LSL_5[] = {
0x6f, 0xea, 0x41, 0x17 // mvn al r7 r1 LSL 5
};
const byte kInstruction_mvn_al_r0_r11_LSL_25[] = {
0x6f, 0xea, 0x4b, 0x60 // mvn al r0 r11 LSL 25
};
const byte kInstruction_mvn_al_r3_r2_LSL_9[] = {
0x6f, 0xea, 0x42, 0x23 // mvn al r3 r2 LSL 9
};
const byte kInstruction_mvn_al_r8_r11_ROR_12[] = {
0x6f, 0xea, 0x3b, 0x38 // mvn al r8 r11 ROR 12
};
const byte kInstruction_mvn_al_r12_r9_LSL_21[] = {
0x6f, 0xea, 0x49, 0x5c // mvn al r12 r9 LSL 21
};
const byte kInstruction_mvn_al_r14_r3_ROR_13[] = {
0x6f, 0xea, 0x73, 0x3e // mvn al r14 r3 ROR 13
};
const byte kInstruction_mvn_al_r13_r8_ROR_26[] = {
0x6f, 0xea, 0xb8, 0x6d // mvn al r13 r8 ROR 26
};
const byte kInstruction_mvn_al_r4_r11_ROR_11[] = {
0x6f, 0xea, 0xfb, 0x24 // mvn al r4 r11 ROR 11
};
const byte kInstruction_mvn_al_r10_r3_ROR_16[] = {
0x6f, 0xea, 0x33, 0x4a // mvn al r10 r3 ROR 16
};
const byte kInstruction_mvn_al_r14_r0_ROR_12[] = {
0x6f, 0xea, 0x30, 0x3e // mvn al r14 r0 ROR 12
};
const byte kInstruction_mvn_al_r11_r4_LSL_18[] = {
0x6f, 0xea, 0x84, 0x4b // mvn al r11 r4 LSL 18
};
const byte kInstruction_mvn_al_r13_r13_ROR_3[] = {
0x6f, 0xea, 0xfd, 0x0d // mvn al r13 r13 ROR 3
};
const byte kInstruction_mvn_al_r10_r14_ROR_10[] = {
0x6f, 0xea, 0xbe, 0x2a // mvn al r10 r14 ROR 10
};
const byte kInstruction_mvn_al_r12_r10_LSL_12[] = {
0x6f, 0xea, 0x0a, 0x3c // mvn al r12 r10 LSL 12
};
const byte kInstruction_mvn_al_r0_r0_ROR_29[] = {
0x6f, 0xea, 0x70, 0x70 // mvn al r0 r0 ROR 29
};
const byte kInstruction_mvn_al_r13_r3_LSL_4[] = {
0x6f, 0xea, 0x03, 0x1d // mvn al r13 r3 LSL 4
};
const byte kInstruction_mvn_al_r1_r10_LSL_15[] = {
0x6f, 0xea, 0xca, 0x31 // mvn al r1 r10 LSL 15
};
const byte kInstruction_mvn_al_r3_r10_LSL_18[] = {
0x6f, 0xea, 0x8a, 0x43 // mvn al r3 r10 LSL 18
};
const byte kInstruction_mvn_al_r11_r14_ROR_13[] = {
0x6f, 0xea, 0x7e, 0x3b // mvn al r11 r14 ROR 13
};
const byte kInstruction_mvn_al_r5_r8_ROR_9[] = {
0x6f, 0xea, 0x78, 0x25 // mvn al r5 r8 ROR 9
};
const byte kInstruction_mvn_al_r1_r7_LSL_3[] = {
0x6f, 0xea, 0xc7, 0x01 // mvn al r1 r7 LSL 3
};
const byte kInstruction_mvn_al_r8_r9_LSL_16[] = {
0x6f, 0xea, 0x09, 0x48 // mvn al r8 r9 LSL 16
};
const byte kInstruction_mvn_al_r6_r6_ROR_29[] = {
0x6f, 0xea, 0x76, 0x76 // mvn al r6 r6 ROR 29
};
const byte kInstruction_mvn_al_r4_r10_ROR_6[] = {
0x6f, 0xea, 0xba, 0x14 // mvn al r4 r10 ROR 6
};
const byte kInstruction_mvn_al_r13_r7_LSL_8[] = {
0x6f, 0xea, 0x07, 0x2d // mvn al r13 r7 LSL 8
};
const byte kInstruction_mvn_al_r0_r0_LSL_26[] = {
0x6f, 0xea, 0x80, 0x60 // mvn al r0 r0 LSL 26
};
const byte kInstruction_mvn_al_r6_r3_ROR_14[] = {
0x6f, 0xea, 0xb3, 0x36 // mvn al r6 r3 ROR 14
};
const byte kInstruction_mvn_al_r13_r12_ROR_16[] = {
0x6f, 0xea, 0x3c, 0x4d // mvn al r13 r12 ROR 16
};
const byte kInstruction_mvn_al_r0_r14_ROR_16[] = {
0x6f, 0xea, 0x3e, 0x40 // mvn al r0 r14 ROR 16
};
const byte kInstruction_mvn_al_r2_r13_ROR_3[] = {
0x6f, 0xea, 0xfd, 0x02 // mvn al r2 r13 ROR 3
};
const byte kInstruction_mvn_al_r3_r5_LSL_31[] = {
0x6f, 0xea, 0xc5, 0x73 // mvn al r3 r5 LSL 31
};
const byte kInstruction_mvn_al_r12_r10_LSL_14[] = {
0x6f, 0xea, 0x8a, 0x3c // mvn al r12 r10 LSL 14
};
const byte kInstruction_mvn_al_r5_r10_LSL_24[] = {
0x6f, 0xea, 0x0a, 0x65 // mvn al r5 r10 LSL 24
};
const byte kInstruction_mvn_al_r5_r5_LSL_21[] = {
0x6f, 0xea, 0x45, 0x55 // mvn al r5 r5 LSL 21
};
const byte kInstruction_mvn_al_r1_r1_LSL_23[] = {
0x6f, 0xea, 0xc1, 0x51 // mvn al r1 r1 LSL 23
};
const byte kInstruction_mvn_al_r6_r0_LSL_12[] = {
0x6f, 0xea, 0x00, 0x36 // mvn al r6 r0 LSL 12
};
const byte kInstruction_mvn_al_r6_r2_ROR_22[] = {
0x6f, 0xea, 0xb2, 0x56 // mvn al r6 r2 ROR 22
};
const byte kInstruction_mvn_al_r10_r0_LSL_15[] = {
0x6f, 0xea, 0xc0, 0x3a // mvn al r10 r0 LSL 15
};
const byte kInstruction_mvn_al_r14_r9_ROR_28[] = {
0x6f, 0xea, 0x39, 0x7e // mvn al r14 r9 ROR 28
};
const byte kInstruction_mvn_al_r0_r2_ROR_6[] = {
0x6f, 0xea, 0xb2, 0x10 // mvn al r0 r2 ROR 6
};
const byte kInstruction_mvn_al_r9_r4_LSL_11[] = {
0x6f, 0xea, 0xc4, 0x29 // mvn al r9 r4 LSL 11
};
const byte kInstruction_mvn_al_r5_r11_LSL_5[] = {
0x6f, 0xea, 0x4b, 0x15 // mvn al r5 r11 LSL 5
};
const byte kInstruction_mvn_al_r7_r4_ROR_6[] = {
0x6f, 0xea, 0xb4, 0x17 // mvn al r7 r4 ROR 6
};
const byte kInstruction_mvn_al_r2_r10_ROR_1[] = {
0x6f, 0xea, 0x7a, 0x02 // mvn al r2 r10 ROR 1
};
const byte kInstruction_mvn_al_r2_r3_LSL_27[] = {
0x6f, 0xea, 0xc3, 0x62 // mvn al r2 r3 LSL 27
};
const byte kInstruction_mvn_al_r5_r13_LSL_10[] = {
0x6f, 0xea, 0x8d, 0x25 // mvn al r5 r13 LSL 10
};
const byte kInstruction_mvn_al_r10_r3_LSL_14[] = {
0x6f, 0xea, 0x83, 0x3a // mvn al r10 r3 LSL 14
};
const byte kInstruction_mvn_al_r12_r7_ROR_29[] = {
0x6f, 0xea, 0x77, 0x7c // mvn al r12 r7 ROR 29
};
const byte kInstruction_mvn_al_r0_r0_ROR_1[] = {
0x6f, 0xea, 0x70, 0x00 // mvn al r0 r0 ROR 1
};
const byte kInstruction_mvn_al_r11_r13_LSL_21[] = {
0x6f, 0xea, 0x4d, 0x5b // mvn al r11 r13 LSL 21
};
const byte kInstruction_mvn_al_r7_r2_LSL_12[] = {
0x6f, 0xea, 0x02, 0x37 // mvn al r7 r2 LSL 12
};
const byte kInstruction_mvn_al_r1_r10_LSL_2[] = {
0x6f, 0xea, 0x8a, 0x01 // mvn al r1 r10 LSL 2
};
const byte kInstruction_mvn_al_r11_r5_LSL_19[] = {
0x6f, 0xea, 0xc5, 0x4b // mvn al r11 r5 LSL 19
};
const byte kInstruction_mvn_al_r13_r2_ROR_2[] = {
0x6f, 0xea, 0xb2, 0x0d // mvn al r13 r2 ROR 2
};
const byte kInstruction_mvn_al_r7_r9_LSL_8[] = {
0x6f, 0xea, 0x09, 0x27 // mvn al r7 r9 LSL 8
};
const byte kInstruction_mvn_al_r5_r9_ROR_8[] = {
0x6f, 0xea, 0x39, 0x25 // mvn al r5 r9 ROR 8
};
const byte kInstruction_mvn_al_r10_r14_LSL_31[] = {
0x6f, 0xea, 0xce, 0x7a // mvn al r10 r14 LSL 31
};
const byte kInstruction_mvn_al_r0_r2_ROR_23[] = {
0x6f, 0xea, 0xf2, 0x50 // mvn al r0 r2 ROR 23
};
const byte kInstruction_mvn_al_r14_r13_LSL_28[] = {
0x6f, 0xea, 0x0d, 0x7e // mvn al r14 r13 LSL 28
};
const byte kInstruction_mvn_al_r1_r2_LSL_25[] = {
0x6f, 0xea, 0x42, 0x61 // mvn al r1 r2 LSL 25
};
const byte kInstruction_mvn_al_r3_r5_LSL_29[] = {
0x6f, 0xea, 0x45, 0x73 // mvn al r3 r5 LSL 29
};
const byte kInstruction_mvn_al_r3_r4_ROR_13[] = {
0x6f, 0xea, 0x74, 0x33 // mvn al r3 r4 ROR 13
};
const byte kInstruction_mvn_al_r4_r6_ROR_4[] = {
0x6f, 0xea, 0x36, 0x14 // mvn al r4 r6 ROR 4
};
const byte kInstruction_mvn_al_r6_r8_ROR_3[] = {
0x6f, 0xea, 0xf8, 0x06 // mvn al r6 r8 ROR 3
};
const byte kInstruction_mvn_al_r11_r2_ROR_2[] = {
0x6f, 0xea, 0xb2, 0x0b // mvn al r11 r2 ROR 2
};
const byte kInstruction_mvn_al_r14_r5_LSL_29[] = {
0x6f, 0xea, 0x45, 0x7e // mvn al r14 r5 LSL 29
};
const byte kInstruction_mvn_al_r0_r7_ROR_23[] = {
0x6f, 0xea, 0xf7, 0x50 // mvn al r0 r7 ROR 23
};
const byte kInstruction_mvn_al_r2_r10_LSL_15[] = {
0x6f, 0xea, 0xca, 0x32 // mvn al r2 r10 LSL 15
};
const byte kInstruction_mvn_al_r6_r7_LSL_5[] = {
0x6f, 0xea, 0x47, 0x16 // mvn al r6 r7 LSL 5
};
const byte kInstruction_mvn_al_r11_r13_ROR_3[] = {
0x6f, 0xea, 0xfd, 0x0b // mvn al r11 r13 ROR 3
};
const byte kInstruction_mvn_al_r5_r12_ROR_13[] = {
0x6f, 0xea, 0x7c, 0x35 // mvn al r5 r12 ROR 13
};
const byte kInstruction_mvn_al_r9_r12_LSL_26[] = {
0x6f, 0xea, 0x8c, 0x69 // mvn al r9 r12 LSL 26
};
const byte kInstruction_mvn_al_r7_r3_ROR_12[] = {
0x6f, 0xea, 0x33, 0x37 // mvn al r7 r3 ROR 12
};
const byte kInstruction_mvn_al_r9_r13_LSL_7[] = {
0x6f, 0xea, 0xcd, 0x19 // mvn al r9 r13 LSL 7
};
const byte kInstruction_mvn_al_r6_r14_LSL_25[] = {
0x6f, 0xea, 0x4e, 0x66 // mvn al r6 r14 LSL 25
};
const byte kInstruction_mvn_al_r1_r12_ROR_17[] = {
0x6f, 0xea, 0x7c, 0x41 // mvn al r1 r12 ROR 17
};
const byte kInstruction_mvn_al_r1_r10_LSL_24[] = {
0x6f, 0xea, 0x0a, 0x61 // mvn al r1 r10 LSL 24
};
const byte kInstruction_mvn_al_r0_r11_LSL_17[] = {
0x6f, 0xea, 0x4b, 0x40 // mvn al r0 r11 LSL 17
};
const byte kInstruction_mvn_al_r8_r3_ROR_11[] = {
0x6f, 0xea, 0xf3, 0x28 // mvn al r8 r3 ROR 11
};
const byte kInstruction_mvn_al_r11_r12_ROR_22[] = {
0x6f, 0xea, 0xbc, 0x5b // mvn al r11 r12 ROR 22
};
const byte kInstruction_mvn_al_r0_r9_ROR_28[] = {
0x6f, 0xea, 0x39, 0x70 // mvn al r0 r9 ROR 28
};
const byte kInstruction_mvn_al_r9_r3_ROR_7[] = {
0x6f, 0xea, 0xf3, 0x19 // mvn al r9 r3 ROR 7
};
const byte kInstruction_mvn_al_r9_r2_ROR_16[] = {
0x6f, 0xea, 0x32, 0x49 // mvn al r9 r2 ROR 16
};
const byte kInstruction_mvn_al_r0_r12_LSL_28[] = {
0x6f, 0xea, 0x0c, 0x70 // mvn al r0 r12 LSL 28
};
const byte kInstruction_mvn_al_r1_r4_ROR_22[] = {
0x6f, 0xea, 0xb4, 0x51 // mvn al r1 r4 ROR 22
};
const byte kInstruction_mvn_al_r12_r7_LSL_16[] = {
0x6f, 0xea, 0x07, 0x4c // mvn al r12 r7 LSL 16
};
const byte kInstruction_mvn_al_r7_r9_ROR_3[] = {
0x6f, 0xea, 0xf9, 0x07 // mvn al r7 r9 ROR 3
};
const byte kInstruction_mvn_al_r8_r2_LSL_13[] = {
0x6f, 0xea, 0x42, 0x38 // mvn al r8 r2 LSL 13
};
const byte kInstruction_mvn_al_r10_r11_LSL_10[] = {
0x6f, 0xea, 0x8b, 0x2a // mvn al r10 r11 LSL 10
};
const byte kInstruction_mvn_al_r10_r12_ROR_6[] = {
0x6f, 0xea, 0xbc, 0x1a // mvn al r10 r12 ROR 6
};
const byte kInstruction_mvn_al_r3_r12_LSL_27[] = {
0x6f, 0xea, 0xcc, 0x63 // mvn al r3 r12 LSL 27
};
const byte kInstruction_mvn_al_r10_r10_ROR_27[] = {
0x6f, 0xea, 0xfa, 0x6a // mvn al r10 r10 ROR 27
};
const byte kInstruction_mvn_al_r8_r8_LSL_8[] = {
0x6f, 0xea, 0x08, 0x28 // mvn al r8 r8 LSL 8
};
const byte kInstruction_mvn_al_r3_r0_ROR_28[] = {
0x6f, 0xea, 0x30, 0x73 // mvn al r3 r0 ROR 28
};
const byte kInstruction_mvn_al_r10_r3_ROR_15[] = {
0x6f, 0xea, 0xf3, 0x3a // mvn al r10 r3 ROR 15
};
const byte kInstruction_mvn_al_r1_r14_LSL_27[] = {
0x6f, 0xea, 0xce, 0x61 // mvn al r1 r14 LSL 27
};
const byte kInstruction_mvn_al_r10_r1_LSL_31[] = {
0x6f, 0xea, 0xc1, 0x7a // mvn al r10 r1 LSL 31
};
const byte kInstruction_mvn_al_r12_r11_LSL_24[] = {
0x6f, 0xea, 0x0b, 0x6c // mvn al r12 r11 LSL 24
};
const byte kInstruction_mvn_al_r5_r11_ROR_11[] = {
0x6f, 0xea, 0xfb, 0x25 // mvn al r5 r11 ROR 11
};
const byte kInstruction_mvn_al_r13_r8_ROR_12[] = {
0x6f, 0xea, 0x38, 0x3d // mvn al r13 r8 ROR 12
};
const byte kInstruction_mvn_al_r1_r14_LSL_28[] = {
0x6f, 0xea, 0x0e, 0x71 // mvn al r1 r14 LSL 28
};
const byte kInstruction_mvn_al_r6_r2_LSL_6[] = {
0x6f, 0xea, 0x82, 0x16 // mvn al r6 r2 LSL 6
};
const byte kInstruction_mvn_al_r14_r13_ROR_22[] = {
0x6f, 0xea, 0xbd, 0x5e // mvn al r14 r13 ROR 22
};
const byte kInstruction_mvn_al_r12_r12_ROR_18[] = {
0x6f, 0xea, 0xbc, 0x4c // mvn al r12 r12 ROR 18
};
const byte kInstruction_mvn_al_r8_r7_ROR_2[] = {
0x6f, 0xea, 0xb7, 0x08 // mvn al r8 r7 ROR 2
};
const byte kInstruction_mvn_al_r6_r4_LSL_2[] = {
0x6f, 0xea, 0x84, 0x06 // mvn al r6 r4 LSL 2
};
const byte kInstruction_mvn_al_r2_r6_ROR_17[] = {
0x6f, 0xea, 0x76, 0x42 // mvn al r2 r6 ROR 17
};
const byte kInstruction_mvn_al_r11_r14_ROR_16[] = {
0x6f, 0xea, 0x3e, 0x4b // mvn al r11 r14 ROR 16
};
const byte kInstruction_mvn_al_r1_r5_ROR_22[] = {
0x6f, 0xea, 0xb5, 0x51 // mvn al r1 r5 ROR 22
};
const byte kInstruction_mvn_al_r2_r2_ROR_11[] = {
0x6f, 0xea, 0xf2, 0x22 // mvn al r2 r2 ROR 11
};
const byte kInstruction_mvn_al_r12_r9_ROR_1[] = {
0x6f, 0xea, 0x79, 0x0c // mvn al r12 r9 ROR 1
};
const byte kInstruction_mvn_al_r13_r5_LSL_13[] = {
0x6f, 0xea, 0x45, 0x3d // mvn al r13 r5 LSL 13
};
const byte kInstruction_mvn_al_r0_r0_LSL_3[] = {
0x6f, 0xea, 0xc0, 0x00 // mvn al r0 r0 LSL 3
};
const byte kInstruction_mvn_al_r0_r11_ROR_9[] = {
0x6f, 0xea, 0x7b, 0x20 // mvn al r0 r11 ROR 9
};
const byte kInstruction_mvn_al_r6_r1_LSL_18[] = {
0x6f, 0xea, 0x81, 0x46 // mvn al r6 r1 LSL 18
};
const byte kInstruction_mvn_al_r6_r3_LSL_21[] = {
0x6f, 0xea, 0x43, 0x56 // mvn al r6 r3 LSL 21
};
const byte kInstruction_mvn_al_r7_r6_LSL_30[] = {
0x6f, 0xea, 0x86, 0x77 // mvn al r7 r6 LSL 30
};
const byte kInstruction_mvn_al_r11_r3_ROR_28[] = {
0x6f, 0xea, 0x33, 0x7b // mvn al r11 r3 ROR 28
};
const byte kInstruction_mvn_al_r0_r4_ROR_14[] = {
0x6f, 0xea, 0xb4, 0x30 // mvn al r0 r4 ROR 14
};
const byte kInstruction_mvn_al_r1_r14_ROR_22[] = {
0x6f, 0xea, 0xbe, 0x51 // mvn al r1 r14 ROR 22
};
const byte kInstruction_mvn_al_r3_r13_LSL_30[] = {
0x6f, 0xea, 0x8d, 0x73 // mvn al r3 r13 LSL 30
};
const byte kInstruction_mvn_al_r14_r6_LSL_14[] = {
0x6f, 0xea, 0x86, 0x3e // mvn al r14 r6 LSL 14
};
const byte kInstruction_mvn_al_r11_r10_ROR_1[] = {
0x6f, 0xea, 0x7a, 0x0b // mvn al r11 r10 ROR 1
};
const byte kInstruction_mvn_al_r11_r13_ROR_15[] = {
0x6f, 0xea, 0xfd, 0x3b // mvn al r11 r13 ROR 15
};
const byte kInstruction_mvn_al_r5_r11_LSL_28[] = {
0x6f, 0xea, 0x0b, 0x75 // mvn al r5 r11 LSL 28
};
const byte kInstruction_mvn_al_r9_r12_ROR_28[] = {
0x6f, 0xea, 0x3c, 0x79 // mvn al r9 r12 ROR 28
};
const byte kInstruction_mvn_al_r14_r9_ROR_31[] = {
0x6f, 0xea, 0xf9, 0x7e // mvn al r14 r9 ROR 31
};
const byte kInstruction_mvn_al_r7_r4_LSL_24[] = {
0x6f, 0xea, 0x04, 0x67 // mvn al r7 r4 LSL 24
};
const byte kInstruction_mvn_al_r11_r14_ROR_6[] = {
0x6f, 0xea, 0xbe, 0x1b // mvn al r11 r14 ROR 6
};
const byte kInstruction_mvn_al_r2_r12_LSL_5[] = {
0x6f, 0xea, 0x4c, 0x12 // mvn al r2 r12 LSL 5
};
const byte kInstruction_mvn_al_r1_r14_ROR_6[] = {
0x6f, 0xea, 0xbe, 0x11 // mvn al r1 r14 ROR 6
};
const byte kInstruction_mvn_al_r6_r4_LSL_20[] = {
0x6f, 0xea, 0x04, 0x56 // mvn al r6 r4 LSL 20
};
const byte kInstruction_mvn_al_r10_r7_LSL_26[] = {
0x6f, 0xea, 0x87, 0x6a // mvn al r10 r7 LSL 26
};
const byte kInstruction_mvn_al_r5_r10_LSL_23[] = {
0x6f, 0xea, 0xca, 0x55 // mvn al r5 r10 LSL 23
};
const byte kInstruction_mvn_al_r9_r5_ROR_27[] = {
0x6f, 0xea, 0xf5, 0x69 // mvn al r9 r5 ROR 27
};
const byte kInstruction_mvn_al_r6_r9_ROR_19[] = {
0x6f, 0xea, 0xf9, 0x46 // mvn al r6 r9 ROR 19
};
const byte kInstruction_mvn_al_r2_r0_LSL_29[] = {
0x6f, 0xea, 0x40, 0x72 // mvn al r2 r0 LSL 29
};
const byte kInstruction_mvn_al_r3_r11_ROR_9[] = {
0x6f, 0xea, 0x7b, 0x23 // mvn al r3 r11 ROR 9
};
const byte kInstruction_mvn_al_r0_r14_LSL_7[] = {
0x6f, 0xea, 0xce, 0x10 // mvn al r0 r14 LSL 7
};
const byte kInstruction_mvn_al_r5_r11_LSL_10[] = {
0x6f, 0xea, 0x8b, 0x25 // mvn al r5 r11 LSL 10
};
const byte kInstruction_mvn_al_r12_r9_ROR_25[] = {
0x6f, 0xea, 0x79, 0x6c // mvn al r12 r9 ROR 25
};
const byte kInstruction_mvn_al_r11_r1_ROR_2[] = {
0x6f, 0xea, 0xb1, 0x0b // mvn al r11 r1 ROR 2
};
const byte kInstruction_mvn_al_r8_r7_ROR_14[] = {
0x6f, 0xea, 0xb7, 0x38 // mvn al r8 r7 ROR 14
};
const byte kInstruction_mvn_al_r7_r0_ROR_1[] = {
0x6f, 0xea, 0x70, 0x07 // mvn al r7 r0 ROR 1
};
const byte kInstruction_mvn_al_r3_r2_ROR_18[] = {
0x6f, 0xea, 0xb2, 0x43 // mvn al r3 r2 ROR 18
};
const byte kInstruction_mvn_al_r14_r12_LSL_4[] = {
0x6f, 0xea, 0x0c, 0x1e // mvn al r14 r12 LSL 4
};
const byte kInstruction_mvn_al_r12_r5_ROR_8[] = {
0x6f, 0xea, 0x35, 0x2c // mvn al r12 r5 ROR 8
};
const byte kInstruction_mvn_al_r6_r9_ROR_27[] = {
0x6f, 0xea, 0xf9, 0x66 // mvn al r6 r9 ROR 27
};
const byte kInstruction_mvn_al_r10_r13_LSL_8[] = {
0x6f, 0xea, 0x0d, 0x2a // mvn al r10 r13 LSL 8
};
const byte kInstruction_mvn_al_r10_r11_ROR_9[] = {
0x6f, 0xea, 0x7b, 0x2a // mvn al r10 r11 ROR 9
};
const byte kInstruction_mvn_al_r2_r6_ROR_5[] = {
0x6f, 0xea, 0x76, 0x12 // mvn al r2 r6 ROR 5
};
const byte kInstruction_mvn_al_r9_r3_LSL_17[] = {
0x6f, 0xea, 0x43, 0x49 // mvn al r9 r3 LSL 17
};
const byte kInstruction_mvn_al_r12_r7_ROR_19[] = {
0x6f, 0xea, 0xf7, 0x4c // mvn al r12 r7 ROR 19
};
const byte kInstruction_mvn_al_r9_r5_LSL_11[] = {
0x6f, 0xea, 0xc5, 0x29 // mvn al r9 r5 LSL 11
};
const byte kInstruction_mvn_al_r14_r9_LSL_20[] = {
0x6f, 0xea, 0x09, 0x5e // mvn al r14 r9 LSL 20
};
const byte kInstruction_mvn_al_r6_r2_ROR_4[] = {
0x6f, 0xea, 0x32, 0x16 // mvn al r6 r2 ROR 4
};
const byte kInstruction_mvn_al_r8_r4_LSL_3[] = {
0x6f, 0xea, 0xc4, 0x08 // mvn al r8 r4 LSL 3
};
const byte kInstruction_mvn_al_r5_r0_ROR_22[] = {
0x6f, 0xea, 0xb0, 0x55 // mvn al r5 r0 ROR 22
};
const byte kInstruction_mvn_al_r10_r6_LSL_13[] = {
0x6f, 0xea, 0x46, 0x3a // mvn al r10 r6 LSL 13
};
const byte kInstruction_mvn_al_r10_r4_ROR_7[] = {
0x6f, 0xea, 0xf4, 0x1a // mvn al r10 r4 ROR 7
};
const byte kInstruction_mvn_al_r6_r2_ROR_17[] = {
0x6f, 0xea, 0x72, 0x46 // mvn al r6 r2 ROR 17
};
const byte kInstruction_mvn_al_r9_r8_LSL_26[] = {
0x6f, 0xea, 0x88, 0x69 // mvn al r9 r8 LSL 26
};
const byte kInstruction_mvn_al_r6_r11_ROR_15[] = {
0x6f, 0xea, 0xfb, 0x36 // mvn al r6 r11 ROR 15
};
const byte kInstruction_mvn_al_r12_r14_LSL_8[] = {
0x6f, 0xea, 0x0e, 0x2c // mvn al r12 r14 LSL 8
};
const byte kInstruction_mvn_al_r4_r3_ROR_3[] = {
0x6f, 0xea, 0xf3, 0x04 // mvn al r4 r3 ROR 3
};
const byte kInstruction_mvn_al_r9_r5_LSL_12[] = {
0x6f, 0xea, 0x05, 0x39 // mvn al r9 r5 LSL 12
};
const byte kInstruction_mvn_al_r6_r3_ROR_13[] = {
0x6f, 0xea, 0x73, 0x36 // mvn al r6 r3 ROR 13
};
const byte kInstruction_mvn_al_r10_r13_LSL_21[] = {
0x6f, 0xea, 0x4d, 0x5a // mvn al r10 r13 LSL 21
};
const byte kInstruction_mvn_al_r4_r0_ROR_3[] = {
0x6f, 0xea, 0xf0, 0x04 // mvn al r4 r0 ROR 3
};
const byte kInstruction_mvn_al_r9_r11_LSL_8[] = {
0x6f, 0xea, 0x0b, 0x29 // mvn al r9 r11 LSL 8
};
const byte kInstruction_mvn_al_r0_r14_ROR_14[] = {
0x6f, 0xea, 0xbe, 0x30 // mvn al r0 r14 ROR 14
};
const byte kInstruction_mvn_al_r9_r9_ROR_14[] = {
0x6f, 0xea, 0xb9, 0x39 // mvn al r9 r9 ROR 14
};
const byte kInstruction_mvn_al_r8_r14_ROR_18[] = {
0x6f, 0xea, 0xbe, 0x48 // mvn al r8 r14 ROR 18
};
const byte kInstruction_mvn_al_r13_r2_ROR_13[] = {
0x6f, 0xea, 0x72, 0x3d // mvn al r13 r2 ROR 13
};
const byte kInstruction_mvn_al_r13_r13_LSL_12[] = {
0x6f, 0xea, 0x0d, 0x3d // mvn al r13 r13 LSL 12
};
const byte kInstruction_mvn_al_r14_r9_LSL_25[] = {
0x6f, 0xea, 0x49, 0x6e // mvn al r14 r9 LSL 25
};
const byte kInstruction_mvn_al_r1_r0_ROR_9[] = {
0x6f, 0xea, 0x70, 0x21 // mvn al r1 r0 ROR 9
};
const byte kInstruction_mvn_al_r12_r6_ROR_20[] = {
0x6f, 0xea, 0x36, 0x5c // mvn al r12 r6 ROR 20
};
const byte kInstruction_mvn_al_r9_r2_ROR_23[] = {
0x6f, 0xea, 0xf2, 0x59 // mvn al r9 r2 ROR 23
};
const byte kInstruction_mvn_al_r2_r10_LSL_1[] = {
0x6f, 0xea, 0x4a, 0x02 // mvn al r2 r10 LSL 1
};
const byte kInstruction_mvn_al_r8_r7_ROR_15[] = {
0x6f, 0xea, 0xf7, 0x38 // mvn al r8 r7 ROR 15
};
const byte kInstruction_mvn_al_r5_r3_ROR_14[] = {
0x6f, 0xea, 0xb3, 0x35 // mvn al r5 r3 ROR 14
};
const byte kInstruction_mvn_al_r4_r8_ROR_1[] = {
0x6f, 0xea, 0x78, 0x04 // mvn al r4 r8 ROR 1
};
const byte kInstruction_mvn_al_r1_r2_ROR_5[] = {
0x6f, 0xea, 0x72, 0x11 // mvn al r1 r2 ROR 5
};
const byte kInstruction_mvn_al_r6_r2_ROR_16[] = {
0x6f, 0xea, 0x32, 0x46 // mvn al r6 r2 ROR 16
};
const byte kInstruction_mvn_al_r5_r4_LSL_15[] = {
0x6f, 0xea, 0xc4, 0x35 // mvn al r5 r4 LSL 15
};
const byte kInstruction_mvn_al_r4_r2_LSL_14[] = {
0x6f, 0xea, 0x82, 0x34 // mvn al r4 r2 LSL 14
};
const byte kInstruction_mvn_al_r2_r1_LSL_7[] = {
0x6f, 0xea, 0xc1, 0x12 // mvn al r2 r1 LSL 7
};
const byte kInstruction_mvn_al_r0_r8_ROR_30[] = {
0x6f, 0xea, 0xb8, 0x70 // mvn al r0 r8 ROR 30
};
const byte kInstruction_mvn_al_r9_r5_LSL_22[] = {
0x6f, 0xea, 0x85, 0x59 // mvn al r9 r5 LSL 22
};
const byte kInstruction_mvn_al_r9_r10_LSL_25[] = {
0x6f, 0xea, 0x4a, 0x69 // mvn al r9 r10 LSL 25
};
const byte kInstruction_mvn_al_r4_r6_ROR_15[] = {
0x6f, 0xea, 0xf6, 0x34 // mvn al r4 r6 ROR 15
};
const byte kInstruction_mvn_al_r2_r9_LSL_29[] = {
0x6f, 0xea, 0x49, 0x72 // mvn al r2 r9 LSL 29
};
const byte kInstruction_mvn_al_r6_r6_ROR_27[] = {
0x6f, 0xea, 0xf6, 0x66 // mvn al r6 r6 ROR 27
};
const byte kInstruction_mvn_al_r11_r1_ROR_26[] = {
0x6f, 0xea, 0xb1, 0x6b // mvn al r11 r1 ROR 26
};
const byte kInstruction_mvn_al_r5_r10_ROR_23[] = {
0x6f, 0xea, 0xfa, 0x55 // mvn al r5 r10 ROR 23
};
const byte kInstruction_mvn_al_r13_r5_LSL_29[] = {
0x6f, 0xea, 0x45, 0x7d // mvn al r13 r5 LSL 29
};
const byte kInstruction_mvn_al_r14_r1_ROR_27[] = {
0x6f, 0xea, 0xf1, 0x6e // mvn al r14 r1 ROR 27
};
const byte kInstruction_mvn_al_r0_r10_LSL_27[] = {
0x6f, 0xea, 0xca, 0x60 // mvn al r0 r10 LSL 27
};
const byte kInstruction_mvn_al_r2_r4_ROR_14[] = {
0x6f, 0xea, 0xb4, 0x32 // mvn al r2 r4 ROR 14
};
const byte kInstruction_mvn_al_r1_r10_LSL_31[] = {
0x6f, 0xea, 0xca, 0x71 // mvn al r1 r10 LSL 31
};
const byte kInstruction_mvn_al_r2_r3_ROR_5[] = {
0x6f, 0xea, 0x73, 0x12 // mvn al r2 r3 ROR 5
};
const byte kInstruction_mvn_al_r0_r6_ROR_14[] = {
0x6f, 0xea, 0xb6, 0x30 // mvn al r0 r6 ROR 14
};
const byte kInstruction_mvn_al_r11_r9_ROR_25[] = {
0x6f, 0xea, 0x79, 0x6b // mvn al r11 r9 ROR 25
};
const byte kInstruction_mvn_al_r2_r11_ROR_29[] = {
0x6f, 0xea, 0x7b, 0x72 // mvn al r2 r11 ROR 29
};
const byte kInstruction_mvn_al_r7_r6_ROR_2[] = {
0x6f, 0xea, 0xb6, 0x07 // mvn al r7 r6 ROR 2
};
const byte kInstruction_mvn_al_r8_r3_ROR_3[] = {
0x6f, 0xea, 0xf3, 0x08 // mvn al r8 r3 ROR 3
};
const byte kInstruction_mvn_al_r8_r13_LSL_18[] = {
0x6f, 0xea, 0x8d, 0x48 // mvn al r8 r13 LSL 18
};
const byte kInstruction_mvn_al_r3_r13_ROR_27[] = {
0x6f, 0xea, 0xfd, 0x63 // mvn al r3 r13 ROR 27
};
const byte kInstruction_mvn_al_r5_r5_LSL_18[] = {
0x6f, 0xea, 0x85, 0x45 // mvn al r5 r5 LSL 18
};
const byte kInstruction_mvn_al_r14_r8_ROR_17[] = {
0x6f, 0xea, 0x78, 0x4e // mvn al r14 r8 ROR 17
};
const byte kInstruction_mvn_al_r10_r6_LSL_18[] = {
0x6f, 0xea, 0x86, 0x4a // mvn al r10 r6 LSL 18
};
const byte kInstruction_mvn_al_r7_r1_LSL_2[] = {
0x6f, 0xea, 0x81, 0x07 // mvn al r7 r1 LSL 2
};
const byte kInstruction_mvn_al_r9_r7_ROR_13[] = {
0x6f, 0xea, 0x77, 0x39 // mvn al r9 r7 ROR 13
};
const byte kInstruction_mvn_al_r5_r9_LSL_29[] = {
0x6f, 0xea, 0x49, 0x75 // mvn al r5 r9 LSL 29
};
const byte kInstruction_mvn_al_r14_r12_LSL_22[] = {
0x6f, 0xea, 0x8c, 0x5e // mvn al r14 r12 LSL 22
};
const byte kInstruction_mvn_al_r0_r8_LSL_12[] = {
0x6f, 0xea, 0x08, 0x30 // mvn al r0 r8 LSL 12
};
const byte kInstruction_mvn_al_r12_r12_ROR_28[] = {
0x6f, 0xea, 0x3c, 0x7c // mvn al r12 r12 ROR 28
};
const byte kInstruction_mvn_al_r12_r3_LSL_2[] = {
0x6f, 0xea, 0x83, 0x0c // mvn al r12 r3 LSL 2
};
const byte kInstruction_mvn_al_r6_r11_ROR_3[] = {
0x6f, 0xea, 0xfb, 0x06 // mvn al r6 r11 ROR 3
};
const byte kInstruction_mvn_al_r1_r5_ROR_21[] = {
0x6f, 0xea, 0x75, 0x51 // mvn al r1 r5 ROR 21
};
const byte kInstruction_mvn_al_r0_r14_ROR_29[] = {
0x6f, 0xea, 0x7e, 0x70 // mvn al r0 r14 ROR 29
};
const byte kInstruction_mvn_al_r11_r8_ROR_16[] = {
0x6f, 0xea, 0x38, 0x4b // mvn al r11 r8 ROR 16
};
const byte kInstruction_mvn_al_r9_r10_ROR_31[] = {
0x6f, 0xea, 0xfa, 0x79 // mvn al r9 r10 ROR 31
};
const byte kInstruction_mvn_al_r10_r1_LSL_25[] = {
0x6f, 0xea, 0x41, 0x6a // mvn al r10 r1 LSL 25
};
const byte kInstruction_mvn_al_r9_r4_ROR_1[] = {
0x6f, 0xea, 0x74, 0x09 // mvn al r9 r4 ROR 1
};
const byte kInstruction_mvn_al_r5_r12_LSL_4[] = {
0x6f, 0xea, 0x0c, 0x15 // mvn al r5 r12 LSL 4
};
const byte kInstruction_mvn_al_r10_r7_ROR_25[] = {
0x6f, 0xea, 0x77, 0x6a // mvn al r10 r7 ROR 25
};
const byte kInstruction_mvn_al_r9_r3_LSL_6[] = {
0x6f, 0xea, 0x83, 0x19 // mvn al r9 r3 LSL 6
};
const byte kInstruction_mvn_al_r7_r4_ROR_26[] = {
0x6f, 0xea, 0xb4, 0x67 // mvn al r7 r4 ROR 26
};
const byte kInstruction_mvn_al_r13_r0_LSL_31[] = {
0x6f, 0xea, 0xc0, 0x7d // mvn al r13 r0 LSL 31
};
const byte kInstruction_mvn_al_r9_r2_LSL_22[] = {
0x6f, 0xea, 0x82, 0x59 // mvn al r9 r2 LSL 22
};
const byte kInstruction_mvn_al_r6_r8_ROR_21[] = {
0x6f, 0xea, 0x78, 0x56 // mvn al r6 r8 ROR 21
};
const byte kInstruction_mvn_al_r12_r7_LSL_11[] = {
0x6f, 0xea, 0xc7, 0x2c // mvn al r12 r7 LSL 11
};
const byte kInstruction_mvn_al_r10_r0_LSL_17[] = {
0x6f, 0xea, 0x40, 0x4a // mvn al r10 r0 LSL 17
};
const byte kInstruction_mvn_al_r2_r9_ROR_23[] = {
0x6f, 0xea, 0xf9, 0x52 // mvn al r2 r9 ROR 23
};
const byte kInstruction_mvn_al_r2_r4_LSL_6[] = {
0x6f, 0xea, 0x84, 0x12 // mvn al r2 r4 LSL 6
};
const byte kInstruction_mvn_al_r7_r8_LSL_24[] = {
0x6f, 0xea, 0x08, 0x67 // mvn al r7 r8 LSL 24
};
const byte kInstruction_mvn_al_r8_r5_LSL_25[] = {
0x6f, 0xea, 0x45, 0x68 // mvn al r8 r5 LSL 25
};
const byte kInstruction_mvn_al_r10_r11_ROR_23[] = {
0x6f, 0xea, 0xfb, 0x5a // mvn al r10 r11 ROR 23
};
const byte kInstruction_mvn_al_r0_r14_LSL_16[] = {
0x6f, 0xea, 0x0e, 0x40 // mvn al r0 r14 LSL 16
};
const byte kInstruction_mvn_al_r2_r3_LSL_16[] = {
0x6f, 0xea, 0x03, 0x42 // mvn al r2 r3 LSL 16
};
const byte kInstruction_mvn_al_r0_r11_ROR_13[] = {
0x6f, 0xea, 0x7b, 0x30 // mvn al r0 r11 ROR 13
};
const byte kInstruction_mvn_al_r6_r4_ROR_15[] = {
0x6f, 0xea, 0xf4, 0x36 // mvn al r6 r4 ROR 15
};
const byte kInstruction_mvn_al_r8_r9_LSL_19[] = {
0x6f, 0xea, 0xc9, 0x48 // mvn al r8 r9 LSL 19
};
const byte kInstruction_mvn_al_r1_r13_LSL_23[] = {
0x6f, 0xea, 0xcd, 0x51 // mvn al r1 r13 LSL 23
};
const byte kInstruction_mvn_al_r4_r11_LSL_6[] = {
0x6f, 0xea, 0x8b, 0x14 // mvn al r4 r11 LSL 6
};
const byte kInstruction_mvn_al_r9_r0_ROR_15[] = {
0x6f, 0xea, 0xf0, 0x39 // mvn al r9 r0 ROR 15
};
const byte kInstruction_mvn_al_r7_r0_ROR_7[] = {
0x6f, 0xea, 0xf0, 0x17 // mvn al r7 r0 ROR 7
};
const byte kInstruction_mvn_al_r5_r7_LSL_26[] = {
0x6f, 0xea, 0x87, 0x65 // mvn al r5 r7 LSL 26
};
const byte kInstruction_mvn_al_r9_r4_LSL_6[] = {
0x6f, 0xea, 0x84, 0x19 // mvn al r9 r4 LSL 6
};
const byte kInstruction_mvn_al_r4_r9_LSL_9[] = {
0x6f, 0xea, 0x49, 0x24 // mvn al r4 r9 LSL 9
};
const byte kInstruction_mvn_al_r3_r14_ROR_24[] = {
0x6f, 0xea, 0x3e, 0x63 // mvn al r3 r14 ROR 24
};
const byte kInstruction_mvn_al_r6_r6_ROR_4[] = {
0x6f, 0xea, 0x36, 0x16 // mvn al r6 r6 ROR 4
};
const byte kInstruction_mvn_al_r2_r1_ROR_19[] = {
0x6f, 0xea, 0xf1, 0x42 // mvn al r2 r1 ROR 19
};
const byte kInstruction_mvn_al_r13_r1_LSL_2[] = {
0x6f, 0xea, 0x81, 0x0d // mvn al r13 r1 LSL 2
};
const byte kInstruction_mvn_al_r5_r9_ROR_2[] = {
0x6f, 0xea, 0xb9, 0x05 // mvn al r5 r9 ROR 2
};
const byte kInstruction_mvn_al_r13_r14_ROR_25[] = {
0x6f, 0xea, 0x7e, 0x6d // mvn al r13 r14 ROR 25
};
const byte kInstruction_mvn_al_r2_r11_ROR_18[] = {
0x6f, 0xea, 0xbb, 0x42 // mvn al r2 r11 ROR 18
};
const byte kInstruction_mvn_al_r10_r12_ROR_5[] = {
0x6f, 0xea, 0x7c, 0x1a // mvn al r10 r12 ROR 5
};
const byte kInstruction_mvn_al_r2_r4_ROR_2[] = {
0x6f, 0xea, 0xb4, 0x02 // mvn al r2 r4 ROR 2
};
const byte kInstruction_mvn_al_r12_r14_LSL_15[] = {
0x6f, 0xea, 0xce, 0x3c // mvn al r12 r14 LSL 15
};
const byte kInstruction_mvn_al_r13_r2_LSL_27[] = {
0x6f, 0xea, 0xc2, 0x6d // mvn al r13 r2 LSL 27
};
const byte kInstruction_mvn_al_r8_r13_ROR_27[] = {
0x6f, 0xea, 0xfd, 0x68 // mvn al r8 r13 ROR 27
};
const byte kInstruction_mvn_al_r12_r11_LSL_22[] = {
0x6f, 0xea, 0x8b, 0x5c // mvn al r12 r11 LSL 22
};
const byte kInstruction_mvn_al_r13_r5_ROR_12[] = {
0x6f, 0xea, 0x35, 0x3d // mvn al r13 r5 ROR 12
};
const byte kInstruction_mvn_al_r13_r7_ROR_17[] = {
0x6f, 0xea, 0x77, 0x4d // mvn al r13 r7 ROR 17
};
const byte kInstruction_mvn_al_r4_r10_LSL_26[] = {
0x6f, 0xea, 0x8a, 0x64 // mvn al r4 r10 LSL 26
};
const byte kInstruction_mvn_al_r6_r9_LSL_24[] = {
0x6f, 0xea, 0x09, 0x66 // mvn al r6 r9 LSL 24
};
const byte kInstruction_mvn_al_r14_r5_LSL_13[] = {
0x6f, 0xea, 0x45, 0x3e // mvn al r14 r5 LSL 13
};
const byte kInstruction_mvn_al_r12_r0_ROR_8[] = {
0x6f, 0xea, 0x30, 0x2c // mvn al r12 r0 ROR 8
};
const byte kInstruction_mvn_al_r1_r2_LSL_30[] = {
0x6f, 0xea, 0x82, 0x71 // mvn al r1 r2 LSL 30
};
const byte kInstruction_mvn_al_r10_r7_LSL_15[] = {
0x6f, 0xea, 0xc7, 0x3a // mvn al r10 r7 LSL 15
};
const byte kInstruction_mvn_al_r0_r7_LSL_31[] = {
0x6f, 0xea, 0xc7, 0x70 // mvn al r0 r7 LSL 31
};
const byte kInstruction_mvn_al_r14_r11_LSL_9[] = {
0x6f, 0xea, 0x4b, 0x2e // mvn al r14 r11 LSL 9
};
const byte kInstruction_mvn_al_r1_r6_ROR_2[] = {
0x6f, 0xea, 0xb6, 0x01 // mvn al r1 r6 ROR 2
};
const byte kInstruction_mvn_al_r5_r2_ROR_26[] = {
0x6f, 0xea, 0xb2, 0x65 // mvn al r5 r2 ROR 26
};
const byte kInstruction_mvn_al_r3_r5_LSL_2[] = {
0x6f, 0xea, 0x85, 0x03 // mvn al r3 r5 LSL 2
};
const byte kInstruction_mvn_al_r8_r3_LSL_3[] = {
0x6f, 0xea, 0xc3, 0x08 // mvn al r8 r3 LSL 3
};
const byte kInstruction_mvn_al_r6_r11_ROR_6[] = {
0x6f, 0xea, 0xbb, 0x16 // mvn al r6 r11 ROR 6
};
const byte kInstruction_mvn_al_r4_r4_ROR_13[] = {
0x6f, 0xea, 0x74, 0x34 // mvn al r4 r4 ROR 13
};
const byte kInstruction_mvn_al_r4_r2_LSL_20[] = {
0x6f, 0xea, 0x02, 0x54 // mvn al r4 r2 LSL 20
};
const byte kInstruction_mvn_al_r13_r8_ROR_25[] = {
0x6f, 0xea, 0x78, 0x6d // mvn al r13 r8 ROR 25
};
const byte kInstruction_mvn_al_r3_r13_LSL_18[] = {
0x6f, 0xea, 0x8d, 0x43 // mvn al r3 r13 LSL 18
};
const byte kInstruction_mvn_al_r1_r0_ROR_23[] = {
0x6f, 0xea, 0xf0, 0x51 // mvn al r1 r0 ROR 23
};
const byte kInstruction_mvn_al_r14_r14_LSL_25[] = {
0x6f, 0xea, 0x4e, 0x6e // mvn al r14 r14 LSL 25
};
const byte kInstruction_mvn_al_r0_r8_LSL_11[] = {
0x6f, 0xea, 0xc8, 0x20 // mvn al r0 r8 LSL 11
};
const byte kInstruction_mvn_al_r10_r1_LSL_13[] = {
0x6f, 0xea, 0x41, 0x3a // mvn al r10 r1 LSL 13
};
const byte kInstruction_mvn_al_r13_r10_LSL_9[] = {
0x6f, 0xea, 0x4a, 0x2d // mvn al r13 r10 LSL 9
};
const byte kInstruction_mvn_al_r6_r13_LSL_16[] = {
0x6f, 0xea, 0x0d, 0x46 // mvn al r6 r13 LSL 16
};
const byte kInstruction_mvn_al_r13_r14_LSL_5[] = {
0x6f, 0xea, 0x4e, 0x1d // mvn al r13 r14 LSL 5
};
const byte kInstruction_mvn_al_r2_r6_LSL_14[] = {
0x6f, 0xea, 0x86, 0x32 // mvn al r2 r6 LSL 14
};
const byte kInstruction_mvn_al_r13_r7_LSL_13[] = {
0x6f, 0xea, 0x47, 0x3d // mvn al r13 r7 LSL 13
};
const byte kInstruction_mvn_al_r7_r5_ROR_26[] = {
0x6f, 0xea, 0xb5, 0x67 // mvn al r7 r5 ROR 26
};
const byte kInstruction_mvn_al_r12_r11_LSL_12[] = {
0x6f, 0xea, 0x0b, 0x3c // mvn al r12 r11 LSL 12
};
const byte kInstruction_mvn_al_r5_r13_ROR_8[] = {
0x6f, 0xea, 0x3d, 0x25 // mvn al r5 r13 ROR 8
};
const byte kInstruction_mvn_al_r2_r8_ROR_2[] = {
0x6f, 0xea, 0xb8, 0x02 // mvn al r2 r8 ROR 2
};
const byte kInstruction_mvn_al_r0_r9_ROR_24[] = {
0x6f, 0xea, 0x39, 0x60 // mvn al r0 r9 ROR 24
};
const byte kInstruction_mvn_al_r8_r6_LSL_29[] = {
0x6f, 0xea, 0x46, 0x78 // mvn al r8 r6 LSL 29
};
const byte kInstruction_mvn_al_r9_r10_LSL_18[] = {
0x6f, 0xea, 0x8a, 0x49 // mvn al r9 r10 LSL 18
};
const byte kInstruction_mvn_al_r6_r0_LSL_24[] = {
0x6f, 0xea, 0x00, 0x66 // mvn al r6 r0 LSL 24
};
const byte kInstruction_mvn_al_r9_r12_LSL_20[] = {
0x6f, 0xea, 0x0c, 0x59 // mvn al r9 r12 LSL 20
};
const byte kInstruction_mvn_al_r14_r11_LSL_3[] = {
0x6f, 0xea, 0xcb, 0x0e // mvn al r14 r11 LSL 3
};
const byte kInstruction_mvn_al_r12_r11_LSL_26[] = {
0x6f, 0xea, 0x8b, 0x6c // mvn al r12 r11 LSL 26
};
const byte kInstruction_mvn_al_r10_r0_LSL_4[] = {
0x6f, 0xea, 0x00, 0x1a // mvn al r10 r0 LSL 4
};
const byte kInstruction_mvn_al_r10_r12_ROR_7[] = {
0x6f, 0xea, 0xfc, 0x1a // mvn al r10 r12 ROR 7
};
const byte kInstruction_mvn_al_r12_r3_LSL_1[] = {
0x6f, 0xea, 0x43, 0x0c // mvn al r12 r3 LSL 1
};
const byte kInstruction_mvn_al_r12_r4_ROR_12[] = {
0x6f, 0xea, 0x34, 0x3c // mvn al r12 r4 ROR 12
};
const byte kInstruction_mvn_al_r8_r0_ROR_12[] = {
0x6f, 0xea, 0x30, 0x38 // mvn al r8 r0 ROR 12
};
const byte kInstruction_mvn_al_r3_r3_ROR_6[] = {
0x6f, 0xea, 0xb3, 0x13 // mvn al r3 r3 ROR 6
};
const byte kInstruction_mvn_al_r11_r0_LSL_19[] = {
0x6f, 0xea, 0xc0, 0x4b // mvn al r11 r0 LSL 19
};
const byte kInstruction_mvn_al_r8_r14_LSL_24[] = {
0x6f, 0xea, 0x0e, 0x68 // mvn al r8 r14 LSL 24
};
const byte kInstruction_mvn_al_r0_r11_LSL_1[] = {
0x6f, 0xea, 0x4b, 0x00 // mvn al r0 r11 LSL 1
};
const byte kInstruction_mvn_al_r13_r5_LSL_6[] = {
0x6f, 0xea, 0x85, 0x1d // mvn al r13 r5 LSL 6
};
const byte kInstruction_mvn_al_r14_r14_ROR_31[] = {
0x6f, 0xea, 0xfe, 0x7e // mvn al r14 r14 ROR 31
};
const byte kInstruction_mvn_al_r10_r14_ROR_6[] = {
0x6f, 0xea, 0xbe, 0x1a // mvn al r10 r14 ROR 6
};
const byte kInstruction_mvn_al_r14_r4_LSL_1[] = {
0x6f, 0xea, 0x44, 0x0e // mvn al r14 r4 LSL 1
};
const byte kInstruction_mvn_al_r0_r3_ROR_7[] = {
0x6f, 0xea, 0xf3, 0x10 // mvn al r0 r3 ROR 7
};
const byte kInstruction_mvn_al_r2_r10_LSL_17[] = {
0x6f, 0xea, 0x4a, 0x42 // mvn al r2 r10 LSL 17
};
const byte kInstruction_mvn_al_r11_r6_ROR_19[] = {
0x6f, 0xea, 0xf6, 0x4b // mvn al r11 r6 ROR 19
};
const byte kInstruction_mvn_al_r9_r13_ROR_11[] = {
0x6f, 0xea, 0xfd, 0x29 // mvn al r9 r13 ROR 11
};
const byte kInstruction_mvn_al_r11_r3_LSL_2[] = {
0x6f, 0xea, 0x83, 0x0b // mvn al r11 r3 LSL 2
};
const byte kInstruction_mvn_al_r9_r1_ROR_4[] = {
0x6f, 0xea, 0x31, 0x19 // mvn al r9 r1 ROR 4
};
const byte kInstruction_mvn_al_r8_r11_LSL_16[] = {
0x6f, 0xea, 0x0b, 0x48 // mvn al r8 r11 LSL 16
};
const byte kInstruction_mvn_al_r1_r12_LSL_11[] = {
0x6f, 0xea, 0xcc, 0x21 // mvn al r1 r12 LSL 11
};
const byte kInstruction_mvn_al_r0_r8_ROR_6[] = {
0x6f, 0xea, 0xb8, 0x10 // mvn al r0 r8 ROR 6
};
const byte kInstruction_mvn_al_r5_r3_LSL_2[] = {
0x6f, 0xea, 0x83, 0x05 // mvn al r5 r3 LSL 2
};
const byte kInstruction_mvn_al_r6_r3_LSL_17[] = {
0x6f, 0xea, 0x43, 0x46 // mvn al r6 r3 LSL 17
};
const byte kInstruction_mvn_al_r3_r12_ROR_27[] = {
0x6f, 0xea, 0xfc, 0x63 // mvn al r3 r12 ROR 27
};
const byte kInstruction_mvn_al_r6_r8_ROR_15[] = {
0x6f, 0xea, 0xf8, 0x36 // mvn al r6 r8 ROR 15
};
const byte kInstruction_mvn_al_r7_r11_LSL_10[] = {
0x6f, 0xea, 0x8b, 0x27 // mvn al r7 r11 LSL 10
};
const byte kInstruction_mvn_al_r2_r12_LSL_15[] = {
0x6f, 0xea, 0xcc, 0x32 // mvn al r2 r12 LSL 15
};
const byte kInstruction_mvn_al_r2_r2_ROR_8[] = {
0x6f, 0xea, 0x32, 0x22 // mvn al r2 r2 ROR 8
};
const byte kInstruction_mvn_al_r12_r0_ROR_26[] = {
0x6f, 0xea, 0xb0, 0x6c // mvn al r12 r0 ROR 26
};
const byte kInstruction_mvn_al_r11_r13_ROR_19[] = {
0x6f, 0xea, 0xfd, 0x4b // mvn al r11 r13 ROR 19
};
const byte kInstruction_mvn_al_r0_r9_ROR_2[] = {
0x6f, 0xea, 0xb9, 0x00 // mvn al r0 r9 ROR 2
};
const byte kInstruction_mvn_al_r9_r7_ROR_25[] = {
0x6f, 0xea, 0x77, 0x69 // mvn al r9 r7 ROR 25
};
const byte kInstruction_mvn_al_r9_r8_LSL_28[] = {
0x6f, 0xea, 0x08, 0x79 // mvn al r9 r8 LSL 28
};
const byte kInstruction_mvn_al_r11_r12_ROR_17[] = {
0x6f, 0xea, 0x7c, 0x4b // mvn al r11 r12 ROR 17
};
const byte kInstruction_mvn_al_r12_r2_ROR_20[] = {
0x6f, 0xea, 0x32, 0x5c // mvn al r12 r2 ROR 20
};
const byte kInstruction_mvn_al_r11_r9_ROR_16[] = {
0x6f, 0xea, 0x39, 0x4b // mvn al r11 r9 ROR 16
};
const byte kInstruction_mvn_al_r13_r11_LSL_14[] = {
0x6f, 0xea, 0x8b, 0x3d // mvn al r13 r11 LSL 14
};
const byte kInstruction_mvn_al_r2_r4_ROR_12[] = {
0x6f, 0xea, 0x34, 0x32 // mvn al r2 r4 ROR 12
};
const byte kInstruction_mvn_al_r3_r12_ROR_17[] = {
0x6f, 0xea, 0x7c, 0x43 // mvn al r3 r12 ROR 17
};
const byte kInstruction_mvn_al_r14_r11_ROR_27[] = {
0x6f, 0xea, 0xfb, 0x6e // mvn al r14 r11 ROR 27
};
const TestResult kReferencemvn[] = {
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r8_ROR_21),
kInstruction_mvn_al_r14_r8_ROR_21,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r13_ROR_4),
kInstruction_mvn_al_r5_r13_ROR_4,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r3_ROR_4),
kInstruction_mvn_al_r0_r3_ROR_4,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r14_ROR_7),
kInstruction_mvn_al_r3_r14_ROR_7,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r6_LSL_30),
kInstruction_mvn_al_r2_r6_LSL_30,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r4_LSL_26),
kInstruction_mvn_al_r11_r4_LSL_26,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r0_LSL_30),
kInstruction_mvn_al_r7_r0_LSL_30,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r9_ROR_17),
kInstruction_mvn_al_r0_r9_ROR_17,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r3_ROR_31),
kInstruction_mvn_al_r11_r3_ROR_31,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r8_ROR_20),
kInstruction_mvn_al_r8_r8_ROR_20,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r13_LSL_24),
kInstruction_mvn_al_r11_r13_LSL_24,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r3_ROR_27),
kInstruction_mvn_al_r1_r3_ROR_27,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r10_ROR_5),
kInstruction_mvn_al_r9_r10_ROR_5,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r11_ROR_25),
kInstruction_mvn_al_r3_r11_ROR_25,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r6_LSL_7),
kInstruction_mvn_al_r2_r6_LSL_7,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r12_ROR_8),
kInstruction_mvn_al_r3_r12_ROR_8,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r0_LSL_14),
kInstruction_mvn_al_r0_r0_LSL_14,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r10_ROR_2),
kInstruction_mvn_al_r8_r10_ROR_2,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r8_LSL_31),
kInstruction_mvn_al_r0_r8_LSL_31,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r14_ROR_27),
kInstruction_mvn_al_r1_r14_ROR_27,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r2_ROR_27),
kInstruction_mvn_al_r14_r2_ROR_27,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r10_LSL_25),
kInstruction_mvn_al_r3_r10_LSL_25,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r8_ROR_6),
kInstruction_mvn_al_r13_r8_ROR_6,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r12_ROR_7),
kInstruction_mvn_al_r5_r12_ROR_7,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r8_LSL_10),
kInstruction_mvn_al_r7_r8_LSL_10,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r12_ROR_10),
kInstruction_mvn_al_r9_r12_ROR_10,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r6_ROR_12),
kInstruction_mvn_al_r8_r6_ROR_12,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r10_LSL_7),
kInstruction_mvn_al_r8_r10_LSL_7,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r12_ROR_8),
kInstruction_mvn_al_r5_r12_ROR_8,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r13_LSL_21),
kInstruction_mvn_al_r0_r13_LSL_21,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r0_LSL_7),
kInstruction_mvn_al_r2_r0_LSL_7,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r2_LSL_22),
kInstruction_mvn_al_r10_r2_LSL_22,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r11_ROR_2),
kInstruction_mvn_al_r4_r11_ROR_2,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r14_LSL_14),
kInstruction_mvn_al_r11_r14_LSL_14,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r0_LSL_23),
kInstruction_mvn_al_r8_r0_LSL_23,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r4_LSL_12),
kInstruction_mvn_al_r10_r4_LSL_12,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r5_ROR_28),
kInstruction_mvn_al_r4_r5_ROR_28,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r5_LSL_25),
kInstruction_mvn_al_r1_r5_LSL_25,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r10_ROR_16),
kInstruction_mvn_al_r7_r10_ROR_16,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r0_LSL_31),
kInstruction_mvn_al_r3_r0_LSL_31,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r2_LSL_2),
kInstruction_mvn_al_r2_r2_LSL_2,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r1_LSL_9),
kInstruction_mvn_al_r8_r1_LSL_9,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r6_LSL_6),
kInstruction_mvn_al_r13_r6_LSL_6,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r8_LSL_13),
kInstruction_mvn_al_r0_r8_LSL_13,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r8_ROR_3),
kInstruction_mvn_al_r11_r8_ROR_3,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r1_LSL_13),
kInstruction_mvn_al_r8_r1_LSL_13,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r2_LSL_13),
kInstruction_mvn_al_r6_r2_LSL_13,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r1_LSL_16),
kInstruction_mvn_al_r4_r1_LSL_16,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r4_LSL_9),
kInstruction_mvn_al_r0_r4_LSL_9,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r8_ROR_8),
kInstruction_mvn_al_r11_r8_ROR_8,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r12_LSL_5),
kInstruction_mvn_al_r9_r12_LSL_5,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r9_ROR_13),
kInstruction_mvn_al_r13_r9_ROR_13,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r0_ROR_23),
kInstruction_mvn_al_r2_r0_ROR_23,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r8_ROR_6),
kInstruction_mvn_al_r7_r8_ROR_6,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r6_LSL_11),
kInstruction_mvn_al_r2_r6_LSL_11,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r13_LSL_12),
kInstruction_mvn_al_r2_r13_LSL_12,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r4_LSL_13),
kInstruction_mvn_al_r7_r4_LSL_13,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r4_LSL_1),
kInstruction_mvn_al_r8_r4_LSL_1,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r4_LSL_8),
kInstruction_mvn_al_r14_r4_LSL_8,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r9_ROR_20),
kInstruction_mvn_al_r7_r9_ROR_20,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r3_ROR_6),
kInstruction_mvn_al_r4_r3_ROR_6,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r12_LSL_2),
kInstruction_mvn_al_r3_r12_LSL_2,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r9_ROR_7),
kInstruction_mvn_al_r12_r9_ROR_7,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r2_LSL_17),
kInstruction_mvn_al_r0_r2_LSL_17,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r3_LSL_28),
kInstruction_mvn_al_r14_r3_LSL_28,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r12_ROR_15),
kInstruction_mvn_al_r14_r12_ROR_15,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r0_ROR_8),
kInstruction_mvn_al_r8_r0_ROR_8,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r11_LSL_20),
kInstruction_mvn_al_r2_r11_LSL_20,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r13_LSL_30),
kInstruction_mvn_al_r8_r13_LSL_30,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r9_LSL_24),
kInstruction_mvn_al_r2_r9_LSL_24,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r1_LSL_2),
kInstruction_mvn_al_r12_r1_LSL_2,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r1_ROR_7),
kInstruction_mvn_al_r7_r1_ROR_7,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r7_ROR_30),
kInstruction_mvn_al_r11_r7_ROR_30,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r9_ROR_22),
kInstruction_mvn_al_r0_r9_ROR_22,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r9_ROR_17),
kInstruction_mvn_al_r14_r9_ROR_17,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r14_LSL_3),
kInstruction_mvn_al_r3_r14_LSL_3,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r0_ROR_30),
kInstruction_mvn_al_r0_r0_ROR_30,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r8_LSL_4),
kInstruction_mvn_al_r9_r8_LSL_4,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r13_LSL_16),
kInstruction_mvn_al_r8_r13_LSL_16,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r8_ROR_28),
kInstruction_mvn_al_r0_r8_ROR_28,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r10_LSL_23),
kInstruction_mvn_al_r11_r10_LSL_23,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r4_LSL_27),
kInstruction_mvn_al_r11_r4_LSL_27,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r2_LSL_30),
kInstruction_mvn_al_r2_r2_LSL_30,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r4_LSL_17),
kInstruction_mvn_al_r5_r4_LSL_17,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r12_LSL_1),
kInstruction_mvn_al_r11_r12_LSL_1,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r14_ROR_21),
kInstruction_mvn_al_r0_r14_ROR_21,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r5_ROR_21),
kInstruction_mvn_al_r11_r5_ROR_21,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r14_LSL_14),
kInstruction_mvn_al_r6_r14_LSL_14,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r9_LSL_24),
kInstruction_mvn_al_r1_r9_LSL_24,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r2_LSL_22),
kInstruction_mvn_al_r5_r2_LSL_22,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r5_LSL_4),
kInstruction_mvn_al_r3_r5_LSL_4,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r0_LSL_5),
kInstruction_mvn_al_r8_r0_LSL_5,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r14_ROR_13),
kInstruction_mvn_al_r5_r14_ROR_13,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r11_LSL_27),
kInstruction_mvn_al_r12_r11_LSL_27,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r14_LSL_20),
kInstruction_mvn_al_r10_r14_LSL_20,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r9_ROR_4),
kInstruction_mvn_al_r5_r9_ROR_4,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r11_ROR_11),
kInstruction_mvn_al_r8_r11_ROR_11,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r1_LSL_24),
kInstruction_mvn_al_r4_r1_LSL_24,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r10_ROR_4),
kInstruction_mvn_al_r7_r10_ROR_4,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r0_ROR_11),
kInstruction_mvn_al_r3_r0_ROR_11,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r10_ROR_23),
kInstruction_mvn_al_r3_r10_ROR_23,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r8_LSL_15),
kInstruction_mvn_al_r2_r8_LSL_15,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r6_LSL_18),
kInstruction_mvn_al_r3_r6_LSL_18,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r2_ROR_7),
kInstruction_mvn_al_r10_r2_ROR_7,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r6_ROR_14),
kInstruction_mvn_al_r6_r6_ROR_14,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r8_LSL_25),
kInstruction_mvn_al_r1_r8_LSL_25,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r14_LSL_13),
kInstruction_mvn_al_r0_r14_LSL_13,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r1_LSL_13),
kInstruction_mvn_al_r14_r1_LSL_13,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r11_ROR_8),
kInstruction_mvn_al_r8_r11_ROR_8,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r12_ROR_6),
kInstruction_mvn_al_r0_r12_ROR_6,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r12_LSL_26),
kInstruction_mvn_al_r0_r12_LSL_26,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r2_LSL_10),
kInstruction_mvn_al_r11_r2_LSL_10,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r7_LSL_3),
kInstruction_mvn_al_r12_r7_LSL_3,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r10_LSL_25),
kInstruction_mvn_al_r6_r10_LSL_25,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r7_ROR_8),
kInstruction_mvn_al_r12_r7_ROR_8,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r3_ROR_24),
kInstruction_mvn_al_r3_r3_ROR_24,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r12_LSL_24),
kInstruction_mvn_al_r9_r12_LSL_24,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r10_LSL_27),
kInstruction_mvn_al_r14_r10_LSL_27,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r5_ROR_4),
kInstruction_mvn_al_r6_r5_ROR_4,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r4_LSL_21),
kInstruction_mvn_al_r7_r4_LSL_21,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r4_ROR_31),
kInstruction_mvn_al_r2_r4_ROR_31,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r7_ROR_8),
kInstruction_mvn_al_r11_r7_ROR_8,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r2_ROR_17),
kInstruction_mvn_al_r5_r2_ROR_17,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r11_LSL_13),
kInstruction_mvn_al_r1_r11_LSL_13,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r11_ROR_2),
kInstruction_mvn_al_r7_r11_ROR_2,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r7_ROR_29),
kInstruction_mvn_al_r1_r7_ROR_29,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r1_LSL_31),
kInstruction_mvn_al_r4_r1_LSL_31,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r13_ROR_11),
kInstruction_mvn_al_r11_r13_ROR_11,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r1_ROR_14),
kInstruction_mvn_al_r13_r1_ROR_14,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r14_ROR_21),
kInstruction_mvn_al_r1_r14_ROR_21,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r12_LSL_5),
kInstruction_mvn_al_r7_r12_LSL_5,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r3_LSL_2),
kInstruction_mvn_al_r10_r3_LSL_2,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r10_ROR_25),
kInstruction_mvn_al_r12_r10_ROR_25,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r7_LSL_6),
kInstruction_mvn_al_r2_r7_LSL_6,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r0_LSL_23),
kInstruction_mvn_al_r5_r0_LSL_23,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r8_ROR_18),
kInstruction_mvn_al_r2_r8_ROR_18,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r1_ROR_15),
kInstruction_mvn_al_r0_r1_ROR_15,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r4_ROR_20),
kInstruction_mvn_al_r14_r4_ROR_20,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r10_LSL_15),
kInstruction_mvn_al_r5_r10_LSL_15,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r1_ROR_28),
kInstruction_mvn_al_r0_r1_ROR_28,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r2_LSL_9),
kInstruction_mvn_al_r11_r2_LSL_9,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r10_LSL_19),
kInstruction_mvn_al_r9_r10_LSL_19,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r11_LSL_8),
kInstruction_mvn_al_r4_r11_LSL_8,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r14_LSL_12),
kInstruction_mvn_al_r12_r14_LSL_12,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r9_LSL_8),
kInstruction_mvn_al_r5_r9_LSL_8,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r14_LSL_16),
kInstruction_mvn_al_r12_r14_LSL_16,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r13_LSL_23),
kInstruction_mvn_al_r13_r13_LSL_23,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r12_ROR_19),
kInstruction_mvn_al_r3_r12_ROR_19,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r5_ROR_24),
kInstruction_mvn_al_r2_r5_ROR_24,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r2_ROR_11),
kInstruction_mvn_al_r3_r2_ROR_11,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r13_ROR_1),
kInstruction_mvn_al_r1_r13_ROR_1,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r7_LSL_11),
kInstruction_mvn_al_r6_r7_LSL_11,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r14_LSL_2),
kInstruction_mvn_al_r3_r14_LSL_2,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r10_LSL_20),
kInstruction_mvn_al_r0_r10_LSL_20,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r0_LSL_19),
kInstruction_mvn_al_r3_r0_LSL_19,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r0_ROR_21),
kInstruction_mvn_al_r14_r0_ROR_21,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r13_LSL_16),
kInstruction_mvn_al_r12_r13_LSL_16,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r5_ROR_28),
kInstruction_mvn_al_r8_r5_ROR_28,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r1_LSL_25),
kInstruction_mvn_al_r8_r1_LSL_25,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r4_LSL_25),
kInstruction_mvn_al_r6_r4_LSL_25,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r12_ROR_26),
kInstruction_mvn_al_r7_r12_ROR_26,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r14_LSL_12),
kInstruction_mvn_al_r8_r14_LSL_12,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r6_ROR_2),
kInstruction_mvn_al_r6_r6_ROR_2,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r11_LSL_13),
kInstruction_mvn_al_r11_r11_LSL_13,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r12_ROR_25),
kInstruction_mvn_al_r1_r12_ROR_25,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r5_LSL_20),
kInstruction_mvn_al_r9_r5_LSL_20,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r11_LSL_20),
kInstruction_mvn_al_r12_r11_LSL_20,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r3_ROR_31),
kInstruction_mvn_al_r8_r3_ROR_31,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r14_ROR_3),
kInstruction_mvn_al_r0_r14_ROR_3,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r14_LSL_30),
kInstruction_mvn_al_r13_r14_LSL_30,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r6_ROR_24),
kInstruction_mvn_al_r3_r6_ROR_24,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r10_LSL_23),
kInstruction_mvn_al_r10_r10_LSL_23,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r1_LSL_7),
kInstruction_mvn_al_r9_r1_LSL_7,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r13_ROR_27),
kInstruction_mvn_al_r6_r13_ROR_27,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r14_LSL_21),
kInstruction_mvn_al_r1_r14_LSL_21,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r14_ROR_12),
kInstruction_mvn_al_r9_r14_ROR_12,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r2_LSL_17),
kInstruction_mvn_al_r14_r2_LSL_17,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r14_LSL_11),
kInstruction_mvn_al_r11_r14_LSL_11,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r7_ROR_2),
kInstruction_mvn_al_r11_r7_ROR_2,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r7_ROR_20),
kInstruction_mvn_al_r8_r7_ROR_20,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r11_LSL_5),
kInstruction_mvn_al_r10_r11_LSL_5,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r11_ROR_16),
kInstruction_mvn_al_r5_r11_ROR_16,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r3_LSL_23),
kInstruction_mvn_al_r8_r3_LSL_23,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r8_LSL_23),
kInstruction_mvn_al_r2_r8_LSL_23,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r13_LSL_28),
kInstruction_mvn_al_r2_r13_LSL_28,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r0_LSL_20),
kInstruction_mvn_al_r1_r0_LSL_20,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r8_ROR_21),
kInstruction_mvn_al_r9_r8_ROR_21,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r14_LSL_22),
kInstruction_mvn_al_r5_r14_LSL_22,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r9_ROR_7),
kInstruction_mvn_al_r4_r9_ROR_7,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r12_ROR_9),
kInstruction_mvn_al_r2_r12_ROR_9,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r10_LSL_31),
kInstruction_mvn_al_r4_r10_LSL_31,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r2_LSL_8),
kInstruction_mvn_al_r4_r2_LSL_8,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r6_LSL_27),
kInstruction_mvn_al_r10_r6_LSL_27,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r7_ROR_7),
kInstruction_mvn_al_r12_r7_ROR_7,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r1_ROR_9),
kInstruction_mvn_al_r5_r1_ROR_9,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r13_LSL_29),
kInstruction_mvn_al_r13_r13_LSL_29,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r12_ROR_28),
kInstruction_mvn_al_r0_r12_ROR_28,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r6_ROR_26),
kInstruction_mvn_al_r9_r6_ROR_26,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r8_ROR_14),
kInstruction_mvn_al_r1_r8_ROR_14,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r5_LSL_19),
kInstruction_mvn_al_r9_r5_LSL_19,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r5_LSL_23),
kInstruction_mvn_al_r10_r5_LSL_23,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r12_ROR_2),
kInstruction_mvn_al_r2_r12_ROR_2,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r10_ROR_18),
kInstruction_mvn_al_r5_r10_ROR_18,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r12_ROR_12),
kInstruction_mvn_al_r13_r12_ROR_12,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r10_LSL_15),
kInstruction_mvn_al_r9_r10_LSL_15,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r2_LSL_26),
kInstruction_mvn_al_r9_r2_LSL_26,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r3_LSL_19),
kInstruction_mvn_al_r2_r3_LSL_19,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r10_ROR_28),
kInstruction_mvn_al_r7_r10_ROR_28,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r6_ROR_6),
kInstruction_mvn_al_r14_r6_ROR_6,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r1_ROR_16),
kInstruction_mvn_al_r5_r1_ROR_16,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r6_ROR_10),
kInstruction_mvn_al_r4_r6_ROR_10,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r12_LSL_10),
kInstruction_mvn_al_r7_r12_LSL_10,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r14_LSL_28),
kInstruction_mvn_al_r0_r14_LSL_28,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r2_LSL_27),
kInstruction_mvn_al_r8_r2_LSL_27,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r12_ROR_1),
kInstruction_mvn_al_r8_r12_ROR_1,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r4_ROR_4),
kInstruction_mvn_al_r8_r4_ROR_4,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r5_ROR_20),
kInstruction_mvn_al_r3_r5_ROR_20,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r13_LSL_5),
kInstruction_mvn_al_r6_r13_LSL_5,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r9_LSL_4),
kInstruction_mvn_al_r9_r9_LSL_4,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r13_ROR_7),
kInstruction_mvn_al_r13_r13_ROR_7,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r7_LSL_11),
kInstruction_mvn_al_r3_r7_LSL_11,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r3_ROR_15),
kInstruction_mvn_al_r1_r3_ROR_15,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r0_LSL_30),
kInstruction_mvn_al_r2_r0_LSL_30,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r13_ROR_16),
kInstruction_mvn_al_r11_r13_ROR_16,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r0_LSL_15),
kInstruction_mvn_al_r3_r0_LSL_15,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r0_LSL_8),
kInstruction_mvn_al_r2_r0_LSL_8,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r13_ROR_5),
kInstruction_mvn_al_r4_r13_ROR_5,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r0_ROR_29),
kInstruction_mvn_al_r13_r0_ROR_29,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r2_ROR_18),
kInstruction_mvn_al_r6_r2_ROR_18,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r2_LSL_2),
kInstruction_mvn_al_r1_r2_LSL_2,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r4_ROR_12),
kInstruction_mvn_al_r7_r4_ROR_12,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r11_ROR_6),
kInstruction_mvn_al_r9_r11_ROR_6,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r2_ROR_12),
kInstruction_mvn_al_r8_r2_ROR_12,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r2_LSL_19),
kInstruction_mvn_al_r12_r2_LSL_19,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r0_ROR_30),
kInstruction_mvn_al_r13_r0_ROR_30,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r6_ROR_16),
kInstruction_mvn_al_r7_r6_ROR_16,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r13_ROR_19),
kInstruction_mvn_al_r6_r13_ROR_19,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r3_LSL_19),
kInstruction_mvn_al_r14_r3_LSL_19,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r5_ROR_24),
kInstruction_mvn_al_r14_r5_ROR_24,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r12_LSL_8),
kInstruction_mvn_al_r10_r12_LSL_8,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r7_LSL_11),
kInstruction_mvn_al_r14_r7_LSL_11,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r14_LSL_30),
kInstruction_mvn_al_r10_r14_LSL_30,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r13_ROR_7),
kInstruction_mvn_al_r7_r13_ROR_7,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r0_LSL_23),
kInstruction_mvn_al_r11_r0_LSL_23,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r12_LSL_30),
kInstruction_mvn_al_r0_r12_LSL_30,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r12_LSL_7),
kInstruction_mvn_al_r5_r12_LSL_7,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r12_ROR_14),
kInstruction_mvn_al_r12_r12_ROR_14,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r11_LSL_4),
kInstruction_mvn_al_r8_r11_LSL_4,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r2_ROR_24),
kInstruction_mvn_al_r14_r2_ROR_24,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r2_ROR_31),
kInstruction_mvn_al_r10_r2_ROR_31,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r5_LSL_1),
kInstruction_mvn_al_r11_r5_LSL_1,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r6_LSL_24),
kInstruction_mvn_al_r8_r6_LSL_24,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r1_ROR_8),
kInstruction_mvn_al_r14_r1_ROR_8,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r2_ROR_19),
kInstruction_mvn_al_r11_r2_ROR_19,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r12_LSL_14),
kInstruction_mvn_al_r1_r12_LSL_14,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r10_LSL_30),
kInstruction_mvn_al_r6_r10_LSL_30,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r1_ROR_6),
kInstruction_mvn_al_r8_r1_ROR_6,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r11_ROR_6),
kInstruction_mvn_al_r13_r11_ROR_6,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r13_LSL_30),
kInstruction_mvn_al_r5_r13_LSL_30,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r13_ROR_26),
kInstruction_mvn_al_r0_r13_ROR_26,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r10_LSL_30),
kInstruction_mvn_al_r4_r10_LSL_30,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r4_LSL_16),
kInstruction_mvn_al_r8_r4_LSL_16,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r12_LSL_11),
kInstruction_mvn_al_r11_r12_LSL_11,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r3_ROR_2),
kInstruction_mvn_al_r9_r3_ROR_2,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r7_LSL_26),
kInstruction_mvn_al_r11_r7_LSL_26,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r2_ROR_22),
kInstruction_mvn_al_r14_r2_ROR_22,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r2_ROR_10),
kInstruction_mvn_al_r8_r2_ROR_10,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r2_ROR_28),
kInstruction_mvn_al_r5_r2_ROR_28,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r3_ROR_11),
kInstruction_mvn_al_r14_r3_ROR_11,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r14_LSL_5),
kInstruction_mvn_al_r3_r14_LSL_5,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r3_ROR_15),
kInstruction_mvn_al_r12_r3_ROR_15,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r1_ROR_30),
kInstruction_mvn_al_r4_r1_ROR_30,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r8_ROR_11),
kInstruction_mvn_al_r13_r8_ROR_11,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r9_ROR_9),
kInstruction_mvn_al_r6_r9_ROR_9,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r13_ROR_15),
kInstruction_mvn_al_r8_r13_ROR_15,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r14_ROR_12),
kInstruction_mvn_al_r0_r14_ROR_12,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r10_LSL_6),
kInstruction_mvn_al_r0_r10_LSL_6,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r7_LSL_5),
kInstruction_mvn_al_r8_r7_LSL_5,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r7_ROR_11),
kInstruction_mvn_al_r3_r7_ROR_11,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r1_LSL_20),
kInstruction_mvn_al_r5_r1_LSL_20,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r7_LSL_10),
kInstruction_mvn_al_r6_r7_LSL_10,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r0_ROR_27),
kInstruction_mvn_al_r14_r0_ROR_27,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r12_LSL_5),
kInstruction_mvn_al_r6_r12_LSL_5,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r8_LSL_28),
kInstruction_mvn_al_r4_r8_LSL_28,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r6_ROR_15),
kInstruction_mvn_al_r7_r6_ROR_15,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r6_LSL_27),
kInstruction_mvn_al_r0_r6_LSL_27,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r6_ROR_19),
kInstruction_mvn_al_r1_r6_ROR_19,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r14_ROR_21),
kInstruction_mvn_al_r11_r14_ROR_21,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r13_LSL_5),
kInstruction_mvn_al_r4_r13_LSL_5,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r7_ROR_2),
kInstruction_mvn_al_r4_r7_ROR_2,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r1_ROR_29),
kInstruction_mvn_al_r8_r1_ROR_29,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r2_LSL_24),
kInstruction_mvn_al_r14_r2_LSL_24,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r12_ROR_27),
kInstruction_mvn_al_r5_r12_ROR_27,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r4_ROR_14),
kInstruction_mvn_al_r11_r4_ROR_14,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r7_LSL_28),
kInstruction_mvn_al_r4_r7_LSL_28,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r6_LSL_9),
kInstruction_mvn_al_r3_r6_LSL_9,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r13_LSL_12),
kInstruction_mvn_al_r11_r13_LSL_12,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r7_ROR_20),
kInstruction_mvn_al_r10_r7_ROR_20,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r8_LSL_12),
kInstruction_mvn_al_r2_r8_LSL_12,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r13_LSL_28),
kInstruction_mvn_al_r4_r13_LSL_28,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r12_LSL_28),
kInstruction_mvn_al_r1_r12_LSL_28,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r14_LSL_6),
kInstruction_mvn_al_r7_r14_LSL_6,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r2_ROR_10),
kInstruction_mvn_al_r11_r2_ROR_10,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r9_ROR_7),
kInstruction_mvn_al_r3_r9_ROR_7,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r12_LSL_11),
kInstruction_mvn_al_r2_r12_LSL_11,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r2_ROR_19),
kInstruction_mvn_al_r4_r2_ROR_19,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r0_LSL_5),
kInstruction_mvn_al_r13_r0_LSL_5,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r11_ROR_29),
kInstruction_mvn_al_r14_r11_ROR_29,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r6_LSL_11),
kInstruction_mvn_al_r9_r6_LSL_11,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r10_ROR_30),
kInstruction_mvn_al_r2_r10_ROR_30,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r14_ROR_4),
kInstruction_mvn_al_r3_r14_ROR_4,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r6_LSL_24),
kInstruction_mvn_al_r9_r6_LSL_24,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r8_LSL_2),
kInstruction_mvn_al_r9_r8_LSL_2,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r5_ROR_7),
kInstruction_mvn_al_r12_r5_ROR_7,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r11_ROR_20),
kInstruction_mvn_al_r1_r11_ROR_20,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r12_LSL_6),
kInstruction_mvn_al_r6_r12_LSL_6,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r11_ROR_26),
kInstruction_mvn_al_r14_r11_ROR_26,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r8_ROR_6),
kInstruction_mvn_al_r5_r8_ROR_6,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r4_LSL_8),
kInstruction_mvn_al_r10_r4_LSL_8,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r0_ROR_24),
kInstruction_mvn_al_r5_r0_ROR_24,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r3_LSL_20),
kInstruction_mvn_al_r10_r3_LSL_20,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r4_LSL_22),
kInstruction_mvn_al_r14_r4_LSL_22,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r8_ROR_1),
kInstruction_mvn_al_r8_r8_ROR_1,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r9_ROR_8),
kInstruction_mvn_al_r12_r9_ROR_8,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r13_ROR_15),
kInstruction_mvn_al_r6_r13_ROR_15,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r5_LSL_2),
kInstruction_mvn_al_r9_r5_LSL_2,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r8_LSL_17),
kInstruction_mvn_al_r13_r8_LSL_17,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r5_ROR_27),
kInstruction_mvn_al_r2_r5_ROR_27,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r12_ROR_10),
kInstruction_mvn_al_r13_r12_ROR_10,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r2_LSL_30),
kInstruction_mvn_al_r13_r2_LSL_30,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r11_LSL_20),
kInstruction_mvn_al_r10_r11_LSL_20,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r1_ROR_22),
kInstruction_mvn_al_r6_r1_ROR_22,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r4_ROR_18),
kInstruction_mvn_al_r0_r4_ROR_18,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r14_ROR_19),
kInstruction_mvn_al_r11_r14_ROR_19,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r7_ROR_4),
kInstruction_mvn_al_r0_r7_ROR_4,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r5_LSL_13),
kInstruction_mvn_al_r1_r5_LSL_13,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r14_LSL_6),
kInstruction_mvn_al_r11_r14_LSL_6,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r11_LSL_10),
kInstruction_mvn_al_r6_r11_LSL_10,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r14_LSL_1),
kInstruction_mvn_al_r10_r14_LSL_1,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r4_ROR_29),
kInstruction_mvn_al_r13_r4_ROR_29,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r8_ROR_28),
kInstruction_mvn_al_r9_r8_ROR_28,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r12_ROR_22),
kInstruction_mvn_al_r7_r12_ROR_22,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r12_ROR_10),
kInstruction_mvn_al_r1_r12_ROR_10,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r8_ROR_31),
kInstruction_mvn_al_r7_r8_ROR_31,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r2_ROR_25),
kInstruction_mvn_al_r0_r2_ROR_25,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r5_LSL_24),
kInstruction_mvn_al_r3_r5_LSL_24,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r10_LSL_25),
kInstruction_mvn_al_r11_r10_LSL_25,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r1_LSL_9),
kInstruction_mvn_al_r11_r1_LSL_9,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r7_LSL_3),
kInstruction_mvn_al_r2_r7_LSL_3,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r10_ROR_20),
kInstruction_mvn_al_r0_r10_ROR_20,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r0_LSL_2),
kInstruction_mvn_al_r7_r0_LSL_2,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r5_LSL_8),
kInstruction_mvn_al_r12_r5_LSL_8,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r1_ROR_16),
kInstruction_mvn_al_r11_r1_ROR_16,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r3_LSL_30),
kInstruction_mvn_al_r3_r3_LSL_30,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r9_LSL_16),
kInstruction_mvn_al_r4_r9_LSL_16,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r8_LSL_27),
kInstruction_mvn_al_r9_r8_LSL_27,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r2_LSL_15),
kInstruction_mvn_al_r4_r2_LSL_15,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r13_LSL_3),
kInstruction_mvn_al_r12_r13_LSL_3,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r3_LSL_29),
kInstruction_mvn_al_r11_r3_LSL_29,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r6_ROR_23),
kInstruction_mvn_al_r4_r6_ROR_23,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r8_LSL_3),
kInstruction_mvn_al_r5_r8_LSL_3,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r9_ROR_4),
kInstruction_mvn_al_r1_r9_ROR_4,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r6_LSL_12),
kInstruction_mvn_al_r13_r6_LSL_12,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r6_ROR_17),
kInstruction_mvn_al_r12_r6_ROR_17,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r1_LSL_22),
kInstruction_mvn_al_r2_r1_LSL_22,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r2_LSL_10),
kInstruction_mvn_al_r9_r2_LSL_10,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r10_LSL_21),
kInstruction_mvn_al_r11_r10_LSL_21,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r12_LSL_31),
kInstruction_mvn_al_r8_r12_LSL_31,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r2_LSL_11),
kInstruction_mvn_al_r5_r2_LSL_11,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r6_LSL_31),
kInstruction_mvn_al_r9_r6_LSL_31,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r6_ROR_23),
kInstruction_mvn_al_r6_r6_ROR_23,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r3_LSL_5),
kInstruction_mvn_al_r14_r3_LSL_5,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r9_ROR_26),
kInstruction_mvn_al_r14_r9_ROR_26,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r1_ROR_15),
kInstruction_mvn_al_r13_r1_ROR_15,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r13_LSL_13),
kInstruction_mvn_al_r2_r13_LSL_13,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r7_LSL_8),
kInstruction_mvn_al_r14_r7_LSL_8,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r4_LSL_8),
kInstruction_mvn_al_r9_r4_LSL_8,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r13_LSL_26),
kInstruction_mvn_al_r0_r13_LSL_26,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r1_LSL_12),
kInstruction_mvn_al_r11_r1_LSL_12,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r6_LSL_5),
kInstruction_mvn_al_r7_r6_LSL_5,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r9_LSL_15),
kInstruction_mvn_al_r4_r9_LSL_15,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r14_ROR_19),
kInstruction_mvn_al_r2_r14_ROR_19,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r4_LSL_21),
kInstruction_mvn_al_r12_r4_LSL_21,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r9_ROR_23),
kInstruction_mvn_al_r0_r9_ROR_23,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r13_ROR_31),
kInstruction_mvn_al_r5_r13_ROR_31,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r1_ROR_19),
kInstruction_mvn_al_r8_r1_ROR_19,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r11_ROR_10),
kInstruction_mvn_al_r1_r11_ROR_10,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r7_ROR_22),
kInstruction_mvn_al_r10_r7_ROR_22,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r11_LSL_26),
kInstruction_mvn_al_r10_r11_LSL_26,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r14_ROR_15),
kInstruction_mvn_al_r0_r14_ROR_15,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r9_LSL_20),
kInstruction_mvn_al_r1_r9_LSL_20,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r0_LSL_11),
kInstruction_mvn_al_r7_r0_LSL_11,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r14_ROR_15),
kInstruction_mvn_al_r10_r14_ROR_15,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r11_LSL_2),
kInstruction_mvn_al_r1_r11_LSL_2,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r13_ROR_2),
kInstruction_mvn_al_r1_r13_ROR_2,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r1_ROR_13),
kInstruction_mvn_al_r12_r1_ROR_13,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r4_LSL_17),
kInstruction_mvn_al_r1_r4_LSL_17,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r4_ROR_16),
kInstruction_mvn_al_r11_r4_ROR_16,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r1_LSL_31),
kInstruction_mvn_al_r1_r1_LSL_31,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r0_ROR_15),
kInstruction_mvn_al_r11_r0_ROR_15,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r12_LSL_10),
kInstruction_mvn_al_r1_r12_LSL_10,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r12_LSL_11),
kInstruction_mvn_al_r0_r12_LSL_11,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r10_ROR_8),
kInstruction_mvn_al_r10_r10_ROR_8,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r5_ROR_29),
kInstruction_mvn_al_r2_r5_ROR_29,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r7_LSL_9),
kInstruction_mvn_al_r7_r7_LSL_9,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r1_LSL_11),
kInstruction_mvn_al_r9_r1_LSL_11,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r8_ROR_14),
kInstruction_mvn_al_r5_r8_ROR_14,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r6_ROR_25),
kInstruction_mvn_al_r1_r6_ROR_25,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r2_LSL_7),
kInstruction_mvn_al_r13_r2_LSL_7,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r3_ROR_24),
kInstruction_mvn_al_r0_r3_ROR_24,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r5_ROR_31),
kInstruction_mvn_al_r4_r5_ROR_31,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r13_ROR_28),
kInstruction_mvn_al_r0_r13_ROR_28,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r3_LSL_5),
kInstruction_mvn_al_r11_r3_LSL_5,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r1_LSL_1),
kInstruction_mvn_al_r3_r1_LSL_1,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r7_ROR_8),
kInstruction_mvn_al_r10_r7_ROR_8,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r13_LSL_17),
kInstruction_mvn_al_r0_r13_LSL_17,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r3_LSL_16),
kInstruction_mvn_al_r10_r3_LSL_16,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r14_LSL_21),
kInstruction_mvn_al_r14_r14_LSL_21,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r7_ROR_12),
kInstruction_mvn_al_r0_r7_ROR_12,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r11_LSL_1),
kInstruction_mvn_al_r4_r11_LSL_1,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r10_ROR_25),
kInstruction_mvn_al_r4_r10_ROR_25,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r7_LSL_10),
kInstruction_mvn_al_r11_r7_LSL_10,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r13_LSL_13),
kInstruction_mvn_al_r4_r13_LSL_13,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r4_ROR_9),
kInstruction_mvn_al_r11_r4_ROR_9,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r3_LSL_4),
kInstruction_mvn_al_r8_r3_LSL_4,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r3_LSL_22),
kInstruction_mvn_al_r0_r3_LSL_22,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r3_LSL_16),
kInstruction_mvn_al_r9_r3_LSL_16,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r11_LSL_24),
kInstruction_mvn_al_r1_r11_LSL_24,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r7_LSL_11),
kInstruction_mvn_al_r0_r7_LSL_11,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r8_LSL_29),
kInstruction_mvn_al_r13_r8_LSL_29,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r8_LSL_1),
kInstruction_mvn_al_r8_r8_LSL_1,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r1_LSL_21),
kInstruction_mvn_al_r8_r1_LSL_21,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r3_LSL_27),
kInstruction_mvn_al_r1_r3_LSL_27,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r8_ROR_2),
kInstruction_mvn_al_r1_r8_ROR_2,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r4_ROR_9),
kInstruction_mvn_al_r9_r4_ROR_9,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r3_ROR_28),
kInstruction_mvn_al_r10_r3_ROR_28,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r8_ROR_11),
kInstruction_mvn_al_r4_r8_ROR_11,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r3_LSL_17),
kInstruction_mvn_al_r2_r3_LSL_17,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r6_ROR_17),
kInstruction_mvn_al_r5_r6_ROR_17,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r9_LSL_6),
kInstruction_mvn_al_r8_r9_LSL_6,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r11_ROR_29),
kInstruction_mvn_al_r9_r11_ROR_29,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r12_ROR_20),
kInstruction_mvn_al_r11_r12_ROR_20,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r13_LSL_21),
kInstruction_mvn_al_r8_r13_LSL_21,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r9_LSL_22),
kInstruction_mvn_al_r8_r9_LSL_22,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r1_ROR_14),
kInstruction_mvn_al_r11_r1_ROR_14,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r3_LSL_15),
kInstruction_mvn_al_r13_r3_LSL_15,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r7_LSL_9),
kInstruction_mvn_al_r3_r7_LSL_9,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r4_ROR_10),
kInstruction_mvn_al_r5_r4_ROR_10,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r10_LSL_24),
kInstruction_mvn_al_r11_r10_LSL_24,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r9_ROR_25),
kInstruction_mvn_al_r1_r9_ROR_25,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r2_ROR_5),
kInstruction_mvn_al_r9_r2_ROR_5,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r4_ROR_19),
kInstruction_mvn_al_r5_r4_ROR_19,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r14_ROR_19),
kInstruction_mvn_al_r1_r14_ROR_19,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r9_LSL_30),
kInstruction_mvn_al_r10_r9_LSL_30,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r4_ROR_24),
kInstruction_mvn_al_r9_r4_ROR_24,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r6_LSL_23),
kInstruction_mvn_al_r6_r6_LSL_23,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r7_LSL_29),
kInstruction_mvn_al_r5_r7_LSL_29,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r5_LSL_10),
kInstruction_mvn_al_r10_r5_LSL_10,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r8_LSL_15),
kInstruction_mvn_al_r13_r8_LSL_15,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r2_ROR_14),
kInstruction_mvn_al_r5_r2_ROR_14,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r3_ROR_6),
kInstruction_mvn_al_r11_r3_ROR_6,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r7_ROR_9),
kInstruction_mvn_al_r12_r7_ROR_9,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r3_ROR_23),
kInstruction_mvn_al_r1_r3_ROR_23,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r13_LSL_30),
kInstruction_mvn_al_r10_r13_LSL_30,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r2_LSL_15),
kInstruction_mvn_al_r3_r2_LSL_15,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r0_LSL_31),
kInstruction_mvn_al_r6_r0_LSL_31,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r12_LSL_12),
kInstruction_mvn_al_r13_r12_LSL_12,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r8_ROR_9),
kInstruction_mvn_al_r7_r8_ROR_9,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r13_LSL_16),
kInstruction_mvn_al_r7_r13_LSL_16,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r6_LSL_17),
kInstruction_mvn_al_r3_r6_LSL_17,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r4_ROR_14),
kInstruction_mvn_al_r13_r4_ROR_14,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r5_ROR_7),
kInstruction_mvn_al_r2_r5_ROR_7,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r10_ROR_18),
kInstruction_mvn_al_r7_r10_ROR_18,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r12_LSL_26),
kInstruction_mvn_al_r7_r12_LSL_26,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r13_ROR_25),
kInstruction_mvn_al_r13_r13_ROR_25,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r2_ROR_5),
kInstruction_mvn_al_r11_r2_ROR_5,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r14_ROR_8),
kInstruction_mvn_al_r0_r14_ROR_8,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r2_ROR_27),
kInstruction_mvn_al_r6_r2_ROR_27,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r14_LSL_31),
kInstruction_mvn_al_r4_r14_LSL_31,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r0_LSL_7),
kInstruction_mvn_al_r1_r0_LSL_7,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r8_LSL_10),
kInstruction_mvn_al_r0_r8_LSL_10,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r0_LSL_13),
kInstruction_mvn_al_r9_r0_LSL_13,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r11_ROR_11),
kInstruction_mvn_al_r11_r11_ROR_11,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r4_ROR_7),
kInstruction_mvn_al_r11_r4_ROR_7,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r4_ROR_19),
kInstruction_mvn_al_r10_r4_ROR_19,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r13_ROR_4),
kInstruction_mvn_al_r1_r13_ROR_4,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r14_ROR_5),
kInstruction_mvn_al_r9_r14_ROR_5,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r11_LSL_22),
kInstruction_mvn_al_r14_r11_LSL_22,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r4_LSL_17),
kInstruction_mvn_al_r2_r4_LSL_17,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r6_LSL_15),
kInstruction_mvn_al_r2_r6_LSL_15,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r5_ROR_28),
kInstruction_mvn_al_r10_r5_ROR_28,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r4_ROR_13),
kInstruction_mvn_al_r6_r4_ROR_13,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r4_ROR_10),
kInstruction_mvn_al_r3_r4_ROR_10,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r7_ROR_15),
kInstruction_mvn_al_r3_r7_ROR_15,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r14_LSL_28),
kInstruction_mvn_al_r7_r14_LSL_28,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r6_ROR_23),
kInstruction_mvn_al_r10_r6_ROR_23,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r5_ROR_4),
kInstruction_mvn_al_r4_r5_ROR_4,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r3_ROR_8),
kInstruction_mvn_al_r9_r3_ROR_8,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r1_LSL_14),
kInstruction_mvn_al_r2_r1_LSL_14,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r7_LSL_4),
kInstruction_mvn_al_r10_r7_LSL_4,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r0_LSL_18),
kInstruction_mvn_al_r0_r0_LSL_18,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r3_ROR_18),
kInstruction_mvn_al_r12_r3_ROR_18,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r5_LSL_4),
kInstruction_mvn_al_r5_r5_LSL_4,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r4_ROR_12),
kInstruction_mvn_al_r11_r4_ROR_12,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r14_ROR_23),
kInstruction_mvn_al_r5_r14_ROR_23,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r6_LSL_31),
kInstruction_mvn_al_r7_r6_LSL_31,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r2_ROR_7),
kInstruction_mvn_al_r14_r2_ROR_7,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r0_ROR_23),
kInstruction_mvn_al_r10_r0_ROR_23,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r0_LSL_25),
kInstruction_mvn_al_r6_r0_LSL_25,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r4_ROR_16),
kInstruction_mvn_al_r7_r4_ROR_16,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r0_LSL_19),
kInstruction_mvn_al_r9_r0_LSL_19,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r2_LSL_23),
kInstruction_mvn_al_r7_r2_LSL_23,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r10_LSL_17),
kInstruction_mvn_al_r7_r10_LSL_17,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r10_ROR_19),
kInstruction_mvn_al_r8_r10_ROR_19,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r9_LSL_19),
kInstruction_mvn_al_r6_r9_LSL_19,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r6_LSL_14),
kInstruction_mvn_al_r12_r6_LSL_14,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r12_ROR_24),
kInstruction_mvn_al_r4_r12_ROR_24,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r6_LSL_6),
kInstruction_mvn_al_r3_r6_LSL_6,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r6_ROR_4),
kInstruction_mvn_al_r11_r6_ROR_4,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r3_LSL_10),
kInstruction_mvn_al_r14_r3_LSL_10,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r1_LSL_12),
kInstruction_mvn_al_r1_r1_LSL_12,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r8_LSL_19),
kInstruction_mvn_al_r7_r8_LSL_19,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r5_LSL_22),
kInstruction_mvn_al_r5_r5_LSL_22,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r8_ROR_29),
kInstruction_mvn_al_r14_r8_ROR_29,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r14_LSL_24),
kInstruction_mvn_al_r3_r14_LSL_24,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r14_ROR_5),
kInstruction_mvn_al_r11_r14_ROR_5,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r4_ROR_15),
kInstruction_mvn_al_r12_r4_ROR_15,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r5_LSL_12),
kInstruction_mvn_al_r3_r5_LSL_12,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r12_ROR_26),
kInstruction_mvn_al_r0_r12_ROR_26,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r7_ROR_12),
kInstruction_mvn_al_r5_r7_ROR_12,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r9_LSL_17),
kInstruction_mvn_al_r8_r9_LSL_17,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r2_ROR_13),
kInstruction_mvn_al_r1_r2_ROR_13,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r13_ROR_8),
kInstruction_mvn_al_r0_r13_ROR_8,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r0_LSL_9),
kInstruction_mvn_al_r4_r0_LSL_9,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r2_LSL_21),
kInstruction_mvn_al_r6_r2_LSL_21,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r3_ROR_29),
kInstruction_mvn_al_r5_r3_ROR_29,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r6_LSL_7),
kInstruction_mvn_al_r14_r6_LSL_7,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r4_ROR_11),
kInstruction_mvn_al_r9_r4_ROR_11,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r0_LSL_14),
kInstruction_mvn_al_r4_r0_LSL_14,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r14_ROR_3),
kInstruction_mvn_al_r10_r14_ROR_3,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r11_LSL_31),
kInstruction_mvn_al_r0_r11_LSL_31,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r2_LSL_17),
kInstruction_mvn_al_r5_r2_LSL_17,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r6_ROR_26),
kInstruction_mvn_al_r2_r6_ROR_26,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r9_LSL_8),
kInstruction_mvn_al_r9_r9_LSL_8,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r12_LSL_19),
kInstruction_mvn_al_r12_r12_LSL_19,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r11_LSL_10),
kInstruction_mvn_al_r2_r11_LSL_10,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r7_ROR_6),
kInstruction_mvn_al_r4_r7_ROR_6,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r3_ROR_14),
kInstruction_mvn_al_r2_r3_ROR_14,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r12_ROR_16),
kInstruction_mvn_al_r4_r12_ROR_16,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r12_LSL_2),
kInstruction_mvn_al_r12_r12_LSL_2,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r5_ROR_23),
kInstruction_mvn_al_r10_r5_ROR_23,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r14_ROR_24),
kInstruction_mvn_al_r8_r14_ROR_24,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r1_LSL_15),
kInstruction_mvn_al_r7_r1_LSL_15,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r10_LSL_8),
kInstruction_mvn_al_r13_r10_LSL_8,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r9_ROR_5),
kInstruction_mvn_al_r1_r9_ROR_5,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r2_ROR_17),
kInstruction_mvn_al_r1_r2_ROR_17,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r3_ROR_30),
kInstruction_mvn_al_r12_r3_ROR_30,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r5_LSL_18),
kInstruction_mvn_al_r0_r5_LSL_18,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r7_LSL_2),
kInstruction_mvn_al_r5_r7_LSL_2,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r4_LSL_30),
kInstruction_mvn_al_r13_r4_LSL_30,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r14_ROR_31),
kInstruction_mvn_al_r2_r14_ROR_31,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r8_LSL_30),
kInstruction_mvn_al_r12_r8_LSL_30,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r5_ROR_4),
kInstruction_mvn_al_r3_r5_ROR_4,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r11_ROR_3),
kInstruction_mvn_al_r11_r11_ROR_3,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r2_ROR_17),
kInstruction_mvn_al_r4_r2_ROR_17,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r9_LSL_15),
kInstruction_mvn_al_r6_r9_LSL_15,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r6_ROR_25),
kInstruction_mvn_al_r5_r6_ROR_25,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r3_LSL_19),
kInstruction_mvn_al_r6_r3_LSL_19,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r7_LSL_6),
kInstruction_mvn_al_r3_r7_LSL_6,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r1_LSL_13),
kInstruction_mvn_al_r12_r1_LSL_13,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r1_ROR_9),
kInstruction_mvn_al_r2_r1_ROR_9,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r4_LSL_28),
kInstruction_mvn_al_r12_r4_LSL_28,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r13_ROR_12),
kInstruction_mvn_al_r14_r13_ROR_12,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r12_LSL_16),
kInstruction_mvn_al_r11_r12_LSL_16,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r7_LSL_29),
kInstruction_mvn_al_r8_r7_LSL_29,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r10_ROR_25),
kInstruction_mvn_al_r0_r10_ROR_25,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r6_LSL_3),
kInstruction_mvn_al_r9_r6_LSL_3,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r12_LSL_18),
kInstruction_mvn_al_r9_r12_LSL_18,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r14_LSL_9),
kInstruction_mvn_al_r1_r14_LSL_9,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r2_ROR_7),
kInstruction_mvn_al_r3_r2_ROR_7,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r9_ROR_16),
kInstruction_mvn_al_r14_r9_ROR_16,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r12_LSL_2),
kInstruction_mvn_al_r6_r12_LSL_2,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r7_LSL_14),
kInstruction_mvn_al_r12_r7_LSL_14,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r10_LSL_8),
kInstruction_mvn_al_r12_r10_LSL_8,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r13_ROR_27),
kInstruction_mvn_al_r4_r13_ROR_27,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r5_ROR_20),
kInstruction_mvn_al_r5_r5_ROR_20,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r5_ROR_14),
kInstruction_mvn_al_r1_r5_ROR_14,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r2_ROR_28),
kInstruction_mvn_al_r6_r2_ROR_28,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r8_LSL_9),
kInstruction_mvn_al_r1_r8_LSL_9,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r10_LSL_16),
kInstruction_mvn_al_r2_r10_LSL_16,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r1_LSL_30),
kInstruction_mvn_al_r5_r1_LSL_30,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r3_ROR_19),
kInstruction_mvn_al_r5_r3_ROR_19,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r2_LSL_7),
kInstruction_mvn_al_r1_r2_LSL_7,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r10_ROR_11),
kInstruction_mvn_al_r7_r10_ROR_11,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r10_LSL_10),
kInstruction_mvn_al_r0_r10_LSL_10,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r5_ROR_1),
kInstruction_mvn_al_r7_r5_ROR_1,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r1_LSL_3),
kInstruction_mvn_al_r0_r1_LSL_3,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r0_LSL_24),
kInstruction_mvn_al_r11_r0_LSL_24,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r7_LSL_29),
kInstruction_mvn_al_r3_r7_LSL_29,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r3_ROR_28),
kInstruction_mvn_al_r5_r3_ROR_28,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r4_LSL_26),
kInstruction_mvn_al_r3_r4_LSL_26,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r10_LSL_30),
kInstruction_mvn_al_r8_r10_LSL_30,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r5_ROR_7),
kInstruction_mvn_al_r5_r5_ROR_7,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r7_ROR_13),
kInstruction_mvn_al_r6_r7_ROR_13,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r1_ROR_20),
kInstruction_mvn_al_r7_r1_ROR_20,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r11_LSL_1),
kInstruction_mvn_al_r11_r11_LSL_1,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r13_LSL_1),
kInstruction_mvn_al_r10_r13_LSL_1,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r11_LSL_9),
kInstruction_mvn_al_r6_r11_LSL_9,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r3_LSL_18),
kInstruction_mvn_al_r2_r3_LSL_18,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r4_ROR_16),
kInstruction_mvn_al_r3_r4_ROR_16,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r10_LSL_1),
kInstruction_mvn_al_r4_r10_LSL_1,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r5_LSL_31),
kInstruction_mvn_al_r1_r5_LSL_31,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r6_LSL_29),
kInstruction_mvn_al_r6_r6_LSL_29,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r13_LSL_5),
kInstruction_mvn_al_r10_r13_LSL_5,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r6_LSL_24),
kInstruction_mvn_al_r14_r6_LSL_24,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r12_LSL_31),
kInstruction_mvn_al_r4_r12_LSL_31,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r7_ROR_6),
kInstruction_mvn_al_r12_r7_ROR_6,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r10_LSL_26),
kInstruction_mvn_al_r14_r10_LSL_26,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r9_ROR_24),
kInstruction_mvn_al_r9_r9_ROR_24,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r13_LSL_5),
kInstruction_mvn_al_r8_r13_LSL_5,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r11_LSL_17),
kInstruction_mvn_al_r4_r11_LSL_17,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r14_LSL_9),
kInstruction_mvn_al_r2_r14_LSL_9,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r0_ROR_29),
kInstruction_mvn_al_r1_r0_ROR_29,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r2_ROR_9),
kInstruction_mvn_al_r10_r2_ROR_9,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r7_ROR_29),
kInstruction_mvn_al_r3_r7_ROR_29,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r12_ROR_1),
kInstruction_mvn_al_r1_r12_ROR_1,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r2_ROR_8),
kInstruction_mvn_al_r7_r2_ROR_8,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r1_LSL_24),
kInstruction_mvn_al_r7_r1_LSL_24,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r1_LSL_17),
kInstruction_mvn_al_r4_r1_LSL_17,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r11_ROR_22),
kInstruction_mvn_al_r12_r11_ROR_22,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r4_ROR_20),
kInstruction_mvn_al_r0_r4_ROR_20,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r12_LSL_11),
kInstruction_mvn_al_r5_r12_LSL_11,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r2_ROR_31),
kInstruction_mvn_al_r11_r2_ROR_31,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r11_LSL_4),
kInstruction_mvn_al_r14_r11_LSL_4,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r8_LSL_12),
kInstruction_mvn_al_r6_r8_LSL_12,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r0_LSL_30),
kInstruction_mvn_al_r14_r0_LSL_30,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r11_LSL_29),
kInstruction_mvn_al_r6_r11_LSL_29,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r12_LSL_21),
kInstruction_mvn_al_r6_r12_LSL_21,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r6_LSL_29),
kInstruction_mvn_al_r9_r6_LSL_29,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r13_ROR_29),
kInstruction_mvn_al_r10_r13_ROR_29,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r7_ROR_16),
kInstruction_mvn_al_r5_r7_ROR_16,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r14_LSL_27),
kInstruction_mvn_al_r0_r14_LSL_27,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r4_ROR_18),
kInstruction_mvn_al_r14_r4_ROR_18,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r2_LSL_28),
kInstruction_mvn_al_r14_r2_LSL_28,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r3_LSL_29),
kInstruction_mvn_al_r13_r3_LSL_29,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r7_LSL_19),
kInstruction_mvn_al_r8_r7_LSL_19,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r1_LSL_1),
kInstruction_mvn_al_r14_r1_LSL_1,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r11_ROR_2),
kInstruction_mvn_al_r1_r11_ROR_2,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r4_ROR_14),
kInstruction_mvn_al_r7_r4_ROR_14,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r3_ROR_22),
kInstruction_mvn_al_r6_r3_ROR_22,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r4_LSL_1),
kInstruction_mvn_al_r5_r4_LSL_1,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r11_LSL_6),
kInstruction_mvn_al_r11_r11_LSL_6,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r5_LSL_21),
kInstruction_mvn_al_r13_r5_LSL_21,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r5_ROR_10),
kInstruction_mvn_al_r7_r5_ROR_10,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r10_LSL_17),
kInstruction_mvn_al_r13_r10_LSL_17,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r1_LSL_5),
kInstruction_mvn_al_r7_r1_LSL_5,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r11_LSL_25),
kInstruction_mvn_al_r0_r11_LSL_25,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r2_LSL_9),
kInstruction_mvn_al_r3_r2_LSL_9,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r11_ROR_12),
kInstruction_mvn_al_r8_r11_ROR_12,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r9_LSL_21),
kInstruction_mvn_al_r12_r9_LSL_21,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r3_ROR_13),
kInstruction_mvn_al_r14_r3_ROR_13,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r8_ROR_26),
kInstruction_mvn_al_r13_r8_ROR_26,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r11_ROR_11),
kInstruction_mvn_al_r4_r11_ROR_11,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r3_ROR_16),
kInstruction_mvn_al_r10_r3_ROR_16,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r0_ROR_12),
kInstruction_mvn_al_r14_r0_ROR_12,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r4_LSL_18),
kInstruction_mvn_al_r11_r4_LSL_18,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r13_ROR_3),
kInstruction_mvn_al_r13_r13_ROR_3,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r14_ROR_10),
kInstruction_mvn_al_r10_r14_ROR_10,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r10_LSL_12),
kInstruction_mvn_al_r12_r10_LSL_12,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r0_ROR_29),
kInstruction_mvn_al_r0_r0_ROR_29,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r3_LSL_4),
kInstruction_mvn_al_r13_r3_LSL_4,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r10_LSL_15),
kInstruction_mvn_al_r1_r10_LSL_15,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r10_LSL_18),
kInstruction_mvn_al_r3_r10_LSL_18,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r14_ROR_13),
kInstruction_mvn_al_r11_r14_ROR_13,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r8_ROR_9),
kInstruction_mvn_al_r5_r8_ROR_9,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r7_LSL_3),
kInstruction_mvn_al_r1_r7_LSL_3,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r9_LSL_16),
kInstruction_mvn_al_r8_r9_LSL_16,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r6_ROR_29),
kInstruction_mvn_al_r6_r6_ROR_29,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r10_ROR_6),
kInstruction_mvn_al_r4_r10_ROR_6,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r7_LSL_8),
kInstruction_mvn_al_r13_r7_LSL_8,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r0_LSL_26),
kInstruction_mvn_al_r0_r0_LSL_26,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r3_ROR_14),
kInstruction_mvn_al_r6_r3_ROR_14,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r12_ROR_16),
kInstruction_mvn_al_r13_r12_ROR_16,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r14_ROR_16),
kInstruction_mvn_al_r0_r14_ROR_16,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r13_ROR_3),
kInstruction_mvn_al_r2_r13_ROR_3,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r5_LSL_31),
kInstruction_mvn_al_r3_r5_LSL_31,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r10_LSL_14),
kInstruction_mvn_al_r12_r10_LSL_14,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r10_LSL_24),
kInstruction_mvn_al_r5_r10_LSL_24,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r5_LSL_21),
kInstruction_mvn_al_r5_r5_LSL_21,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r1_LSL_23),
kInstruction_mvn_al_r1_r1_LSL_23,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r0_LSL_12),
kInstruction_mvn_al_r6_r0_LSL_12,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r2_ROR_22),
kInstruction_mvn_al_r6_r2_ROR_22,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r0_LSL_15),
kInstruction_mvn_al_r10_r0_LSL_15,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r9_ROR_28),
kInstruction_mvn_al_r14_r9_ROR_28,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r2_ROR_6),
kInstruction_mvn_al_r0_r2_ROR_6,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r4_LSL_11),
kInstruction_mvn_al_r9_r4_LSL_11,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r11_LSL_5),
kInstruction_mvn_al_r5_r11_LSL_5,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r4_ROR_6),
kInstruction_mvn_al_r7_r4_ROR_6,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r10_ROR_1),
kInstruction_mvn_al_r2_r10_ROR_1,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r3_LSL_27),
kInstruction_mvn_al_r2_r3_LSL_27,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r13_LSL_10),
kInstruction_mvn_al_r5_r13_LSL_10,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r3_LSL_14),
kInstruction_mvn_al_r10_r3_LSL_14,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r7_ROR_29),
kInstruction_mvn_al_r12_r7_ROR_29,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r0_ROR_1),
kInstruction_mvn_al_r0_r0_ROR_1,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r13_LSL_21),
kInstruction_mvn_al_r11_r13_LSL_21,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r2_LSL_12),
kInstruction_mvn_al_r7_r2_LSL_12,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r10_LSL_2),
kInstruction_mvn_al_r1_r10_LSL_2,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r5_LSL_19),
kInstruction_mvn_al_r11_r5_LSL_19,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r2_ROR_2),
kInstruction_mvn_al_r13_r2_ROR_2,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r9_LSL_8),
kInstruction_mvn_al_r7_r9_LSL_8,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r9_ROR_8),
kInstruction_mvn_al_r5_r9_ROR_8,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r14_LSL_31),
kInstruction_mvn_al_r10_r14_LSL_31,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r2_ROR_23),
kInstruction_mvn_al_r0_r2_ROR_23,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r13_LSL_28),
kInstruction_mvn_al_r14_r13_LSL_28,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r2_LSL_25),
kInstruction_mvn_al_r1_r2_LSL_25,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r5_LSL_29),
kInstruction_mvn_al_r3_r5_LSL_29,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r4_ROR_13),
kInstruction_mvn_al_r3_r4_ROR_13,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r6_ROR_4),
kInstruction_mvn_al_r4_r6_ROR_4,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r8_ROR_3),
kInstruction_mvn_al_r6_r8_ROR_3,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r2_ROR_2),
kInstruction_mvn_al_r11_r2_ROR_2,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r5_LSL_29),
kInstruction_mvn_al_r14_r5_LSL_29,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r7_ROR_23),
kInstruction_mvn_al_r0_r7_ROR_23,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r10_LSL_15),
kInstruction_mvn_al_r2_r10_LSL_15,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r7_LSL_5),
kInstruction_mvn_al_r6_r7_LSL_5,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r13_ROR_3),
kInstruction_mvn_al_r11_r13_ROR_3,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r12_ROR_13),
kInstruction_mvn_al_r5_r12_ROR_13,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r12_LSL_26),
kInstruction_mvn_al_r9_r12_LSL_26,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r3_ROR_12),
kInstruction_mvn_al_r7_r3_ROR_12,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r13_LSL_7),
kInstruction_mvn_al_r9_r13_LSL_7,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r14_LSL_25),
kInstruction_mvn_al_r6_r14_LSL_25,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r12_ROR_17),
kInstruction_mvn_al_r1_r12_ROR_17,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r10_LSL_24),
kInstruction_mvn_al_r1_r10_LSL_24,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r11_LSL_17),
kInstruction_mvn_al_r0_r11_LSL_17,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r3_ROR_11),
kInstruction_mvn_al_r8_r3_ROR_11,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r12_ROR_22),
kInstruction_mvn_al_r11_r12_ROR_22,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r9_ROR_28),
kInstruction_mvn_al_r0_r9_ROR_28,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r3_ROR_7),
kInstruction_mvn_al_r9_r3_ROR_7,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r2_ROR_16),
kInstruction_mvn_al_r9_r2_ROR_16,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r12_LSL_28),
kInstruction_mvn_al_r0_r12_LSL_28,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r4_ROR_22),
kInstruction_mvn_al_r1_r4_ROR_22,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r7_LSL_16),
kInstruction_mvn_al_r12_r7_LSL_16,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r9_ROR_3),
kInstruction_mvn_al_r7_r9_ROR_3,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r2_LSL_13),
kInstruction_mvn_al_r8_r2_LSL_13,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r11_LSL_10),
kInstruction_mvn_al_r10_r11_LSL_10,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r12_ROR_6),
kInstruction_mvn_al_r10_r12_ROR_6,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r12_LSL_27),
kInstruction_mvn_al_r3_r12_LSL_27,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r10_ROR_27),
kInstruction_mvn_al_r10_r10_ROR_27,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r8_LSL_8),
kInstruction_mvn_al_r8_r8_LSL_8,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r0_ROR_28),
kInstruction_mvn_al_r3_r0_ROR_28,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r3_ROR_15),
kInstruction_mvn_al_r10_r3_ROR_15,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r14_LSL_27),
kInstruction_mvn_al_r1_r14_LSL_27,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r1_LSL_31),
kInstruction_mvn_al_r10_r1_LSL_31,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r11_LSL_24),
kInstruction_mvn_al_r12_r11_LSL_24,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r11_ROR_11),
kInstruction_mvn_al_r5_r11_ROR_11,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r8_ROR_12),
kInstruction_mvn_al_r13_r8_ROR_12,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r14_LSL_28),
kInstruction_mvn_al_r1_r14_LSL_28,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r2_LSL_6),
kInstruction_mvn_al_r6_r2_LSL_6,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r13_ROR_22),
kInstruction_mvn_al_r14_r13_ROR_22,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r12_ROR_18),
kInstruction_mvn_al_r12_r12_ROR_18,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r7_ROR_2),
kInstruction_mvn_al_r8_r7_ROR_2,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r4_LSL_2),
kInstruction_mvn_al_r6_r4_LSL_2,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r6_ROR_17),
kInstruction_mvn_al_r2_r6_ROR_17,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r14_ROR_16),
kInstruction_mvn_al_r11_r14_ROR_16,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r5_ROR_22),
kInstruction_mvn_al_r1_r5_ROR_22,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r2_ROR_11),
kInstruction_mvn_al_r2_r2_ROR_11,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r9_ROR_1),
kInstruction_mvn_al_r12_r9_ROR_1,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r5_LSL_13),
kInstruction_mvn_al_r13_r5_LSL_13,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r0_LSL_3),
kInstruction_mvn_al_r0_r0_LSL_3,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r11_ROR_9),
kInstruction_mvn_al_r0_r11_ROR_9,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r1_LSL_18),
kInstruction_mvn_al_r6_r1_LSL_18,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r3_LSL_21),
kInstruction_mvn_al_r6_r3_LSL_21,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r6_LSL_30),
kInstruction_mvn_al_r7_r6_LSL_30,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r3_ROR_28),
kInstruction_mvn_al_r11_r3_ROR_28,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r4_ROR_14),
kInstruction_mvn_al_r0_r4_ROR_14,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r14_ROR_22),
kInstruction_mvn_al_r1_r14_ROR_22,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r13_LSL_30),
kInstruction_mvn_al_r3_r13_LSL_30,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r6_LSL_14),
kInstruction_mvn_al_r14_r6_LSL_14,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r10_ROR_1),
kInstruction_mvn_al_r11_r10_ROR_1,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r13_ROR_15),
kInstruction_mvn_al_r11_r13_ROR_15,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r11_LSL_28),
kInstruction_mvn_al_r5_r11_LSL_28,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r12_ROR_28),
kInstruction_mvn_al_r9_r12_ROR_28,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r9_ROR_31),
kInstruction_mvn_al_r14_r9_ROR_31,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r4_LSL_24),
kInstruction_mvn_al_r7_r4_LSL_24,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r14_ROR_6),
kInstruction_mvn_al_r11_r14_ROR_6,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r12_LSL_5),
kInstruction_mvn_al_r2_r12_LSL_5,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r14_ROR_6),
kInstruction_mvn_al_r1_r14_ROR_6,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r4_LSL_20),
kInstruction_mvn_al_r6_r4_LSL_20,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r7_LSL_26),
kInstruction_mvn_al_r10_r7_LSL_26,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r10_LSL_23),
kInstruction_mvn_al_r5_r10_LSL_23,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r5_ROR_27),
kInstruction_mvn_al_r9_r5_ROR_27,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r9_ROR_19),
kInstruction_mvn_al_r6_r9_ROR_19,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r0_LSL_29),
kInstruction_mvn_al_r2_r0_LSL_29,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r11_ROR_9),
kInstruction_mvn_al_r3_r11_ROR_9,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r14_LSL_7),
kInstruction_mvn_al_r0_r14_LSL_7,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r11_LSL_10),
kInstruction_mvn_al_r5_r11_LSL_10,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r9_ROR_25),
kInstruction_mvn_al_r12_r9_ROR_25,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r1_ROR_2),
kInstruction_mvn_al_r11_r1_ROR_2,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r7_ROR_14),
kInstruction_mvn_al_r8_r7_ROR_14,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r0_ROR_1),
kInstruction_mvn_al_r7_r0_ROR_1,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r2_ROR_18),
kInstruction_mvn_al_r3_r2_ROR_18,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r12_LSL_4),
kInstruction_mvn_al_r14_r12_LSL_4,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r5_ROR_8),
kInstruction_mvn_al_r12_r5_ROR_8,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r9_ROR_27),
kInstruction_mvn_al_r6_r9_ROR_27,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r13_LSL_8),
kInstruction_mvn_al_r10_r13_LSL_8,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r11_ROR_9),
kInstruction_mvn_al_r10_r11_ROR_9,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r6_ROR_5),
kInstruction_mvn_al_r2_r6_ROR_5,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r3_LSL_17),
kInstruction_mvn_al_r9_r3_LSL_17,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r7_ROR_19),
kInstruction_mvn_al_r12_r7_ROR_19,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r5_LSL_11),
kInstruction_mvn_al_r9_r5_LSL_11,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r9_LSL_20),
kInstruction_mvn_al_r14_r9_LSL_20,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r2_ROR_4),
kInstruction_mvn_al_r6_r2_ROR_4,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r4_LSL_3),
kInstruction_mvn_al_r8_r4_LSL_3,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r0_ROR_22),
kInstruction_mvn_al_r5_r0_ROR_22,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r6_LSL_13),
kInstruction_mvn_al_r10_r6_LSL_13,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r4_ROR_7),
kInstruction_mvn_al_r10_r4_ROR_7,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r2_ROR_17),
kInstruction_mvn_al_r6_r2_ROR_17,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r8_LSL_26),
kInstruction_mvn_al_r9_r8_LSL_26,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r11_ROR_15),
kInstruction_mvn_al_r6_r11_ROR_15,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r14_LSL_8),
kInstruction_mvn_al_r12_r14_LSL_8,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r3_ROR_3),
kInstruction_mvn_al_r4_r3_ROR_3,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r5_LSL_12),
kInstruction_mvn_al_r9_r5_LSL_12,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r3_ROR_13),
kInstruction_mvn_al_r6_r3_ROR_13,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r13_LSL_21),
kInstruction_mvn_al_r10_r13_LSL_21,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r0_ROR_3),
kInstruction_mvn_al_r4_r0_ROR_3,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r11_LSL_8),
kInstruction_mvn_al_r9_r11_LSL_8,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r14_ROR_14),
kInstruction_mvn_al_r0_r14_ROR_14,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r9_ROR_14),
kInstruction_mvn_al_r9_r9_ROR_14,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r14_ROR_18),
kInstruction_mvn_al_r8_r14_ROR_18,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r2_ROR_13),
kInstruction_mvn_al_r13_r2_ROR_13,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r13_LSL_12),
kInstruction_mvn_al_r13_r13_LSL_12,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r9_LSL_25),
kInstruction_mvn_al_r14_r9_LSL_25,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r0_ROR_9),
kInstruction_mvn_al_r1_r0_ROR_9,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r6_ROR_20),
kInstruction_mvn_al_r12_r6_ROR_20,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r2_ROR_23),
kInstruction_mvn_al_r9_r2_ROR_23,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r10_LSL_1),
kInstruction_mvn_al_r2_r10_LSL_1,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r7_ROR_15),
kInstruction_mvn_al_r8_r7_ROR_15,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r3_ROR_14),
kInstruction_mvn_al_r5_r3_ROR_14,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r8_ROR_1),
kInstruction_mvn_al_r4_r8_ROR_1,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r2_ROR_5),
kInstruction_mvn_al_r1_r2_ROR_5,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r2_ROR_16),
kInstruction_mvn_al_r6_r2_ROR_16,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r4_LSL_15),
kInstruction_mvn_al_r5_r4_LSL_15,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r2_LSL_14),
kInstruction_mvn_al_r4_r2_LSL_14,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r1_LSL_7),
kInstruction_mvn_al_r2_r1_LSL_7,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r8_ROR_30),
kInstruction_mvn_al_r0_r8_ROR_30,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r5_LSL_22),
kInstruction_mvn_al_r9_r5_LSL_22,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r10_LSL_25),
kInstruction_mvn_al_r9_r10_LSL_25,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r6_ROR_15),
kInstruction_mvn_al_r4_r6_ROR_15,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r9_LSL_29),
kInstruction_mvn_al_r2_r9_LSL_29,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r6_ROR_27),
kInstruction_mvn_al_r6_r6_ROR_27,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r1_ROR_26),
kInstruction_mvn_al_r11_r1_ROR_26,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r10_ROR_23),
kInstruction_mvn_al_r5_r10_ROR_23,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r5_LSL_29),
kInstruction_mvn_al_r13_r5_LSL_29,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r1_ROR_27),
kInstruction_mvn_al_r14_r1_ROR_27,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r10_LSL_27),
kInstruction_mvn_al_r0_r10_LSL_27,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r4_ROR_14),
kInstruction_mvn_al_r2_r4_ROR_14,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r10_LSL_31),
kInstruction_mvn_al_r1_r10_LSL_31,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r3_ROR_5),
kInstruction_mvn_al_r2_r3_ROR_5,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r6_ROR_14),
kInstruction_mvn_al_r0_r6_ROR_14,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r9_ROR_25),
kInstruction_mvn_al_r11_r9_ROR_25,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r11_ROR_29),
kInstruction_mvn_al_r2_r11_ROR_29,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r6_ROR_2),
kInstruction_mvn_al_r7_r6_ROR_2,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r3_ROR_3),
kInstruction_mvn_al_r8_r3_ROR_3,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r13_LSL_18),
kInstruction_mvn_al_r8_r13_LSL_18,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r13_ROR_27),
kInstruction_mvn_al_r3_r13_ROR_27,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r5_LSL_18),
kInstruction_mvn_al_r5_r5_LSL_18,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r8_ROR_17),
kInstruction_mvn_al_r14_r8_ROR_17,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r6_LSL_18),
kInstruction_mvn_al_r10_r6_LSL_18,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r1_LSL_2),
kInstruction_mvn_al_r7_r1_LSL_2,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r7_ROR_13),
kInstruction_mvn_al_r9_r7_ROR_13,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r9_LSL_29),
kInstruction_mvn_al_r5_r9_LSL_29,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r12_LSL_22),
kInstruction_mvn_al_r14_r12_LSL_22,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r8_LSL_12),
kInstruction_mvn_al_r0_r8_LSL_12,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r12_ROR_28),
kInstruction_mvn_al_r12_r12_ROR_28,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r3_LSL_2),
kInstruction_mvn_al_r12_r3_LSL_2,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r11_ROR_3),
kInstruction_mvn_al_r6_r11_ROR_3,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r5_ROR_21),
kInstruction_mvn_al_r1_r5_ROR_21,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r14_ROR_29),
kInstruction_mvn_al_r0_r14_ROR_29,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r8_ROR_16),
kInstruction_mvn_al_r11_r8_ROR_16,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r10_ROR_31),
kInstruction_mvn_al_r9_r10_ROR_31,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r1_LSL_25),
kInstruction_mvn_al_r10_r1_LSL_25,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r4_ROR_1),
kInstruction_mvn_al_r9_r4_ROR_1,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r12_LSL_4),
kInstruction_mvn_al_r5_r12_LSL_4,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r7_ROR_25),
kInstruction_mvn_al_r10_r7_ROR_25,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r3_LSL_6),
kInstruction_mvn_al_r9_r3_LSL_6,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r4_ROR_26),
kInstruction_mvn_al_r7_r4_ROR_26,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r0_LSL_31),
kInstruction_mvn_al_r13_r0_LSL_31,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r2_LSL_22),
kInstruction_mvn_al_r9_r2_LSL_22,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r8_ROR_21),
kInstruction_mvn_al_r6_r8_ROR_21,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r7_LSL_11),
kInstruction_mvn_al_r12_r7_LSL_11,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r0_LSL_17),
kInstruction_mvn_al_r10_r0_LSL_17,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r9_ROR_23),
kInstruction_mvn_al_r2_r9_ROR_23,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r4_LSL_6),
kInstruction_mvn_al_r2_r4_LSL_6,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r8_LSL_24),
kInstruction_mvn_al_r7_r8_LSL_24,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r5_LSL_25),
kInstruction_mvn_al_r8_r5_LSL_25,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r11_ROR_23),
kInstruction_mvn_al_r10_r11_ROR_23,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r14_LSL_16),
kInstruction_mvn_al_r0_r14_LSL_16,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r3_LSL_16),
kInstruction_mvn_al_r2_r3_LSL_16,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r11_ROR_13),
kInstruction_mvn_al_r0_r11_ROR_13,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r4_ROR_15),
kInstruction_mvn_al_r6_r4_ROR_15,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r9_LSL_19),
kInstruction_mvn_al_r8_r9_LSL_19,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r13_LSL_23),
kInstruction_mvn_al_r1_r13_LSL_23,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r11_LSL_6),
kInstruction_mvn_al_r4_r11_LSL_6,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r0_ROR_15),
kInstruction_mvn_al_r9_r0_ROR_15,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r0_ROR_7),
kInstruction_mvn_al_r7_r0_ROR_7,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r7_LSL_26),
kInstruction_mvn_al_r5_r7_LSL_26,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r4_LSL_6),
kInstruction_mvn_al_r9_r4_LSL_6,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r9_LSL_9),
kInstruction_mvn_al_r4_r9_LSL_9,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r14_ROR_24),
kInstruction_mvn_al_r3_r14_ROR_24,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r6_ROR_4),
kInstruction_mvn_al_r6_r6_ROR_4,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r1_ROR_19),
kInstruction_mvn_al_r2_r1_ROR_19,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r1_LSL_2),
kInstruction_mvn_al_r13_r1_LSL_2,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r9_ROR_2),
kInstruction_mvn_al_r5_r9_ROR_2,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r14_ROR_25),
kInstruction_mvn_al_r13_r14_ROR_25,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r11_ROR_18),
kInstruction_mvn_al_r2_r11_ROR_18,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r12_ROR_5),
kInstruction_mvn_al_r10_r12_ROR_5,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r4_ROR_2),
kInstruction_mvn_al_r2_r4_ROR_2,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r14_LSL_15),
kInstruction_mvn_al_r12_r14_LSL_15,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r2_LSL_27),
kInstruction_mvn_al_r13_r2_LSL_27,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r13_ROR_27),
kInstruction_mvn_al_r8_r13_ROR_27,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r11_LSL_22),
kInstruction_mvn_al_r12_r11_LSL_22,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r5_ROR_12),
kInstruction_mvn_al_r13_r5_ROR_12,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r7_ROR_17),
kInstruction_mvn_al_r13_r7_ROR_17,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r10_LSL_26),
kInstruction_mvn_al_r4_r10_LSL_26,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r9_LSL_24),
kInstruction_mvn_al_r6_r9_LSL_24,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r5_LSL_13),
kInstruction_mvn_al_r14_r5_LSL_13,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r0_ROR_8),
kInstruction_mvn_al_r12_r0_ROR_8,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r2_LSL_30),
kInstruction_mvn_al_r1_r2_LSL_30,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r7_LSL_15),
kInstruction_mvn_al_r10_r7_LSL_15,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r7_LSL_31),
kInstruction_mvn_al_r0_r7_LSL_31,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r11_LSL_9),
kInstruction_mvn_al_r14_r11_LSL_9,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r6_ROR_2),
kInstruction_mvn_al_r1_r6_ROR_2,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r2_ROR_26),
kInstruction_mvn_al_r5_r2_ROR_26,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r5_LSL_2),
kInstruction_mvn_al_r3_r5_LSL_2,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r3_LSL_3),
kInstruction_mvn_al_r8_r3_LSL_3,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r11_ROR_6),
kInstruction_mvn_al_r6_r11_ROR_6,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r4_ROR_13),
kInstruction_mvn_al_r4_r4_ROR_13,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r4_r2_LSL_20),
kInstruction_mvn_al_r4_r2_LSL_20,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r8_ROR_25),
kInstruction_mvn_al_r13_r8_ROR_25,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r13_LSL_18),
kInstruction_mvn_al_r3_r13_LSL_18,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r0_ROR_23),
kInstruction_mvn_al_r1_r0_ROR_23,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r14_LSL_25),
kInstruction_mvn_al_r14_r14_LSL_25,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r8_LSL_11),
kInstruction_mvn_al_r0_r8_LSL_11,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r1_LSL_13),
kInstruction_mvn_al_r10_r1_LSL_13,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r10_LSL_9),
kInstruction_mvn_al_r13_r10_LSL_9,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r13_LSL_16),
kInstruction_mvn_al_r6_r13_LSL_16,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r14_LSL_5),
kInstruction_mvn_al_r13_r14_LSL_5,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r6_LSL_14),
kInstruction_mvn_al_r2_r6_LSL_14,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r7_LSL_13),
kInstruction_mvn_al_r13_r7_LSL_13,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r5_ROR_26),
kInstruction_mvn_al_r7_r5_ROR_26,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r11_LSL_12),
kInstruction_mvn_al_r12_r11_LSL_12,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r13_ROR_8),
kInstruction_mvn_al_r5_r13_ROR_8,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r8_ROR_2),
kInstruction_mvn_al_r2_r8_ROR_2,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r9_ROR_24),
kInstruction_mvn_al_r0_r9_ROR_24,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r6_LSL_29),
kInstruction_mvn_al_r8_r6_LSL_29,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r10_LSL_18),
kInstruction_mvn_al_r9_r10_LSL_18,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r0_LSL_24),
kInstruction_mvn_al_r6_r0_LSL_24,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r12_LSL_20),
kInstruction_mvn_al_r9_r12_LSL_20,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r11_LSL_3),
kInstruction_mvn_al_r14_r11_LSL_3,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r11_LSL_26),
kInstruction_mvn_al_r12_r11_LSL_26,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r0_LSL_4),
kInstruction_mvn_al_r10_r0_LSL_4,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r12_ROR_7),
kInstruction_mvn_al_r10_r12_ROR_7,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r3_LSL_1),
kInstruction_mvn_al_r12_r3_LSL_1,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r4_ROR_12),
kInstruction_mvn_al_r12_r4_ROR_12,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r0_ROR_12),
kInstruction_mvn_al_r8_r0_ROR_12,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r3_ROR_6),
kInstruction_mvn_al_r3_r3_ROR_6,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r0_LSL_19),
kInstruction_mvn_al_r11_r0_LSL_19,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r14_LSL_24),
kInstruction_mvn_al_r8_r14_LSL_24,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r11_LSL_1),
kInstruction_mvn_al_r0_r11_LSL_1,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r5_LSL_6),
kInstruction_mvn_al_r13_r5_LSL_6,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r14_ROR_31),
kInstruction_mvn_al_r14_r14_ROR_31,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r10_r14_ROR_6),
kInstruction_mvn_al_r10_r14_ROR_6,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r4_LSL_1),
kInstruction_mvn_al_r14_r4_LSL_1,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r3_ROR_7),
kInstruction_mvn_al_r0_r3_ROR_7,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r10_LSL_17),
kInstruction_mvn_al_r2_r10_LSL_17,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r6_ROR_19),
kInstruction_mvn_al_r11_r6_ROR_19,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r13_ROR_11),
kInstruction_mvn_al_r9_r13_ROR_11,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r3_LSL_2),
kInstruction_mvn_al_r11_r3_LSL_2,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r1_ROR_4),
kInstruction_mvn_al_r9_r1_ROR_4,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r8_r11_LSL_16),
kInstruction_mvn_al_r8_r11_LSL_16,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r1_r12_LSL_11),
kInstruction_mvn_al_r1_r12_LSL_11,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r8_ROR_6),
kInstruction_mvn_al_r0_r8_ROR_6,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r5_r3_LSL_2),
kInstruction_mvn_al_r5_r3_LSL_2,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r3_LSL_17),
kInstruction_mvn_al_r6_r3_LSL_17,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r12_ROR_27),
kInstruction_mvn_al_r3_r12_ROR_27,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r6_r8_ROR_15),
kInstruction_mvn_al_r6_r8_ROR_15,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r7_r11_LSL_10),
kInstruction_mvn_al_r7_r11_LSL_10,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r12_LSL_15),
kInstruction_mvn_al_r2_r12_LSL_15,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r2_ROR_8),
kInstruction_mvn_al_r2_r2_ROR_8,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r0_ROR_26),
kInstruction_mvn_al_r12_r0_ROR_26,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r13_ROR_19),
kInstruction_mvn_al_r11_r13_ROR_19,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r0_r9_ROR_2),
kInstruction_mvn_al_r0_r9_ROR_2,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r7_ROR_25),
kInstruction_mvn_al_r9_r7_ROR_25,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r9_r8_LSL_28),
kInstruction_mvn_al_r9_r8_LSL_28,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r12_ROR_17),
kInstruction_mvn_al_r11_r12_ROR_17,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r12_r2_ROR_20),
kInstruction_mvn_al_r12_r2_ROR_20,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r11_r9_ROR_16),
kInstruction_mvn_al_r11_r9_ROR_16,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r13_r11_LSL_14),
kInstruction_mvn_al_r13_r11_LSL_14,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r2_r4_ROR_12),
kInstruction_mvn_al_r2_r4_ROR_12,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r3_r12_ROR_17),
kInstruction_mvn_al_r3_r12_ROR_17,
},
{
ARRAY_SIZE(kInstruction_mvn_al_r14_r11_ROR_27),
kInstruction_mvn_al_r14_r11_ROR_27,
},
};
#endif // VIXL_ASSEMBLER_COND_RD_OPERAND_RN_SHIFT_AMOUNT_1TO31_MVN_T32_H_
| 28.631018 | 80 | 0.734304 |
aecfb4dee0512ee7a6576536cfc74257014a26c9 | 3,230 | h | C | MyMatrix/Matrix_Sparse.h | ccecka/squishy | 431fc4f99c46b6c16467a0a8ff873d44b6e31679 | [
"MIT"
] | null | null | null | MyMatrix/Matrix_Sparse.h | ccecka/squishy | 431fc4f99c46b6c16467a0a8ff873d44b6e31679 | [
"MIT"
] | null | null | null | MyMatrix/Matrix_Sparse.h | ccecka/squishy | 431fc4f99c46b6c16467a0a8ff873d44b6e31679 | [
"MIT"
] | 3 | 2018-05-19T04:44:46.000Z | 2021-07-31T07:51:08.000Z | #ifndef MATRIX_SPARSE_BASE_H
#define MATRIX_SPARSE_BASE_H
#include "Matrix_Base.h"
#include "../Parser.h"
template <typename T>
class matrix_sparse : virtual public matrix_base<T>
{
protected:
using matrix_base<T>::n_rows; // Num Rows
using matrix_base<T>::n_cols; // Num Cols
using matrix_base<T>::val; // Val array
using matrix_base<T>::NOT_STORED;
public:
map< pair<int,int>, int > IJ2K; // (i,j) -> [k] map for all nzs
// Constructors
matrix_sparse() : matrix_base<T>() {}
matrix_sparse(int R, int C) : matrix_base<T>(R,C,0) {}
matrix_sparse(int R, int C, T v) : matrix_base<T>(R,C,0,v) {}
// Destructor
virtual ~matrix_sparse() {}
static string name() { return "MatSparse"; }
using matrix_base<T>::operator=;
inline int nNZ() const
{
return IJ2K.size();
}
// An easy way to check matrices - reorder val to simple row-major
virtual vector<T> getCSRA() const
{
vector<T> A(nNZ());
int nz = 0;
map< pair<int,int>, int >::const_iterator mi;
for( mi = IJ2K.begin(); mi != IJ2K.end(); ++mi, ++nz ) {
A[nz] += val[mi->second];
}
return A;
}
// Default matrix indexing: use the IJ2K map
virtual int IJtoK( int i, int j ) const
{
map< pair<int,int>, int >::const_iterator mi = IJ2K.find( make_pair(i,j) );
if( mi == IJ2K.end() )
return NOT_STORED;
return mi->second;
}
// Default output: row-major
friend ostream& operator<<( ostream& os, const matrix_sparse<T>& A )
{
ios::fmtflags olda = os.setf(ios::right,ios::adjustfield);
ios::fmtflags oldf = os.setf(ios::scientific,ios::floatfield);
int oldp = os.precision(12);
int ichars = ceil( log10( A.nRows() ) );
int jchars = ceil( log10( A.nCols() ) );
map< pair<int,int>, int >::const_iterator mi;
for( mi = A.IJ2K.begin(); mi != A.IJ2K.end(); ++mi ) {
os << "(";
os.width( ichars );
os << mi->first.first << ",";
os.width( jchars );
os << mi->first.second << "): ";
os << A[mi->second] << endl;
}
os.setf(olda,ios::adjustfield);
os.setf(oldf,ios::floatfield);
os.precision(oldp);
return os;
}
void writeASCII( const char* filename )
{
fstream os( filename, ios::out | ios::binary );
os.setf(ios::right,ios::adjustfield);
os.setf(ios::scientific,ios::floatfield);
os.precision(16);
map< pair<int,int>, int >::const_iterator mi;
for( mi = IJ2K.begin(); mi != IJ2K.end(); ++mi ) {
os << mi->first.first << " ";
os << mi->first.second << " ";
os << val[mi->second] << "\n";
}
os.close();
}
};
// Default Sparse MVM
template <typename T>
class SpMVM_CPU : public MVM_CPU<T>
{
protected:
using MVM_CPU<T>::h_y;
map<pair<int,int>, int> IJ2K;
public:
SpMVM_CPU( matrix_sparse<T>& A )
: MVM_CPU<T>(A),
IJ2K(A.IJ2K) {}
virtual ~SpMVM_CPU() {}
static string name() { return "SpMVM_CPU"; }
inline void prod_cpu( vector<T>& h_A, vector<T>& h_x )
{
h_y.zero();
map< pair<int,int>, int >::const_iterator mi;
for( mi = IJ2K.begin(); mi != IJ2K.end(); ++mi ) {
h_y[mi->first.first] += h_A[mi->second] * h_x[mi->first.second];
}
}
};
#endif
| 23.23741 | 79 | 0.58483 |
aed03f17d04d186abcc586c21f686125d99749b8 | 306 | c | C | basic/csapp/exercise/ex8-16.c | zing-dev/learn-c | 193e5f419bf9503aaca93b451b2f2f61bcb668ac | [
"Apache-2.0"
] | 1 | 2020-06-01T14:19:55.000Z | 2020-06-01T14:19:55.000Z | basic/csapp/exercise/ex8-16.c | zhangrxiang/learn-c | 193e5f419bf9503aaca93b451b2f2f61bcb668ac | [
"Apache-2.0"
] | null | null | null | basic/csapp/exercise/ex8-16.c | zhangrxiang/learn-c | 193e5f419bf9503aaca93b451b2f2f61bcb668ac | [
"Apache-2.0"
] | null | null | null | /*
* 8.16
*
* unix> gcc -I../common ex8-16.c ../common/csapp.c -lpthread
* counter = 2
*/
#include "csapp.h"
int counter = 1;
int main() {
if (fork() == 0) {
counter--;
exit(0);
} else {
Wait(NULL);
printf("counter = %d\n", ++counter);
}
exit(0);
}
| 13.304348 | 61 | 0.457516 |
aed0a78915f58e8eb6951e78d8b03dd0d1377baa | 186 | h | C | master-firmware/src/gui.h | greck2908/robot-software | 2e1e8177148a089e8883967375dde7f8ed3d878b | [
"MIT"
] | 40 | 2016-10-04T19:59:22.000Z | 2020-12-25T18:11:35.000Z | master-firmware/src/gui.h | greck2908/robot-software | 2e1e8177148a089e8883967375dde7f8ed3d878b | [
"MIT"
] | 209 | 2016-09-21T21:54:28.000Z | 2022-01-26T07:42:37.000Z | master-firmware/src/gui.h | greck2908/robot-software | 2e1e8177148a089e8883967375dde7f8ed3d878b | [
"MIT"
] | 21 | 2016-11-07T14:40:16.000Z | 2021-11-02T09:53:37.000Z | #ifndef GUI_H
#define GUI_H
#include <error/error.h>
#include <stdarg.h>
#ifdef __cplusplus
extern "C" {
#endif
void gui_start(void);
#ifdef __cplusplus
}
#endif
#endif /* GUI_H */
| 10.333333 | 24 | 0.698925 |
aed3baeaacdcb35585be955fc98fb4d2036c36b0 | 6,880 | h | C | Components/MovingImagePyramids/MovingGenericPyramid/elxMovingGenericPyramid.h | eliseemond/elastix | 0e8572f4a315e0a8f08b07d5947b4f3ac160b575 | [
"Apache-2.0"
] | 318 | 2017-05-22T11:39:46.000Z | 2022-03-27T04:40:13.000Z | Components/MovingImagePyramids/MovingGenericPyramid/elxMovingGenericPyramid.h | eliseemond/elastix | 0e8572f4a315e0a8f08b07d5947b4f3ac160b575 | [
"Apache-2.0"
] | 358 | 2017-05-22T11:36:05.000Z | 2022-03-18T15:49:10.000Z | Components/MovingImagePyramids/MovingGenericPyramid/elxMovingGenericPyramid.h | eliseemond/elastix | 0e8572f4a315e0a8f08b07d5947b4f3ac160b575 | [
"Apache-2.0"
] | 102 | 2017-05-22T11:38:44.000Z | 2021-12-23T20:27:51.000Z | /*=========================================================================
*
* Copyright UMC Utrecht and contributors
*
* 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.txt
*
* 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 elxMovingGenericPyramid_h
#define elxMovingGenericPyramid_h
#include "elxIncludes.h" // include first to avoid MSVS warning
#include "itkGenericMultiResolutionPyramidImageFilter.h"
namespace elastix
{
/**
* \class MovingGenericPyramid
* \brief A pyramid based on the itk::GenericMultiResolutionPyramidImageFilter.
*
* It is generic since it has all functionality that the MovingRecursivePyramid,
* MovingShrinkingPyramid and MovingSmoothingPyramid have together.
* This pyramid has two separate schedules: one for size rescaling and one for
* the Gaussian smoothing factor sigma. In addition, it has an option to compute
* pyramid output per resolution, and not all at once, to reduce memory consumption.
*
* The parameters used in this class are:
* \parameter MovingImagePyramid: Select this pyramid as follows:\n
* <tt>(MovingImagePyramid "MovingGenericImagePyramid")</tt>
* \parameter MovingImagePyramidRescaleSchedule: downsampling factors for the moving image pyramid.\n
* For each dimension, for each resolution level, the downsampling factor of the
* moving image can be specified.\n
* Syntax for 2D images:\n
* <tt>(MovingImagePyramidRescaleSchedule <reslevel0,dim0> <reslevel0,dim1> <reslevel1,dim0> <reslevel1,dim1>
* ...)</tt>\n example: <tt>(MovingImagePyramidRescaleSchedule 4 4 2 2 1 1)</tt>\n Default: isotropic, halved in each
* resolution, so, like in the example. If ImagePyramidRescaleSchedule is specified, that schedule is used for both
* moving and moving image pyramid. \parameter ImagePyramidRescaleSchedule: rescale schedule for both pyramids
* \parameter ImagePyramidSchedule: same as ImagePyramidRescaleSchedule
* \parameter MovingImagePyramidSchedule: same as MovingImagePyramidRescaleSchedule
* \parameter MovingImagePyramidSmoothingSchedule: sigma's for smoothing the moving image pyramid.\n
* For each dimension, for each resolution level, the sigma of the
* moving image can be specified.\n
* Syntax for 2D images:\n
* <tt>(MovingImagePyramidSmoothingSchedule <reslevel0,dim0> <reslevel0,dim1> <reslevel1,dim0> <reslevel1,dim1>
* ...)</tt>\n example: <tt>(MovingImagePyramidSmoothingSchedule 4 4 2 2 1 1)</tt>\n Default: 0.5 x rescale_factor x
* moving_image_spacing.\n If ImagePyramidSmoothingSchedule is specified, that schedule is used for both moving and
* moving image pyramid. \parameter ImagePyramidSmoothingSchedule: smoothing schedule for both pyramids \parameter
* ComputePyramidImagesPerResolution: Flag to specify if all resolution levels are computed at once, or per resolution.
* Latter saves memory.\n example: <tt>(ComputePyramidImagesPerResolution "true")</tt>\n Default false. \parameter
* ImagePyramidUseShrinkImageFilter: Flag to specify if the ShrinkingImageFilter is used for rescaling the image, or the
* ResampleImageFilter. Shrinker is faster.\n example: <tt>(ImagePyramidUseShrinkImageFilter "true")</tt>\n Default
* false, so by default the resampler is used.
*
* \ingroup ImagePyramids
*/
template <class TElastix>
class ITK_TEMPLATE_EXPORT MovingGenericPyramid
: public itk::GenericMultiResolutionPyramidImageFilter<typename MovingImagePyramidBase<TElastix>::InputImageType,
typename MovingImagePyramidBase<TElastix>::OutputImageType>
, public MovingImagePyramidBase<TElastix>
{
public:
/** Standard ITK-stuff. */
typedef MovingGenericPyramid Self;
typedef itk::GenericMultiResolutionPyramidImageFilter<typename MovingImagePyramidBase<TElastix>::InputImageType,
typename MovingImagePyramidBase<TElastix>::OutputImageType>
Superclass1;
typedef MovingImagePyramidBase<TElastix> Superclass2;
typedef itk::SmartPointer<Self> Pointer;
typedef itk::SmartPointer<const Self> ConstPointer;
/** Method for creation through the object factory. */
itkNewMacro(Self);
/** Run-time type information (and related methods). */
itkTypeMacro(MovingGenericPyramid, GenericMultiResolutionPyramidImageFilter);
/** Name of this class.
* Use this name in the parameter file to select this specific pyramid. \n
* example: <tt>(MovingImagePyramid "MovingGenericImagePyramid")</tt>\n
*/
elxClassNameMacro("MovingGenericImagePyramid");
/** Get the ImageDimension. */
itkStaticConstMacro(ImageDimension, unsigned int, Superclass1::ImageDimension);
/** Typedefs inherited from the superclass. */
using typename Superclass1::InputImageType;
using typename Superclass1::OutputImageType;
using typename Superclass1::InputImagePointer;
using typename Superclass1::OutputImagePointer;
using typename Superclass1::InputImageConstPointer;
using typename Superclass1::ScheduleType;
using typename Superclass1::RescaleScheduleType;
using typename Superclass1::SmoothingScheduleType;
/** Typedefs inherited from Elastix. */
using typename Superclass2::ElastixType;
using typename Superclass2::ElastixPointer;
using typename Superclass2::ConfigurationType;
using typename Superclass2::ConfigurationPointer;
using typename Superclass2::RegistrationType;
using typename Superclass2::RegistrationPointer;
typedef typename Superclass2::ITKBaseType ITKBaseType;
/** Method for setting the schedule. Override from MovingImagePyramidBase,
* since we now have two schedules, rescaling and smoothing.
*/
void
SetMovingSchedule(void) override;
/** Update the current resolution level. */
void
BeforeEachResolution(void) override;
protected:
/** The constructor. */
MovingGenericPyramid() = default;
/** The destructor. */
~MovingGenericPyramid() override = default;
private:
elxOverrideGetSelfMacro;
/** The deleted copy constructor. */
MovingGenericPyramid(const Self &) = delete;
/** The deleted assignment operator. */
void
operator=(const Self &) = delete;
};
} // end namespace elastix
#ifndef ITK_MANUAL_INSTANTIATION
# include "elxMovingGenericPyramid.hxx"
#endif
#endif // end #ifndef elxMovingGenericPyramid_h
| 45.866667 | 120 | 0.742878 |
aed411a4c3e638cd3da82c7dd64bdaa1e7aef79d | 6,143 | h | C | library/base/algorithm/libjpeg_turbo/jpeglibmangler.h | topillar/PuTTY-ng | 1f5bf26de0f42e03ef4f100fa879b16216d61abf | [
"MIT"
] | 39 | 2019-06-22T12:25:54.000Z | 2022-03-14T05:42:44.000Z | library/base/algorithm/libjpeg_turbo/jpeglibmangler.h | topillar/PuTTY-ng | 1f5bf26de0f42e03ef4f100fa879b16216d61abf | [
"MIT"
] | 5 | 2019-06-29T10:58:43.000Z | 2020-09-04T08:44:09.000Z | library/base/algorithm/libjpeg_turbo/jpeglibmangler.h | topillar/PuTTY-ng | 1f5bf26de0f42e03ef4f100fa879b16216d61abf | [
"MIT"
] | 16 | 2015-01-08T01:47:24.000Z | 2022-02-25T06:06:06.000Z | // Copyright (c) 2009 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef THIRD_PARTY_LIBJPEG_TURBO_JPEGLIBMANGLER_H_
#define THIRD_PARTY_LIBJPEG_TURBO_JPEGLIBMANGLER_H_
// Mangle all externally visible function names so we can build our own libjpeg
// without system libraries trying to use it.
#define jpeg_make_c_derived_tbl chromium_jpeg_make_c_derived_tbl
#define jpeg_gen_optimal_table chromium_jpeg_gen_optimal_table
#define jpeg_make_d_derived_tbl chromium_jpeg_make_d_derived_tbl
#define jpeg_fill_bit_buffer chromium_jpeg_fill_bit_buffer
#define jpeg_huff_decode chromium_jpeg_huff_decode
#define jpeg_fdct_islow chromium_jpeg_fdct_islow
#define jpeg_fdct_ifast chromium_jpeg_fdct_ifast
#define jpeg_fdct_float chromium_jpeg_fdct_float
#define jpeg_idct_islow chromium_jpeg_idct_islow
#define jpeg_idct_ifast chromium_jpeg_idct_ifast
#define jpeg_idct_float chromium_jpeg_idct_float
#define jpeg_idct_4x4 chromium_jpeg_idct_4x4
#define jpeg_idct_2x2 chromium_jpeg_idct_2x2
#define jpeg_idct_1x1 chromium_jpeg_idct_1x1
#define jinit_compress_master chromium_jinit_compress_master
#define jinit_c_master_control chromium_jinit_c_master_control
#define jinit_c_main_controller chromium_jinit_c_main_controller
#define jinit_c_prep_controller chromium_jinit_c_prep_controller
#define jinit_c_coef_controller chromium_jinit_c_coef_controller
#define jinit_color_converter chromium_jinit_color_converter
#define jinit_downsampler chromium_jinit_downsampler
#define jinit_forward_dct chromium_jinit_forward_dct
#define jinit_huff_encoder chromium_jinit_huff_encoder
#define jinit_phuff_encoder chromium_jinit_phuff_encoder
#define jinit_marker_writer chromium_jinit_marker_writer
#define jinit_master_decompress chromium_jinit_master_decompress
#define jinit_d_main_controller chromium_jinit_d_main_controller
#define jinit_d_coef_controller chromium_jinit_d_coef_controller
#define jinit_d_post_controller chromium_jinit_d_post_controller
#define jinit_input_controller chromium_jinit_input_controller
#define jinit_marker_reader chromium_jinit_marker_reader
#define jinit_huff_decoder chromium_jinit_huff_decoder
#define jinit_phuff_decoder chromium_jinit_phuff_decoder
#define jinit_inverse_dct chromium_jinit_inverse_dct
#define jinit_upsampler chromium_jinit_upsampler
#define jinit_color_deconverter chromium_jinit_color_deconverter
#define jinit_1pass_quantizer chromium_jinit_1pass_quantizer
#define jinit_2pass_quantizer chromium_jinit_2pass_quantizer
#define jinit_merged_upsampler chromium_jinit_merged_upsampler
#define jinit_memory_mgr chromium_jinit_memory_mgr
#define jdiv_round_up chromium_jdiv_round_up
#define jround_up chromium_jround_up
#define jcopy_sample_rows chromium_jcopy_sample_rows
#define jcopy_block_row chromium_jcopy_block_row
#define jzero_far chromium_jzero_far
#define jpeg_std_error chromium_jpeg_std_error
#define jpeg_CreateCompress chromium_jpeg_CreateCompress
#define jpeg_CreateDecompress chromium_jpeg_CreateDecompress
#define jpeg_destroy_compress chromium_jpeg_destroy_compress
#define jpeg_destroy_decompress chromium_jpeg_destroy_decompress
#define jpeg_stdio_dest chromium_jpeg_stdio_dest
#define jpeg_stdio_src chromium_jpeg_stdio_src
#define jpeg_set_defaults chromium_jpeg_set_defaults
#define jpeg_set_colorspace chromium_jpeg_set_colorspace
#define jpeg_default_colorspace chromium_jpeg_default_colorspace
#define jpeg_set_quality chromium_jpeg_set_quality
#define jpeg_set_linear_quality chromium_jpeg_set_linear_quality
#define jpeg_add_quant_table chromium_jpeg_add_quant_table
#define jpeg_quality_scaling chromium_jpeg_quality_scaling
#define jpeg_simple_progression chromium_jpeg_simple_progression
#define jpeg_suppress_tables chromium_jpeg_suppress_tables
#define jpeg_alloc_quant_table chromium_jpeg_alloc_quant_table
#define jpeg_alloc_huff_table chromium_jpeg_alloc_huff_table
#define jpeg_start_compress chromium_jpeg_start_compress
#define jpeg_write_scanlines chromium_jpeg_write_scanlines
#define jpeg_finish_compress chromium_jpeg_finish_compress
#define jpeg_write_raw_data chromium_jpeg_write_raw_data
#define jpeg_write_marker chromium_jpeg_write_marker
#define jpeg_write_m_header chromium_jpeg_write_m_header
#define jpeg_write_m_byte chromium_jpeg_write_m_byte
#define jpeg_write_tables chromium_jpeg_write_tables
#define jpeg_read_header chromium_jpeg_read_header
#define jpeg_start_decompress chromium_jpeg_start_decompress
#define jpeg_read_scanlines chromium_jpeg_read_scanlines
#define jpeg_finish_decompress chromium_jpeg_finish_decompress
#define jpeg_read_raw_data chromium_jpeg_read_raw_data
#define jpeg_has_multiple_scans chromium_jpeg_has_multiple_scans
#define jpeg_start_output chromium_jpeg_start_output
#define jpeg_finish_output chromium_jpeg_finish_output
#define jpeg_input_complete chromium_jpeg_input_complete
#define jpeg_new_colormap chromium_jpeg_new_colormap
#define jpeg_consume_input chromium_jpeg_consume_input
#define jpeg_calc_output_dimensions chromium_jpeg_calc_output_dimensions
#define jpeg_save_markers chromium_jpeg_save_markers
#define jpeg_set_marker_processor chromium_jpeg_set_marker_processor
#define jpeg_read_coefficients chromium_jpeg_read_coefficients
#define jpeg_write_coefficients chromium_jpeg_write_coefficients
#define jpeg_copy_critical_parameters chromium_jpeg_copy_critical_parameters
#define jpeg_abort_compress chromium_jpeg_abort_compress
#define jpeg_abort_decompress chromium_jpeg_abort_decompress
#define jpeg_abort chromium_jpeg_abort
#define jpeg_destroy chromium_jpeg_destroy
#define jpeg_resync_to_restart chromium_jpeg_resync_to_restart
#define jpeg_get_small chromium_jpeg_get_small
#define jpeg_free_small chromium_jpeg_free_small
#define jpeg_get_large chromium_jpeg_get_large
#define jpeg_free_large chromium_jpeg_free_large
#define jpeg_mem_available chromium_jpeg_mem_available
#define jpeg_open_backing_store chromium_jpeg_open_backing_store
#define jpeg_mem_init chromium_jpeg_mem_init
#define jpeg_mem_term chromium_jpeg_mem_term
#endif // THIRD_PARTY_LIBJPEG_TURBO_JPEGLIBMANGLER_H_
| 53.885965 | 79 | 0.920072 |
aed423bc97836aab0f9b23005fa06e4a9db30da2 | 215 | c | C | linux_linker/our_exe/our_exe.c | rebeccaskinner/procedural_friday | 6c34839f28ae9c281d6d1e451b048d4479f5d3a6 | [
"MIT"
] | null | null | null | linux_linker/our_exe/our_exe.c | rebeccaskinner/procedural_friday | 6c34839f28ae9c281d6d1e451b048d4479f5d3a6 | [
"MIT"
] | null | null | null | linux_linker/our_exe/our_exe.c | rebeccaskinner/procedural_friday | 6c34839f28ae9c281d6d1e451b048d4479f5d3a6 | [
"MIT"
] | null | null | null | #include <stdlib.h>
#include <stdio.h>
#include <our_so.h>
int main(int argc, char** argv)
{
int num = 0;
if(argc >= 2) {
num = atoi(argv[1]);
}
printf("%d! = %d\n", num, factorial(num));
return 0;
}
| 15.357143 | 44 | 0.55814 |
aed4ef072d54988e01dcec664eeb43c9ef57f997 | 3,080 | h | C | UIKit/Classes/UIScroller.h | Eric-Wright/Chameleon | 490944c89027c89f6e7c108c1775f850fc6bd9f1 | [
"BSD-3-Clause"
] | 1 | 2015-03-20T08:19:47.000Z | 2015-03-20T08:19:47.000Z | UIKit/Classes/UIScroller.h | Eric-Wright/Chameleon | 490944c89027c89f6e7c108c1775f850fc6bd9f1 | [
"BSD-3-Clause"
] | null | null | null | UIKit/Classes/UIScroller.h | Eric-Wright/Chameleon | 490944c89027c89f6e7c108c1775f850fc6bd9f1 | [
"BSD-3-Clause"
] | null | null | null | /*
* Copyright (c) 2011, The Iconfactory. 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 Iconfactory 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 ICONFACTORY 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.
*/
#import "UIView.h"
#import "UIScrollView.h"
@class UIImageView, UIScroller;
CGFloat UIScrollerWidthForBoundsSize(CGSize boundsSize);
@protocol _UIScrollerDelegate
- (void)_UIScroller:(UIScroller *)scroller contentOffsetDidChange:(CGFloat)newOffset;
- (void)_UIScrollerDidEndDragging:(UIScroller *)scroller withEvent:(UIEvent *)event;
@end
@interface UIScroller : UIView {
@private
id _delegate;
CGFloat _contentOffset;
CGFloat _contentSize;
CGFloat _dragOffset;
BOOL _draggingKnob;
BOOL _isVertical;
CGPoint _lastTouchLocation;
NSTimer *_holdTimer;
UIScrollViewIndicatorStyle _indicatorStyle;
NSTimer *_fadeTimer;
BOOL _alwaysVisible;
}
// NOTE: UIScroller set's its own alpha to 0 when it is created, so it is NOT visible by default!
// the flash/quickFlash methods alter its own alpha in order to fade in/out, etc.
- (void)flash;
- (void)quickFlash;
@property (nonatomic, assign) BOOL alwaysVisible; // if YES, -flash has no effect on the scroller's alpha, setting YES fades alpha to 1, setting NO fades it out if it was visible
@property (nonatomic, assign) id<_UIScrollerDelegate> delegate;
@property (nonatomic, assign) CGFloat contentSize; // used to calulate how big the slider knob should be (uses its own frame height/width and compares against this value)
@property (nonatomic, assign) CGFloat contentOffset; // set this after contentSize is set or else it'll normalize in unexpected ways
@property (nonatomic) UIScrollViewIndicatorStyle indicatorStyle;
@end
| 44 | 179 | 0.768831 |
aed68d56b7293e41878011d9eeb2a639fd0941bc | 252 | c | C | lineno.c | jonathangjertsen/cshells | 8171f7449b792fa845535d2488553cf01ea54df6 | [
"Unlicense"
] | 1 | 2022-02-10T15:05:24.000Z | 2022-02-10T15:05:24.000Z | lineno.c | jonathangjertsen/cshells | 8171f7449b792fa845535d2488553cf01ea54df6 | [
"Unlicense"
] | null | null | null | lineno.c | jonathangjertsen/cshells | 8171f7449b792fa845535d2488553cf01ea54df6 | [
"Unlicense"
] | 1 | 2022-02-10T11:37:24.000Z | 2022-02-10T11:37:24.000Z | #include <stdio.h>
#include "shell_utils.h"
int main(int argc, char **argv)
{
line_buffer lb = {};
int lineno = 1;
while (fgets(lb, sizeof(lb), stdin))
{
printf("%6d | %s", lineno, lb);
lineno++;
}
return 0;
}
| 15.75 | 40 | 0.52381 |
aed837d58f0b3468f27bddb75a4d6a01ce016440 | 8,900 | c | C | CSparse/bbd/cs_misc.c | xiongyw/SuiteSparse | 2c07efbf8950cb03b92d49720ef1e55635cc099c | [
"Apache-2.0"
] | null | null | null | CSparse/bbd/cs_misc.c | xiongyw/SuiteSparse | 2c07efbf8950cb03b92d49720ef1e55635cc099c | [
"Apache-2.0"
] | null | null | null | CSparse/bbd/cs_misc.c | xiongyw/SuiteSparse | 2c07efbf8950cb03b92d49720ef1e55635cc099c | [
"Apache-2.0"
] | null | null | null | #include <assert.h>
#include <string.h>
#include "cs.h"
#include "mmio.h"
#include "cs_misc.h"
// cf: https://math.nist.gov/MatrixMarket/mmio/c/example_read.c
cs* CS_load_mm(const char* path)
{
MM_typecode matcode;
FILE *f;
int M, N, nz;
csi i, *I, *J;
double *val;
int tmp;
if ((f = fopen(path, "r")) == NULL) {
printf("file %s not founc!", path);
return NULL;
}
if (mm_read_banner(f, &matcode) != 0) {
printf("Could not process Matrix Market banner.\n");
return NULL;
}
/* This is how one can screen matrix types if their application */
/* only supports a subset of the Matrix Market data types. */
if (mm_is_complex(matcode) && mm_is_matrix(matcode) && mm_is_sparse(matcode)) {
printf("Sorry, this application does not support ");
printf("Market Market type: [%s]\n", mm_typecode_to_str(matcode));
return NULL;
}
/* find out size of sparse matrix .... */
if (0 != mm_read_mtx_crd_size(f, &M, &N, &nz)) {
printf("Sorry, mm_read_mtx_crd_size() failed!");
return NULL;
}
printf("(M, N, nz)=(%d, %d, %d)\n", M, N, nz);
/* reseve memory for matrices */
I = (csi*) malloc(nz * sizeof(csi));
J = (csi*) malloc(nz * sizeof(csi));
val = (double *) malloc(nz * sizeof(double));
/* NOTE: when reading in doubles, ANSI C requires the use of the "l" */
/* specifier as in "%lg", "%lf", "%le", otherwise errors will occur */
/* (ANSI C X3.159-1989, Sec. 4.9.6.2, p. 136 lines 13-15) */
for (i=0; i<nz; i++)
{
tmp = fscanf(f, "%ld %ld %lg\n", &I[i], &J[i], &val[i]);
I[i]--; /* adjust from 1-based to 0-based */
J[i]--;
}
fclose(f);
cs* A = (cs*)malloc(sizeof(cs));
A->m = M;
A->n = N;
A->nzmax = nz;
A->nz = nz; // not compressed
A->p = J;
A->i = I;
A->x = val;
return A;
}
cs* CS_unzip(const cs* A)
{
if (!A || (A->nz != -1)) {
assert( 0 && "input is either NULL, or it's already triplet-form");
return NULL;
}
// new triplet-form matrix skeleton
cs* t = CS_skeleton(A->m, A->n, 1);
assert(t && "CS_skeleton() failure");
// travese the elements
int ret;
for (int j = 0 ; j < A->n ; ++j) {
for (int p = A->p[j] ; p < A->p[j+1] ; p++) {
int row = A->i[p]; // col = j
ret = cs_entry(t, row, j, A->x[p]);
assert((ret == 1) && "cs_entry() failure!\n");
}
}
return t;
}
void CS_dump(const cs* M, const char* text)
{
printf("\n%s (%s): (m, n, nzmax, nz) = (%ld, %ld, %ld, %ld)\n", text, (M->nz==-1)? "compressed": "triplet", M->m, M->n, M->nzmax, M->nz);
if (M->nz != - 1) { // triplet
printf("p[]=[");
for (int i = 0; i < M->nz; ++ i) printf("%ld, ", M->p[i]);
printf("] <- col start indices\n");
printf("i[]=[");
for (int i = 0; i < M->nz; ++ i) printf("%ld, ", M->i[i]);
printf("] <- row indices\n");
printf("x[]=[");
for (int i = 0; i < M->nz; ++ i) printf("%lf, ", M->x[i]);
printf("]\n");
} else { // compressed
printf("p[]=[");
for (int i = 0; i < M->n; ++ i) printf("%ld, ", M->p[i]);
printf("] <- col start indices\n");
printf("i[]=[");
for (int i = 0; i < M->nzmax; ++ i) printf("%ld, ", M->i[i]);
printf("] <- row indices\n");
printf("x[]=[");
for (int i = 0; i < M->nzmax; ++ i) printf("%lf, ", M->x[i]);
printf("]\n");
}
}
cs* CS_diff(const cs* A, const cs* B)
{
return cs_add(A, B, 1, -1);
}
cs* CS_copy(const cs* src)
{
assert(src);
cs* c = (cs*)malloc(sizeof(cs));
assert(c && "malloc() failure");
c->nzmax = src->nzmax;
c->nz = src->nz;
c->m = src->m;
c->n = src->n;
if (src->i) {
c->i = (csi*)calloc(src->nzmax, sizeof(csi));
assert(c->i);
memcpy(c->i, src->i, sizeof(csi) * src->nzmax);
} else {
c->i = NULL;
}
if (src->x) {
c->x = (double*)calloc(src->nzmax, sizeof(double));
assert(c->x);
memcpy(c->x, src->x, sizeof(double) * src->nzmax);
} else {
c->x = NULL;
}
if (src->p) {
int len = 0; // #elements of p[]
if (src->nz == -1) { // compressed
len = src->n + 1;
} else { // triplet
len = src->nzmax;
}
c->p = (csi*)malloc(sizeof(csi)*len);
assert(c->p);
memcpy(c->p, src->p, sizeof(csi)*len);
} else {
c->p = NULL;
}
return c;
}
cs* CS_clip(cs* A, csi ri, csi ci, csi m, csi n)
{
int ret;
// sanity checks
if (!A || m < 1 || n < 1 || ri < 0 || ci < 0 ||
(ri >= A->m) || (ci >= A->n) ||
((ri + m) > A->m) || ((ci + n) > A->n)) {
assert(0 && "CS_submatrix() error: wrong parameters!");
return NULL;
}
cs* t = CS_skeleton(m, n, 1);
//CS_dump(t, "clip");
if (A->nz != -1) { // source is triplet-form
for(int i = 0; i < A->nzmax; ++ i) {
if(A->p[i] >= ci && A->p[i] < (ci + n) &&
A->i[i] >= ri && A->i[i] < (ri + m)) {
ret = cs_entry(t, A->i[i] - ri, A->p[i] - ci, A->x[i]);
assert((ret == 1) && "cs_entry() failure!\n");
}
}
} else { // source is compressed
for (int j = 0 ; j < A->n ; ++j) {
for (int p = A->p[j] ; p < A->p[j+1] ; p++) {
int row = A->i[p]; // col = j
if(row >= ri &&
row < (ri + m) &&
j >= ci &&
j < (ci + n)) {
//printf("(row, col, value)=%d, %d, %g\n", row, j, A->x[p]);
//printf("new (row, col)=%d, %d\n", row-ri, j - ci);
ret = cs_entry(t, row - ri, j - ci, A->x[p]);
assert((ret == 1) && "cs_entry() failure!\n");
}
}
}
}
cs* c = cs_compress(t);
cs_spfree(t);
return c;
}
cs* CS_skeleton(csi m, csi n, int triplet)
{
cs* A = cs_spalloc(m, n,
1, // nzmax
1, // values
triplet);
assert(A && "cs_spalloc() fail");
if (triplet) {
A->nz = 0;
} else {
// set all Ap[] to zero
for (int i = 0; i <= n; i ++)
A->p[i] = 0;
}
return A;
}
cs* CS_id(csi n)
{
int ret;
cs* id = CS_skeleton(n, n, 1);
for (int i = 0; i < n; i ++) {
ret = cs_entry(id, i, i, 1.);
assert((ret == 1) && "cs_entry() failure!\n");
}
cs* idc = cs_compress(id);
cs_spfree(id);
return idc;
}
cs* CS_patch(const cs* A, const cs* P, csi ri, csi ci, double k)
{
int ret;
if (!A || !P ||
!CS_CSC (A) ||!CS_CSC (P) ||
ri < 0 || ci < 0 ||
ri >= A->m || ci >= A->n ||
((ri + P->m) > A->m) ||
((ci + P->n) > A->n)) {
assert (0 && "input parameter wrong");
return 0;
}
// in case A & P are of the same size and completely overlap
if (ri == 0 && ci == 0 && A->m == P->m && A->n == P->n) {
return cs_add(A, P, 1, k);
}
// extend P to the same size of A, in triplet-form
cs* PP = CS_skeleton(A->m, A->n, 1);
// populate PP
for (int j = 0 ; j < P->n ; ++j) {
for (int p = P->p[j] ; p < P->p[j+1] ; p++) {
int row = P->i[p]; // col = j
ret = cs_entry(PP, row + ri, j + ci, P->x[p]);
assert((ret == 1) && "cs_entry() failure!\n");
}
}
// compress PP
cs* C = cs_compress(PP);
// patch by cs_add()
cs* AP = cs_add(A, C, 1, k);
cs_spfree(PP);
cs_spfree(C);
return AP;
}
cs* CS_tri_inv(cs* t, int low)
{
int ret;
if (!t || !CS_CSC(t) || t->m != t->n) {
assert(t && "invalid input");
return NULL;
}
cs* id = CS_id(t->n);
cs* inv = CS_skeleton(t->n, t->n, 1); // triplet-form for now
double* x = (double*)malloc(sizeof(double)*t->n);
assert(x && "malloc failure!");
csi* xi = (csi*)malloc(sizeof(csi)*t->n*2);
assert(xi && "malloc failure!");
// solve Lx=I, column by column
for (int k = 0; k < id->n; k ++) {
memset(x, 0, sizeof(double)*t->n); // this is needed, opposite to the book at p34
ret = cs_spsolve(t, id, k, xi, x, NULL, low);
assert((ret != -1) && "cs_spsolve() failure");
for (int i = 0; i < id->n; i ++) {
if (x[i] != 0.) {
ret = cs_entry(inv, i, k, x[i]);
assert((ret == 1) && "cs_spsolve() failure");
}
}
}
cs* INV = cs_compress(inv);
assert(INV && "cs_spsolve() failure");
free(x);
free(xi);
cs_spfree(id);
cs_spfree(inv);
return INV;
}
| 25.356125 | 141 | 0.437303 |
aed88045e54465387da2f593ec952ddf19907284 | 81 | c | C | tools-src/gnu/gcc/gcc/testsuite/gcc.c-torture/compile/920501-7.c | enfoTek/tomato.linksys.e2000.nvram-mod | 2ce3a5217def49d6df7348522e2bfda702b56029 | [
"FSFAP"
] | 80 | 2015-01-02T10:14:04.000Z | 2021-06-07T06:29:49.000Z | tools-src/gnu/gcc/gcc/testsuite/gcc.c-torture/compile/920501-7.c | unforgiven512/tomato | 96f09fab4929c6ddde5c9113f1b2476ad37133c4 | [
"FSFAP"
] | 9 | 2015-05-14T11:03:12.000Z | 2018-01-04T07:12:58.000Z | tools-src/gnu/gcc/gcc/testsuite/gcc.c-torture/compile/920501-7.c | unforgiven512/tomato | 96f09fab4929c6ddde5c9113f1b2476ad37133c4 | [
"FSFAP"
] | 69 | 2015-01-02T10:45:56.000Z | 2021-09-06T07:52:13.000Z | #ifndef NO_LABEL_VALUES
x(){if(&&e-&&b<0)x();b:goto*&&b;e:;}
#else
int x;
#endif
| 13.5 | 36 | 0.592593 |
aeda2cf9c7901e6b533ea43a33137cfa1c0ba353 | 26,918 | c | C | deps/neverbleed/neverbleed.c | mingodad/h2o | 7c471d5807808d63715243ace65eea319b9021f9 | [
"MIT"
] | 7 | 2015-05-27T23:01:46.000Z | 2020-02-17T21:51:36.000Z | deps/neverbleed/neverbleed.c | mingodad/h2o | 7c471d5807808d63715243ace65eea319b9021f9 | [
"MIT"
] | null | null | null | deps/neverbleed/neverbleed.c | mingodad/h2o | 7c471d5807808d63715243ace65eea319b9021f9 | [
"MIT"
] | null | null | null | /*
* Copyright (c) 2015 Kazuho Oku, DeNA Co., Ltd.
*
* 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.
*/
#include <assert.h>
#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <grp.h>
#include <limits.h>
#include <pthread.h>
#include <pwd.h>
#include <stdarg.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/uio.h>
#include <unistd.h>
#include <openssl/rand.h>
#include <openssl/ssl.h>
#ifdef __linux__
#include <sys/prctl.h>
#endif
#include "neverbleed.h"
struct expbuf_t {
char *buf;
char *start;
char *end;
size_t capacity;
};
struct st_neverbleed_rsa_exdata_t {
neverbleed_t *nb;
size_t key_index;
};
struct st_neverbleed_thread_data_t {
pid_t self_pid;
int fd;
};
static void warnvf(const char *fmt, va_list args)
{
char errbuf[256];
if (errno != 0) {
strerror_r(errno, errbuf, sizeof(errbuf));
} else {
errbuf[0] = '\0';
}
fprintf(stderr, "[openssl-privsep] ");
vfprintf(stderr, fmt, args);
if (errbuf[0] != '\0')
fputs(errbuf, stderr);
fputc('\n', stderr);
}
__attribute__((format(printf, 1, 2))) static void warnf(const char *fmt, ...)
{
va_list args;
va_start(args, fmt);
warnvf(fmt, args);
va_end(args);
}
__attribute__((format(printf, 1, 2), noreturn)) static void dief(const char *fmt, ...)
{
va_list args;
va_start(args, fmt);
warnvf(fmt, args);
va_end(args);
abort();
}
static char *dirname(const char *path)
{
const char *last_slash = strrchr(path, '/');
char *ret;
if (last_slash == NULL) {
errno = 0;
dief("dirname: no slash in given path:%s", path);
}
if ((ret = (char *)malloc(last_slash + 1 - path)) == NULL)
dief("no memory");
memcpy(ret, path, last_slash - path);
ret[last_slash - path] = '\0';
return ret;
}
static void set_cloexec(int fd)
{
if (fcntl(fd, F_SETFD, O_CLOEXEC) == -1)
dief("failed to set O_CLOEXEC to fd %d", fd);
}
static int read_nbytes(int fd, void *p, size_t sz)
{
while (sz != 0) {
ssize_t r;
while ((r = read(fd, p, sz)) == -1 && errno == EINTR)
;
if (r == -1) {
return -1;
} else if (r == 0) {
errno = 0;
return -1;
}
p = (char *)p + r;
sz -= r;
}
return 0;
}
static size_t expbuf_size(struct expbuf_t *buf)
{
return buf->end - buf->start;
}
static void expbuf_dispose(struct expbuf_t *buf)
{
if (buf->capacity != 0)
OPENSSL_cleanse(buf->buf, buf->capacity);
free(buf->buf);
memset(buf, 0, sizeof(*buf));
}
static void expbuf_reserve(struct expbuf_t *buf, size_t extra)
{
char *n;
if (extra <= size_t(buf->buf + buf->capacity - buf->end))
return;
if (buf->capacity == 0)
buf->capacity = 4096;
while (size_t(buf->buf + buf->capacity - buf->end) < extra)
buf->capacity *= 2;
if ((n = (char *)realloc(buf->buf, buf->capacity)) == NULL)
dief("realloc failed");
buf->start += n - buf->buf;
buf->end += n - buf->buf;
buf->buf = n;
}
static void expbuf_push_num(struct expbuf_t *buf, size_t v)
{
expbuf_reserve(buf, sizeof(v));
memcpy(buf->end, &v, sizeof(v));
buf->end += sizeof(v);
}
static void expbuf_push_str(struct expbuf_t *buf, const char *s)
{
size_t l = strlen(s) + 1;
expbuf_reserve(buf, l);
memcpy(buf->end, s, l);
buf->end += l;
}
static void expbuf_push_bytes(struct expbuf_t *buf, const void *p, size_t l)
{
expbuf_push_num(buf, l);
expbuf_reserve(buf, l);
memcpy(buf->end, p, l);
buf->end += l;
}
static int expbuf_shift_num(struct expbuf_t *buf, size_t *v)
{
if (expbuf_size(buf) < sizeof(*v))
return -1;
memcpy(v, buf->start, sizeof(*v));
buf->start += sizeof(*v);
return 0;
}
static char *expbuf_shift_str(struct expbuf_t *buf)
{
char *nul = (char *)memchr(buf->start, '\0', expbuf_size(buf)), *ret;
if (nul == NULL)
return NULL;
ret = buf->start;
buf->start = nul + 1;
return ret;
}
static void *expbuf_shift_bytes(struct expbuf_t *buf, size_t *l)
{
void *ret;
if (expbuf_shift_num(buf, l) != 0)
return NULL;
if (expbuf_size(buf) < *l)
return NULL;
ret = buf->start;
buf->start += *l;
return ret;
}
static int expbuf_write(struct expbuf_t *buf, int fd)
{
struct iovec vecs[2] = {};
size_t bufsz = expbuf_size(buf);
int vecindex;
ssize_t r;
vecs[0].iov_base = &bufsz;
vecs[0].iov_len = sizeof(bufsz);
vecs[1].iov_base = buf->start;
vecs[1].iov_len = bufsz;
for (vecindex = 0; vecindex != sizeof(vecs) / sizeof(vecs[0]);) {
while ((r = writev(fd, vecs + vecindex, sizeof(vecs) / sizeof(vecs[0]) - vecindex)) == -1 && errno == EINTR)
;
if (r == -1)
return -1;
assert(r != 0);
while (r != 0 && size_t(r) >= vecs[vecindex].iov_len) {
r -= vecs[vecindex].iov_len;
++vecindex;
}
if (r != 0) {
vecs[vecindex].iov_base = ((char*)vecs[vecindex].iov_base) + r;
vecs[vecindex].iov_len -= r;
}
}
return 0;
}
static int expbuf_read(struct expbuf_t *buf, int fd)
{
size_t sz;
if (read_nbytes(fd, &sz, sizeof(sz)) != 0)
return -1;
expbuf_reserve(buf, sz);
if (read_nbytes(fd, buf->end, sz) != 0)
return -1;
buf->end += sz;
return 0;
}
static void unlink_dir(const char *path)
{
DIR *dp;
char buf[PATH_MAX];
if ((dp = opendir(path)) != NULL) {
struct dirent entbuf, *entp;
while (readdir_r(dp, &entbuf, &entp) == 0 && entp != NULL) {
if (strcmp(entp->d_name, ".") == 0 || strcmp(entp->d_name, "..") == 0)
continue;
snprintf(buf, sizeof(buf), "%s/%s", path, entp->d_name);
unlink_dir(buf);
}
closedir(dp);
}
unlink(path);
rmdir(path);
}
void dispose_thread_data(void *_thdata)
{
auto thdata = (struct st_neverbleed_thread_data_t *)_thdata;
assert(thdata->fd >= 0);
close(thdata->fd);
thdata->fd = -1;
}
struct st_neverbleed_thread_data_t *get_thread_data(neverbleed_t *nb)
{
struct st_neverbleed_thread_data_t *thdata;
pid_t self_pid = getpid();
ssize_t r;
if ((thdata = (st_neverbleed_thread_data_t *)pthread_getspecific(nb->thread_key)) != NULL) {
if (thdata->self_pid == self_pid)
return thdata;
/* we have been forked! */
close(thdata->fd);
} else {
if ((thdata = (st_neverbleed_thread_data_t *)malloc(sizeof(*thdata))) == NULL)
dief("malloc failed");
}
thdata->self_pid = self_pid;
#ifdef SOCK_CLOEXEC
if ((thdata->fd = socket(PF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0)) == -1)
dief("socket(2) failed");
#else
if ((thdata->fd = socket(PF_UNIX, SOCK_STREAM, 0)) == -1)
dief("socket(2) failed");
set_cloexec(thdata->fd);
#endif
while (connect(thdata->fd, (sockaddr *)&nb->sun_, sizeof(nb->sun_)) != 0)
if (errno != EINTR)
dief("failed to connect to privsep daemon");
while ((r = write(thdata->fd, nb->auth_token, sizeof(nb->auth_token))) == -1 && errno == EINTR)
;
if (r != sizeof(nb->auth_token))
dief("failed to send authentication token");
pthread_setspecific(nb->thread_key, thdata);
return thdata;
}
static void get_privsep_data(const RSA *rsa, struct st_neverbleed_rsa_exdata_t **exdata,
struct st_neverbleed_thread_data_t **thdata)
{
*exdata = (struct st_neverbleed_rsa_exdata_t *)RSA_get_ex_data(rsa, 0);
if (*exdata == NULL) {
errno = 0;
dief("invalid internal ref");
}
*thdata = get_thread_data((*exdata)->nb);
}
static struct {
struct {
pthread_mutex_t lock;
size_t size;
RSA **keys;
} keys;
neverbleed_t *nb;
} daemon_vars = {{PTHREAD_MUTEX_INITIALIZER}};
static RSA *daemon_get_rsa(size_t key_index)
{
RSA *rsa;
pthread_mutex_lock(&daemon_vars.keys.lock);
rsa = daemon_vars.keys.keys[key_index];
pthread_mutex_unlock(&daemon_vars.keys.lock);
return rsa;
}
static size_t daemon_set_rsa(RSA *rsa)
{
size_t index;
pthread_mutex_lock(&daemon_vars.keys.lock);
if ((daemon_vars.keys.keys = (RSA **)realloc(daemon_vars.keys.keys, sizeof(*daemon_vars.keys.keys) * (daemon_vars.keys.size + 1))) ==
NULL)
dief("no memory");
index = daemon_vars.keys.size++;
daemon_vars.keys.keys[index] = rsa;
RSA_up_ref(rsa);
pthread_mutex_unlock(&daemon_vars.keys.lock);
return index;
}
static int priv_encdec_proxy(const char *cmd, int flen, const unsigned char *from, unsigned char *_to, RSA *rsa, int padding)
{
struct st_neverbleed_rsa_exdata_t *exdata;
struct st_neverbleed_thread_data_t *thdata;
struct expbuf_t buf = {};
size_t ret;
unsigned char *to;
size_t tolen;
get_privsep_data(rsa, &exdata, &thdata);
expbuf_push_str(&buf, cmd);
expbuf_push_bytes(&buf, from, flen);
expbuf_push_num(&buf, exdata->key_index);
expbuf_push_num(&buf, padding);
if (expbuf_write(&buf, thdata->fd) != 0)
dief(errno != 0 ? "write error" : "connection closed by daemon");
expbuf_dispose(&buf);
if (expbuf_read(&buf, thdata->fd) != 0)
dief(errno != 0 ? "read error" : "connection closed by daemon");
if (expbuf_shift_num(&buf, &ret) != 0 || (to = (unsigned char*)expbuf_shift_bytes(&buf, &tolen)) == NULL) {
errno = 0;
dief("failed to parse response");
}
memcpy(_to, to, tolen);
expbuf_dispose(&buf);
return (int)ret;
}
static int priv_encdec_stub(const char *name,
int (*func)(int flen, const unsigned char *from, unsigned char *to, RSA *rsa, int padding),
struct expbuf_t *buf)
{
unsigned char *from, to[4096];
size_t flen;
size_t key_index, padding;
RSA *rsa;
int ret;
if ((from = (unsigned char*)expbuf_shift_bytes(buf, &flen)) == NULL || expbuf_shift_num(buf, &key_index) != 0 ||
expbuf_shift_num(buf, &padding) != 0) {
errno = 0;
warnf("%s: failed to parse request", name);
return -1;
}
if ((rsa = daemon_get_rsa(key_index)) == NULL) {
errno = 0;
warnf("%s: invalid key index:%zu\n", name, key_index);
return -1;
}
ret = func((int)flen, from, to, rsa, (int)padding);
expbuf_dispose(buf);
expbuf_push_num(buf, ret);
expbuf_push_bytes(buf, to, ret > 0 ? ret : 0);
return 0;
}
static int priv_enc_proxy(int flen, const unsigned char *from, unsigned char *to, RSA *rsa, int padding)
{
return priv_encdec_proxy("priv_enc", flen, from, to, rsa, padding);
}
static int priv_enc_stub(struct expbuf_t *buf)
{
return priv_encdec_stub(__FUNCTION__, RSA_private_encrypt, buf);
}
static int priv_dec_proxy(int flen, const unsigned char *from, unsigned char *to, RSA *rsa, int padding)
{
return priv_encdec_proxy("priv_dec", flen, from, to, rsa, padding);
}
static int priv_dec_stub(struct expbuf_t *buf)
{
return priv_encdec_stub(__FUNCTION__, RSA_private_decrypt, buf);
}
static int sign_proxy(int type, const unsigned char *m, unsigned int m_len, unsigned char *_sigret, unsigned *_siglen,
const RSA *rsa)
{
struct st_neverbleed_rsa_exdata_t *exdata;
struct st_neverbleed_thread_data_t *thdata;
struct expbuf_t buf = {};
size_t ret, siglen;
unsigned char *sigret;
get_privsep_data(rsa, &exdata, &thdata);
expbuf_push_str(&buf, "sign");
expbuf_push_num(&buf, type);
expbuf_push_bytes(&buf, m, m_len);
expbuf_push_num(&buf, exdata->key_index);
if (expbuf_write(&buf, thdata->fd) != 0)
dief(errno != 0 ? "write error" : "connection closed by daemon");
expbuf_dispose(&buf);
if (expbuf_read(&buf, thdata->fd) != 0)
dief(errno != 0 ? "read error" : "connection closed by daemon");
if (expbuf_shift_num(&buf, &ret) != 0 || (sigret = (unsigned char*)expbuf_shift_bytes(&buf, &siglen)) == NULL) {
errno = 0;
dief("failed to parse response");
}
memcpy(_sigret, sigret, siglen);
*_siglen = (unsigned)siglen;
expbuf_dispose(&buf);
return (int)ret;
}
static int sign_stub(struct expbuf_t *buf)
{
unsigned char *m, sigret[4096];
size_t type, m_len, key_index;
RSA *rsa;
unsigned siglen = 0;
int ret;
if (expbuf_shift_num(buf, &type) != 0 || (m = (unsigned char*)expbuf_shift_bytes(buf, &m_len)) == NULL ||
expbuf_shift_num(buf, &key_index) != 0) {
errno = 0;
warnf("%s: failed to parse request", __FUNCTION__);
return -1;
}
if ((rsa = daemon_get_rsa(key_index)) == NULL) {
errno = 0;
warnf("%s: invalid key index:%zu", __FUNCTION__, key_index);
return -1;
}
ret = RSA_sign((int)type, m, (unsigned)m_len, sigret, &siglen, rsa);
expbuf_dispose(buf);
expbuf_push_num(buf, ret);
expbuf_push_bytes(buf, sigret, ret == 1 ? siglen : 0);
return 0;
}
static EVP_PKEY *create_pkey(neverbleed_t *nb, size_t key_index, const char *ebuf, const char *nbuf)
{
struct st_neverbleed_rsa_exdata_t *exdata;
RSA *rsa;
EVP_PKEY *pkey;
if ((exdata = (st_neverbleed_rsa_exdata_t *)malloc(sizeof(*exdata))) == NULL) {
fprintf(stderr, "no memory\n");
abort();
}
exdata->nb = nb;
exdata->key_index = key_index;
rsa = RSA_new_method(nb->engine);
RSA_set_ex_data(rsa, 0, exdata);
if (BN_hex2bn(&rsa->e, ebuf) == 0) {
fprintf(stderr, "failed to parse e:%s\n", ebuf);
abort();
}
if (BN_hex2bn(&rsa->n, nbuf) == 0) {
fprintf(stderr, "failed to parse n:%s\n", nbuf);
abort();
}
rsa->flags |= RSA_FLAG_EXT_PKEY;
pkey = EVP_PKEY_new();
EVP_PKEY_set1_RSA(pkey, rsa);
RSA_free(rsa);
return pkey;
}
int neverbleed_load_private_key_file(neverbleed_t *nb, SSL_CTX *ctx, const char *fn, char *errbuf)
{
struct st_neverbleed_thread_data_t *thdata = get_thread_data(nb);
struct expbuf_t buf = {};
size_t ret, key_index;
char *estr, *nstr, *errstr;
EVP_PKEY *pkey;
expbuf_push_str(&buf, "load_key");
expbuf_push_str(&buf, fn);
if (expbuf_write(&buf, thdata->fd) != 0)
dief(errno != 0 ? "write error" : "connection closed by daemon");
expbuf_dispose(&buf);
if (expbuf_read(&buf, thdata->fd) != 0)
dief(errno != 0 ? "read error" : "connection closed by daemon");
if (expbuf_shift_num(&buf, &ret) != 0 || expbuf_shift_num(&buf, &key_index) != 0 || (estr = expbuf_shift_str(&buf)) == NULL ||
(nstr = expbuf_shift_str(&buf)) == NULL || (errstr = expbuf_shift_str(&buf)) == NULL) {
errno = 0;
dief("failed to parse response");
}
if (ret != 1) {
snprintf(errbuf, NEVERBLEED_ERRBUF_SIZE, "%s", errstr);
return -1;
}
/* success */
pkey = create_pkey(nb, key_index, estr, nstr);
if (SSL_CTX_use_PrivateKey(ctx, pkey) != 1) {
snprintf(errbuf, NEVERBLEED_ERRBUF_SIZE, "SSL_CTX_use_PrivateKey failed");
ret = 0;
}
EVP_PKEY_free(pkey);
return (int)ret;
}
static int load_key_stub(struct expbuf_t *buf)
{
char *fn;
FILE *fp = NULL;
RSA *rsa = NULL;
size_t key_index = SIZE_MAX;
char *estr = NULL, *nstr = NULL, errbuf[NEVERBLEED_ERRBUF_SIZE] = "";
if ((fn = expbuf_shift_str(buf)) == NULL) {
warnf("%s: failed to parse request", __FUNCTION__);
return -1;
}
if ((fp = fopen(fn, "rt")) == NULL) {
strerror_r(errno, errbuf, sizeof(errbuf));
goto Respond;
}
if ((rsa = PEM_read_RSAPrivateKey(fp, NULL, NULL, NULL)) == NULL) {
snprintf(errbuf, sizeof(errbuf), "failed to parse the private key");
goto Respond;
}
key_index = daemon_set_rsa(rsa);
estr = BN_bn2hex(rsa->e);
nstr = BN_bn2hex(rsa->n);
Respond:
expbuf_dispose(buf);
expbuf_push_num(buf, rsa != NULL);
expbuf_push_num(buf, key_index);
expbuf_push_str(buf, estr != NULL ? estr : "");
expbuf_push_str(buf, nstr != NULL ? nstr : "");
expbuf_push_str(buf, errbuf);
if (rsa != NULL)
RSA_free(rsa);
if (estr != NULL)
OPENSSL_free(estr);
if (nstr != NULL)
OPENSSL_free(nstr);
if (fp != NULL)
fclose(fp);
return 0;
}
int neverbleed_setuidgid(neverbleed_t *nb, const char *user, int change_socket_ownership)
{
struct st_neverbleed_thread_data_t *thdata = get_thread_data(nb);
struct expbuf_t buf = {};
size_t ret;
expbuf_push_str(&buf, "setuidgid");
expbuf_push_str(&buf, user);
expbuf_push_num(&buf, change_socket_ownership);
if (expbuf_write(&buf, thdata->fd) != 0)
dief(errno != 0 ? "write error" : "connection closed by daemon");
expbuf_dispose(&buf);
if (expbuf_read(&buf, thdata->fd) != 0)
dief(errno != 0 ? "read error" : "connection closed by daemon");
if (expbuf_shift_num(&buf, &ret) != 0) {
errno = 0;
dief("failed to parse response");
}
expbuf_dispose(&buf);
return (int)ret;
}
static int setuidgid_stub(struct expbuf_t *buf)
{
const char *user;
size_t change_socket_ownership;
struct passwd pwbuf, *pw;
char pwstrbuf[65536]; /* should be large enough */
int ret = -1;
if ((user = expbuf_shift_str(buf)) == NULL || expbuf_shift_num(buf, &change_socket_ownership) != 0) {
errno = 0;
warnf("%s: failed to parse request", __FUNCTION__);
return -1;
}
errno = 0;
if (getpwnam_r(user, &pwbuf, pwstrbuf, sizeof(pwstrbuf), &pw) != 0) {
warnf("%s: getpwnam_r failed", __FUNCTION__);
goto Respond;
}
if (pw == NULL) {
warnf("%s: failed to obtain information of user:%s", __FUNCTION__, user);
goto Respond;
}
if (change_socket_ownership) {
char *dir;
if (chown(daemon_vars.nb->sun_.sun_path, pw->pw_uid, pw->pw_gid) != 0)
dief("chown failed for:%s", daemon_vars.nb->sun_.sun_path);
dir = dirname(daemon_vars.nb->sun_.sun_path);
if (chown(dir, pw->pw_uid, pw->pw_gid) != 0)
dief("chown failed for:%s", dir);
free(dir);
}
/* setuidgid */
if (setgid(pw->pw_gid) != 0) {
warnf("%s: setgid(%d) failed", __FUNCTION__, (int)pw->pw_gid);
goto Respond;
}
if (initgroups(pw->pw_name, pw->pw_gid) != 0) {
warnf("%s: initgroups(%s, %d) failed", __FUNCTION__, pw->pw_name, (int)pw->pw_gid);
goto Respond;
}
if (setuid(pw->pw_uid) != 0) {
warnf("%s: setuid(%d) failed\n", __FUNCTION__, (int)pw->pw_uid);
goto Respond;
}
ret = 0;
Respond:
expbuf_dispose(buf);
expbuf_push_num(buf, ret);
return 0;
}
__attribute__((noreturn)) static void *daemon_close_notify_thread(void *_close_notify_fd)
{
int close_notify_fd = (int)((char *)_close_notify_fd - (char *)NULL);
char b;
ssize_t r;
Redo:
r = read(close_notify_fd, &b, 1);
if (r == -1 && errno == EINTR)
goto Redo;
if (r > 0)
goto Redo;
/* close or error */
/* unlink the temporary directory and socket file */
unlink_dir(dirname(daemon_vars.nb->sun_.sun_path));
_exit(0);
}
static void *daemon_conn_thread(void *_sock_fd)
{
int sock_fd = (int)((char *)_sock_fd - (char *)NULL);
struct expbuf_t buf = {};
unsigned char auth_token[NEVERBLEED_AUTH_TOKEN_SIZE];
/* authenticate */
if (read_nbytes(sock_fd, &auth_token, sizeof(auth_token)) != 0) {
warnf("failed to receive authencication token from client");
goto Exit;
}
if (memcmp(auth_token, daemon_vars.nb->auth_token, NEVERBLEED_AUTH_TOKEN_SIZE) != 0) {
warnf("client authentication failed");
goto Exit;
}
while (1) {
char *cmd;
if (expbuf_read(&buf, sock_fd) != 0) {
if (errno != 0)
warnf("read error");
break;
}
if ((cmd = expbuf_shift_str(&buf)) == NULL) {
errno = 0;
warnf("failed to parse request");
break;
}
if (strcmp(cmd, "priv_enc") == 0) {
if (priv_enc_stub(&buf) != 0)
break;
} else if (strcmp(cmd, "priv_dec") == 0) {
if (priv_dec_stub(&buf) != 0)
break;
} else if (strcmp(cmd, "sign") == 0) {
if (sign_stub(&buf) != 0)
break;
} else if (strcmp(cmd, "load_key") == 0) {
if (load_key_stub(&buf) != 0)
break;
} else if (strcmp(cmd, "setuidgid") == 0) {
if (setuidgid_stub(&buf) != 0)
break;
} else {
warnf("unknown command:%s", cmd);
break;
}
if (expbuf_write(&buf, sock_fd) != 0) {
warnf(errno != 0 ? "write error" : "connection closed by client");
break;
}
expbuf_dispose(&buf);
}
Exit:
expbuf_dispose(&buf);
close(sock_fd);
return NULL;
}
__attribute__((noreturn)) static void daemon_main(int listen_fd, int close_notify_fd, const char *tempdir)
{
pthread_t tid;
pthread_attr_t thattr;
int sock_fd;
{ /* close all descriptors (except STDIN, STDOUT, STRERR, listen_fd, close_notify_fd) */
int fd = (int)sysconf(_SC_OPEN_MAX) - 1;
for (; fd > 2; --fd) {
if (fd == listen_fd || fd == close_notify_fd)
continue;
close(fd);
}
}
pthread_attr_init(&thattr);
pthread_attr_setdetachstate(&thattr, 1);
if (pthread_create(&tid, &thattr, daemon_close_notify_thread, (char *)NULL + close_notify_fd) != 0)
dief("pthread_create failed");
while (1) {
while ((sock_fd = accept(listen_fd, NULL, NULL)) == -1)
;
if (pthread_create(&tid, &thattr, daemon_conn_thread, (char *)NULL + sock_fd) != 0)
dief("pthread_create failed");
}
}
static RSA_METHOD rsa_method = {
"privsep RSA method", /* name */
NULL, /* rsa_pub_enc */
NULL, /* rsa_pub_dec */
priv_enc_proxy, /* rsa_priv_enc */
priv_dec_proxy, /* rsa_priv_dec */
NULL, /* rsa_mod_exp */
NULL, /* bn_mod_exp */
NULL, /* init */
NULL, /* finish */
RSA_FLAG_SIGN_VER, /* flags */
NULL, /* app data */
sign_proxy, /* rsa_sign */
NULL, /* rsa_verify */
NULL /* rsa_keygen */
};
int neverbleed_init(neverbleed_t *nb, char *errbuf)
{
int pipe_fds[2] = {-1, -1}, listen_fd = -1;
char *tempdir = NULL;
const RSA_METHOD *default_method = RSA_PKCS1_SSLeay();
rsa_method.rsa_pub_enc = default_method->rsa_pub_enc;
rsa_method.rsa_pub_dec = default_method->rsa_pub_dec;
rsa_method.rsa_verify = default_method->rsa_verify;
/* setup the daemon */
if (pipe(pipe_fds) != 0) {
snprintf(errbuf, NEVERBLEED_ERRBUF_SIZE, "pipe(2) failed:%s", strerror(errno));
goto Fail;
}
set_cloexec(pipe_fds[1]);
if ((tempdir = strdup("/tmp/openssl-privsep.XXXXXX")) == NULL) {
snprintf(errbuf, NEVERBLEED_ERRBUF_SIZE, "no memory");
goto Fail;
}
if (mkdtemp(tempdir) == NULL) {
snprintf(errbuf, NEVERBLEED_ERRBUF_SIZE, "failed to create temporary directory under /tmp:%s", strerror(errno));
goto Fail;
}
memset(&nb->sun_, 0, sizeof(nb->sun_));
nb->sun_.sun_family = AF_UNIX;
snprintf(nb->sun_.sun_path, sizeof(nb->sun_.sun_path), "%s/_", tempdir);
RAND_bytes(nb->auth_token, sizeof(nb->auth_token));
if ((listen_fd = socket(PF_UNIX, SOCK_STREAM, 0)) == -1) {
snprintf(errbuf, NEVERBLEED_ERRBUF_SIZE, "socket(2) failed:%s", strerror(errno));
goto Fail;
}
if (bind(listen_fd, (sockaddr *)&nb->sun_, sizeof(nb->sun_)) != 0) {
snprintf(errbuf, NEVERBLEED_ERRBUF_SIZE, "failed to bind to %s:%s", nb->sun_.sun_path, strerror(errno));
goto Fail;
}
if (listen(listen_fd, SOMAXCONN) != 0) {
snprintf(errbuf, NEVERBLEED_ERRBUF_SIZE, "listen(2) failed:%s", strerror(errno));
goto Fail;
}
nb->daemon_pid = fork();
switch (nb->daemon_pid) {
case -1:
snprintf(errbuf, NEVERBLEED_ERRBUF_SIZE, "fork(2) failed:%s", strerror(errno));
goto Fail;
case 0:
close(pipe_fds[1]);
#ifdef __linux__
prctl(PR_SET_DUMPABLE, 0, 0, 0, 0);
#endif
daemon_vars.nb = nb;
daemon_main(listen_fd, pipe_fds[0], tempdir);
break;
default:
break;
}
close(listen_fd);
listen_fd = -1;
close(pipe_fds[0]);
pipe_fds[0] = -1;
/* setup engine */
if ((nb->engine = ENGINE_new()) == NULL || !ENGINE_set_id(nb->engine, "neverbleed") ||
!ENGINE_set_name(nb->engine, "privilege separation software engine") || !ENGINE_set_RSA(nb->engine, &rsa_method)) {
snprintf(errbuf, NEVERBLEED_ERRBUF_SIZE, "failed to initialize the OpenSSL engine");
goto Fail;
}
ENGINE_add(nb->engine);
/* setup thread key */
pthread_key_create(&nb->thread_key, dispose_thread_data);
free(tempdir);
return 0;
Fail:
if (pipe_fds[0] != -1)
close(pipe_fds[0]);
if (pipe_fds[1] != -1)
close(pipe_fds[1]);
if (tempdir != NULL) {
unlink_dir(tempdir);
free(tempdir);
}
if (listen_fd != -1)
close(listen_fd);
if (nb->engine != NULL) {
ENGINE_free(nb->engine);
nb->engine = NULL;
}
return -1;
}
| 28.912997 | 137 | 0.595921 |
aeddaa569142c7e1111fd106509b7d4011923c01 | 10,935 | h | C | src/structures.h | Argonne-National-Laboratory/ENPEP-windows | c74836cdd2ec1e6ecb1bf53b84729c02f75f6364 | [
"BSD-3-Clause"
] | null | null | null | src/structures.h | Argonne-National-Laboratory/ENPEP-windows | c74836cdd2ec1e6ecb1bf53b84729c02f75f6364 | [
"BSD-3-Clause"
] | null | null | null | src/structures.h | Argonne-National-Laboratory/ENPEP-windows | c74836cdd2ec1e6ecb1bf53b84729c02f75f6364 | [
"BSD-3-Clause"
] | null | null | null | /*******************************************************************
COPYRIGHT NOTIFICATION
********************************************************************
Copyright © 2021, UChicago Argonne, LLC
All Rights Reserved
Software Name: ENPEP- Balance
By: Argonne National Laboratory
OPEN SOURCE LICENSE
********************************************************************
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.
********************************************************************
DISCLAIMER
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.
********************************************************************
*/
struct {
char unitcode[16][50];
char unitname[16][50];
float unitcnvt[16];
} units_;
#define units_1 units_
struct {
integer laby[75];
} outwr_;
#define outwr_1 outwr_
struct {
integer lwrit[75], itelf[75], itell[75], iecho, ieech, ifinl;
} el1_;
#define el1_1 el1_
struct {
integer itn, itmax, ntime, nper;
real rctol, epsn;
integer iwr1, nnrep, nnrnp, nnpr, iers, ires, lnkmx, nrsmx;
real whi, wlo, actol;
integer nrnmx;
real shr[4000] /* was [200][10] */;
integer nprmx, idmp[75], iyrb, itime, nnall, nnre, nnde, nnlnk, nnst,nnmi;
real qscale;
char qu[15], pu[15];
} var_;
#define var_1 var_
struct {
integer ninal[400], iinal[4000] /* was [200][10] */, noual[400],
ioual[4000] /* was [200][10] */;
real gm[400], bl[400], split[4000] /* was [200][10] */;
integer nalpr[400], ialpr[4000]; /* was [200][10] */
char cmc_laba[400][20];
real rms[4000] /* was [200][10] */, oms[4000] /* was [200][10] */,
oquan, poquan[400];
} all_;
#define all_1 all_
struct {
integer ngg[400];
} al1_;
#define al1_1 al1_
struct {
integer iwre, nunit, nuse[300], kuse[300];
real qunit[22500] /* was [75][300] */;
integer noperat[22500] /* was [75][300] */;
real Efactors[300][50][3]; /* 300 nodes, 50 pollutants, and 3 factors namely
emission factor, scale value, emission tax */
} elec_;
#define elec_1 elec_
struct {
real q[999], p[999], capl[999];
integer lab[5], iuse[300], luse[999];
real noTaxPrice[999];
} net_;
#define net_1 net_
struct {
integer iours[75];
real qt[92], hqt[92], hqtm[92], qtm[92], a[75], b[75];
/* integer labr[375]; /* was [75][5] */
char cmc_labr[75][30];
real pprj[5625] /* was [75][75] */;
integer kpr[75];
real plast[75], ab[75];
real Efactors[75][50][3]; /* 75 nodes, 50 pollutants, and 3 factors namely
emission factor, scale value, emission tax */
real noTaxPrice[75][75];
real fuelCost[75][75];
real economicRent[75][75];
real cumulativeQ[75][75];
} res_;
#define res_1 res_
struct {
integer ndemx, iinde[200];
char cmc_labd[200][20];
real drat[15000] /* was [200][75] */;
integer kd[200];
real qbase[200];
real Efactors[200][50][3]; /* 200 nodes, 50 pollutants, and 3 factors namely
emission factor, scale value, emission tax */
} dem_;
#define dem_1 dem_
struct {
/* increase arry size from 100 to 300 */
real alpha[300], delta[300], pmax[300], pmin[300];
integer iinpp[300];
real pscale;
integer ioupp[300];
char cmc_labp[300][20];
real sen[1500], /* was [20][75]; sen is related stock pile rather than pricing node */
zen[149850] /* was [2][999][75]; zen is used to store p and q values for all links */
;
integer ioutx;
integer linkp[300];
} pri_;
#define pri_1 pri_
struct {
integer iinpr[300], ioupr[300];
real om[300], cc[300], eff[300], tci[300], capm[300], cf[300];
integer life[300];
real rir[300];
char cmc_labc[300][20];
real Efactors[300][50][3]; /* 300 nodes, 50 pollutants, and 3 factors namely
emission factor, scale value, emission tax */
integer baseYearLife[300] ;
real baseYearCap[300];
real baseYearCapital[300];
integer opUnits[300][75];
real opCap[300][75];
integer baseUnits[300][75];
real baseCap[300][75];
real baseSunk[300][75];
integer existingUnits[300][75];
real existingCap[300][75];
real existingSunk[300][75];
real demandNotServed[300][75];
integer newUnits[300][75];
real newCap[300][75];
real newCapital[300][75];
real operatingCost[300][75];
real totalCapital[300][75];
real avgInvestment[300][75];
real avgCap[300][75];
real avgCF[300][75];
real outputCapability[300][75];
} pro_;
#define pro_1 pro_
struct {
/* MI Nodes have been increased from 15 to 200 */
integer ninmi[200], iinmi[1000] /* was [15][5] */, ioumi[200];
real omm[200], ccm[200], rio[1000] /* was [15][5] */, tcim[200], capmm[200], cfm[200];
integer lifem[200];
real rirm[200];
char cmc_labm[201][30]; /* was [15][20] changed to [16][30] - Prakash */
real prem[4000] /* was [200][10] */;
integer nremx, nmimx;
real Efactors[200][50][3]; /* 200 nodes, 50 pollutants, and 3 factors namely
emission factor, scale value, emission tax */
integer baseYearLife[200] ;
real baseYearCap[200];
real baseYearCapital[200];
integer opUnits[200][75];
real opCap[200][75];
integer baseUnits[200][75];
real baseCap[200][75];
real baseSunk[200][75];
integer existingUnits[200][75];
real existingCap[200][75];
real existingSunk[200][75];
real demandNotServed[200][75];
integer newUnits[200][75];
real newCap[200][75];
real newCapital[200][75];
real operatingCost[200][75];
real totalCapital[200][75];
real avgInvestment[200][75];
real avgCap[200][75];
real avgCF[200][75];
real outputCapability[200][75];
} min_;
#define min_1 min_
struct {
integer ninre[30], iinre[60] /* was [30][2] */, noure[30], ioure[
180] /* was [30][6] */, istck[180] /* was [30][6] */;
real pff[30];
integer ixces[180] /* was [30][6] */;
real slate[180] /* was [30][6] */, omr[30], ccr[30], prat[180] /*
was [30][6] */;
integer iordc[30];
real tcir[30], capmr[30], cfr[30];
integer lifer[30];
real rirr[30];
char cmc_labe[30][20];
real remul[180] /* was [30][6] */;
integer icntl[180] /* was [30][6] */, linpr[180] /* was [30][6] */;
real Efactors[30][50][3]; /* 30 nodes, 50 pollutants, and 3 factors namely
emission factor, scale value, emission tax */
integer baseYearLife[30] ;
real baseYearCap[30];
real baseYearCapital[30];
integer opUnits[30][75];
real opCap[30][75];
integer baseUnits[30][75];
real baseCap[30][75];
real baseSunk[30][75];
integer existingUnits[30][75];
real existingCap[30][75];
real existingSunk[30][75];
real demandNotServed[30][75];
integer newUnits[30][75];
real newCap[30][75];
real newCapital[30][75];
real operatingCost[30][75];
real totalCapital[30][75];
real avgInvestment[30][75];
real avgCap[30][75];
real avgCF[30][75];
real outputCapability[30][75];
} ref_;
#define ref_1 ref_
struct {
integer iourn[17];
real prn[85] /* was [17][5] */, qrn[85] /* was [17][5] */;
integer nstep[17];
char cmc_labn[17][20];
real rlim[17];
integer mup[17], jwrit[75], itfir[75], itlas[75];
char ititl[6][256]; /* was integer changed to char -Prakash */
real Efactors[17][50][3]; /* 17 nodes, 50 pollutants, and 3 factors namely
emission factor, scale value, emission tax */
real economicRent[17][75];
real fuelCost[17][75];
real noTaxPrice[17][75];
} ren_;
#define ren_1 ren_
struct {
integer ioust[20];
real stok[20], st[20];
char cmc_labs[20][20];
integer ialst[400], istc[20], istkexl[20];
real stkexr[20];
} stk_;
#define stk_1 stk_
struct {
integer ireson, ilod, iele, imp;
real boemwh, boembtu;
} mode_;
#define mode_1 mode_
struct {
integer mab[5];
real xldci[104] /* was [52][2] */, cap[300], varct[300], temp[300];
integer isun[300], iunit[300], iinlk[300], ioulk[300];
real htrt[300];
integer labe[1500] /* was [300][5] */;
integer labf[1500] /* was [300][5] */;
/* CMC ERROR? added labf */
real oma[300], omb[300], forc[300], dmain[300], capc[300];
integer iyrf[300], iyrr[300], iinel[40], ioupl[80];
real umin[300];
/* CMC added iblanklov and optionallov below */
integer iblanklov[300];
real optionallov[300];
char unitname[300][9]; /* added by Prakash */
real basecap[300]; /* added by Prakash - cap is being overwritten by derated cap */
int unitype[300]; /* added by Prakash - to keep track of unit type in calculating emissions */
real baseCapital[300];
real generation[300];
} elec1_;
#define elec1_1 elec1_
struct {
integer ispeclov[300];
real optionallov[300], xmlod, xlfac;
} elec4_;
#define elec4_1 elec4_
struct {
integer ic1[135], ic2[135], ic3[135];
real rc4[135], rc5[135], rc6[135], rc7[135], rc8[135], rc9[135], rc10[135];
integer ic11[135], ic12[135];
real rc11[135]; /* changed all array sizes from 50 to 135 - Prakash */
integer labv[135] /* was [50][5] */;
char unitname[300][9]; /* added by Prakash */
} elec2_;
#define elec2_1 elec2_
struct {
real peakf, rire;
integer ninel, noupl;
real qiouel;
integer munit;
} elec3_;
#define elec3_1 elec3_
struct {
int unitnumber[300];
char unitname[300][9];
int unittype[300];
} elec5_;
#define elec5_1 elec5_
struct {
real agenr[75], aload[75];
integer iouel;
} toload_;
#define toload_1 toload_
struct {
/* char nodel[7992] was [2][999] */
char nodel[3][999][5]; /* c-ified nodel[up=1|down=2][999][4-char] */
integer numb[1998] /* was [2][999] */, ispec[1998] /* was [2][999] */,
labw[1000] /* was [2][100][5] */, kup, kdwn, ielecs;
} invis_;
#define invis_1 invis_
struct {
real qnt[92], caplimp[999];
} saveimp_;
#define saveimp_1 saveimp_
| 28.18299 | 755 | 0.639963 |
aeddc91bf40bec43a05939f0a3ad4d49ef5b482f | 5,161 | h | C | Source/USemLog/Classes/Viz/SLVizStructs.h | hawkina/USemLog | d2a1fc2fdf70c4054d71c89f50628df357a83956 | [
"BSD-3-Clause"
] | null | null | null | Source/USemLog/Classes/Viz/SLVizStructs.h | hawkina/USemLog | d2a1fc2fdf70c4054d71c89f50628df357a83956 | [
"BSD-3-Clause"
] | null | null | null | Source/USemLog/Classes/Viz/SLVizStructs.h | hawkina/USemLog | d2a1fc2fdf70c4054d71c89f50628df357a83956 | [
"BSD-3-Clause"
] | null | null | null | // Copyright 2017-2020, Institute for Artificial Intelligence - University of Bremen
// Author: Andrei Haidu (http://haidu.eu)
#pragma once
#include "CoreMinimal.h"
#include "SLVizStructs.generated.h"
// Forward declarations
class UMeshComponent;
/**
* Dynamic material types
*/
UENUM()
enum class ESLVizMaterialType : uint8
{
NONE UMETA(DisplayName = "NONE"),
Lit UMETA(DisplayName = "Lit"),
Unlit UMETA(DisplayName = "Unlit"),
Additive UMETA(DisplayName = "Additive"),
Translucent UMETA(DisplayName = "Translucent")
};
/**
* Viz visual parameters (color and material type)
*/
USTRUCT()
struct FSLVizVisualParams
{
GENERATED_BODY();
// Color to apply to the dynamic material
UPROPERTY(VisibleAnywhere, Category = "Semantic Logger")
FLinearColor Color = FLinearColor::Green;
// Type of dynamic material
UPROPERTY(VisibleAnywhere, Category = "Semantic Logger")
ESLVizMaterialType MaterialType = ESLVizMaterialType::Unlit;
// Material slots to which to apply the visual parameters (if empty, apply to all slots)
UPROPERTY(VisibleAnywhere, Category = "Semantic Logger")
TArray<int32> MaterialSlots;
// Default ctor
FSLVizVisualParams() {};
// Init ctor
FSLVizVisualParams(const FLinearColor& InColor, ESLVizMaterialType InMaterialType, const TArray<int32>& InMaterialSlots)
: Color(InColor), MaterialType(InMaterialType), MaterialSlots(InMaterialSlots) {};
// Init ctor
FSLVizVisualParams(const FLinearColor& InColor, ESLVizMaterialType InMaterialType, int32 InMaterialSlot)
: Color(InColor), MaterialType(InMaterialType), MaterialSlots(TArray<int32>{InMaterialSlot}) {};
// Init ctor
FSLVizVisualParams(const FLinearColor& InColor, ESLVizMaterialType InMaterialType)
: Color(InColor), MaterialType(InMaterialType) {};
// Init ctor
FSLVizVisualParams(const FLinearColor& InColor)
: Color(InColor) {};
// Init ctor
FSLVizVisualParams(const FLinearColor& InColor, const TArray<int32>& InMaterialSlots)
: Color(InColor), MaterialSlots(InMaterialSlots) {};
// Init ctor
FSLVizVisualParams(const FLinearColor& InColor, int32 InMaterialSlot)
: Color(InColor), MaterialSlots(TArray<int32>{InMaterialSlot}) {};
};
/*
* Marker primitive types
*/
UENUM()
enum class ESLVizPrimitiveMarkerType : uint8
{
NONE UMETA(DisplayName = "NONE"),
Box UMETA(DisplayName = "Box"),
Sphere UMETA(DisplayName = "Sphere"),
Cylinder UMETA(DisplayName = "Cylinder"),
Arrow UMETA(DisplayName = "Arrow"),
Axis UMETA(DisplayName = "Axis")
};
/**
* Data about the currently highlighted individuals (mesh, material index)
*/
USTRUCT()
struct FSLVizIndividualHighlightData
{
GENERATED_BODY();
// The mesh that is currently highlighted
UPROPERTY(VisibleAnywhere, Category = "Semantic Logger")
UMeshComponent* MeshComponent = nullptr;
// The mesh slots that are highlighted (empty means all)
UPROPERTY(EditAnywhere, Category = "Semantic Logger")
TArray<int32> MaterialSlots;
// Default ctor
FSLVizIndividualHighlightData() {};
// Init ctor
FSLVizIndividualHighlightData(UMeshComponent* InMeshComponent) : MeshComponent(InMeshComponent) {};
// Init ctor
FSLVizIndividualHighlightData(UMeshComponent* InMeshComponent, int32 InMaterialSlot)
: MeshComponent(InMeshComponent), MaterialSlots(TArray<int32>{InMaterialSlot}) {};
// Init ctor
FSLVizIndividualHighlightData(UMeshComponent* InMeshComponent, const TArray<int32>& InMaterialSlots)
: MeshComponent(InMeshComponent), MaterialSlots(InMaterialSlots) {};
};
/**
* A set of parameters to describe how to replay the episode data
*/
USTRUCT()
struct FSLVizEpisodePlayParams
{
GENERATED_BODY()
// For negative value it will start from first frame
UPROPERTY(EditAnywhere, Category = "Time")
float StartTime = -1.f;
// For negative value it will run until the last frame
UPROPERTY(EditAnywhere, Category = "Time")
float EndTime = -1.f;
// Repeat replay after finishing
UPROPERTY(EditAnywhere, Category = "Properties")
bool bLoop = false;
// How quickly to move to the next frame (if negative, it will calculate an average update rate from the episode data)
UPROPERTY(EditAnywhere, Category = "Properties")
float UpdateRate = -1.f;
// How many steps to update every frame
UPROPERTY(EditAnywhere, Category = "Properties")
int32 StepSize = 1;
// Default ctor
FSLVizEpisodePlayParams() {};
// Init ctor
FSLVizEpisodePlayParams(bool bLoopValue, float InUpdateRate, int32 InStepSize, const FString& InTargetViewId) :
bLoop(bLoopValue),
UpdateRate(InUpdateRate),
StepSize(InStepSize) {}
};
/**
* Parameters for timeline markers
*/
USTRUCT()
struct FSLVizTimelineParams
{
GENERATED_BODY()
// For negative value the duration will be computed
UPROPERTY(EditAnywhere, Category = "Time")
float Duration = -1.f;
// For negative value it will run every tick
UPROPERTY(EditAnywhere, Category = "Time")
float UpdateRate = -1.f;
// Maximum number of instaces to simultaneusly draw (negative values ignored)
UPROPERTY(EditAnywhere, Category = "Properties")
int32 MaxNumInstances = INDEX_NONE;
// Repeat timeline after finishing
UPROPERTY(EditAnywhere, Category = "Properties")
bool bLoop = false;
};
| 28.202186 | 121 | 0.754311 |
aedfb947719c2d191b53e5face4143b610667f12 | 1,687 | c | C | archive/chapter04/ex01_strrindex.c | Chrinkus/k-n-r | 573abfc19a200db4db653c74b15222ed3708a2be | [
"MIT"
] | 1 | 2021-06-14T10:25:39.000Z | 2021-06-14T10:25:39.000Z | archive/chapter04/ex01_strrindex.c | Chrinkus/k-n-r | 573abfc19a200db4db653c74b15222ed3708a2be | [
"MIT"
] | null | null | null | archive/chapter04/ex01_strrindex.c | Chrinkus/k-n-r | 573abfc19a200db4db653c74b15222ed3708a2be | [
"MIT"
] | null | null | null | /*
* Exercise 4-1
*
* Write the function strrindex(s,t), which returns the position of the
* rightmost occurrence of t in s, or -1 if there is none.
*/
#include <stdio.h>
#include <string.h>
#define MAXLINE 1000 /* maximum input line length */
int my_getline(char line[], int max);
int strindex(char source[], char searchfor[]);
int strrindex(char source[], char searchfor[]);
char pattern[] = "ould"; /* pattern to search for */
char pattern2[] = "ea"; /* multi-occurence pattern */
/* find all lines matching pattern */
int main()
{
char line[MAXLINE];
int found = 0;
int i;
while (my_getline(line, MAXLINE) > 0)
if ((i = strrindex(line, pattern2)) >= 0) {
printf("%d\t: %s", i, line);
found++;
}
return found;
}
/* my_getline: get line into s, return length */
int my_getline(char s[], int lim)
{
int c, i;
i = 0;
while (--lim > 0 && (c=getchar()) != EOF && c != '\n')
s[i++] = c;
if (c == '\n')
s[i++] = c;
s[i] = '\0';
return i;
}
/* strindex: return index of t in s, -1 if none */
int strindex(char s[], char t[])
{
int i, j, k;
for (i = 0; s[i] != '\0'; ++i) {
for (j = i, k = 0; t[k] != '\0' && s[j] == t[k]; j++, k++)
;
if (k > 0 && t[k] == '\0')
return i;
}
return -1;
}
/* strrindex: return index of rightmost t in s, -1 if none */
int strrindex(char s[], char t[])
{
int i, j, k;
for (i = strlen(s) - 1; i >= 0; --i) {
for (j = i, k = 0; t[k] != '\0' && s[j] == t[k]; ++j, ++k)
;
if (k > 0 && t[k] == '\0')
return i;
}
return -1;
}
| 22.197368 | 71 | 0.482513 |
aee02cd95a3ac704d0240ccf7f5272fad332b0c5 | 291 | h | C | frameeditor.h | chennes/Stop_Motion_Animation | 282c65a38053202c4e35735a0bf0a53797dc1481 | [
"MIT"
] | 3 | 2015-09-28T13:14:06.000Z | 2019-11-28T13:23:10.000Z | frameeditor.h | chennes/Stop_Motion_Animation | 282c65a38053202c4e35735a0bf0a53797dc1481 | [
"MIT"
] | 42 | 2017-03-26T15:22:37.000Z | 2019-04-05T13:42:00.000Z | frameeditor.h | chennes/Stop_Motion_Animation | 282c65a38053202c4e35735a0bf0a53797dc1481 | [
"MIT"
] | null | null | null | #ifndef FRAMEEDITOR_H
#define FRAMEEDITOR_H
#include <QDialog>
namespace Ui {
class FrameEditor;
}
class FrameEditor : public QDialog
{
Q_OBJECT
public:
explicit FrameEditor(QWidget *parent = 0);
~FrameEditor();
private:
Ui::FrameEditor *ui;
};
#endif // FRAMEEDITOR_H
| 12.652174 | 46 | 0.707904 |
aee16d5863e2773e455ff551be6ce16d1f55e484 | 3,315 | h | C | linux-3.0/drivers/net/star_mac/star_regUtil.h | spartan263/vizio_oss | 74270002d874391148119b48882db6816e7deedc | [
"Linux-OpenIB"
] | 4 | 2016-07-01T04:50:02.000Z | 2021-11-14T21:29:42.000Z | linux-3.0/drivers/net/star_mac/star_regUtil.h | spartan263/vizio_oss | 74270002d874391148119b48882db6816e7deedc | [
"Linux-OpenIB"
] | null | null | null | linux-3.0/drivers/net/star_mac/star_regUtil.h | spartan263/vizio_oss | 74270002d874391148119b48882db6816e7deedc | [
"Linux-OpenIB"
] | null | null | null | /**
* @file star_regUtil.h
* @brief The header file to define register utility functions including accessing register
* @author mtk02196
*/
#ifndef _STAR_REGUTIL_H_
#define _STAR_REGUTIL_H_
#include <asm/io.h>
/* debug level */
enum
{
STAR_ERR = 0,
STAR_WARN,
STAR_DBG,
STAR_VERB,
STAR_DBG_MAX
};
#ifndef STAR_DBG_LVL_DEFAULT
#define STAR_DBG_LVL_DEFAULT STAR_WARN
#endif
extern int star_dbg_lvl;
#define STAR_MSG(lvl, fmt...) do {\
if (lvl <= star_dbg_lvl)\
printk("star: " fmt);\
} while(0)
/**
* @brief set 32bit register
* @param reg register
* @param value value to be set
*/
static void __inline__ StarSetReg(u32 reg, u32 value)
{
STAR_MSG(STAR_VERB, "StarSetReg(%08x)=%08x\n", reg, value);
//writel(value, reg);
iowrite32(value, reg);
}
/**
* @brief get 32bit register value
* @param reg register
* @return the register's value
*/
static u32 __inline__ StarGetReg(u32 reg)
{
//u32 data = readl(reg);
u32 data = ioread32(reg);
STAR_MSG(STAR_VERB, "StarGetReg(%08x)=%08x\n", reg, data);
return data;
}
/**
* @brief set bit value to register
* @param reg register
* @param bin bit to be set
*/
static void __inline__ StarSetBit(u32 reg, u32 bit)
{
//u32 data = readl(reg);
u32 data =ioread32(reg);
data |= bit;
STAR_MSG(STAR_VERB, "StarSetBit(%08x,bit:%08x)=%08x\n", reg, bit, data);
//writel(data, reg);
iowrite32(data, reg);
}
/**
* @brief clear bit value of register
* @param reg register
* @param bin bit to be cleared
*/
static void __inline__ StarClearBit(u32 reg, u32 bit)
{
//u32 data = readl(reg);
u32 data =ioread32(reg);
data &= ~bit;
STAR_MSG(STAR_VERB, "StarClearBit(%08x,bit:%08x)=%08x\n", reg, bit, data);
//writel(data, reg);
iowrite32(data, reg);
}
/**
* @brief set bitMask with value
* @param reg register
* @param mask bit mask to be set(overwrite)
* @param offset offset of bitMask
* @param value value to be set
*/
static void __inline__ StarSetBitMask(u32 reg, u32 mask, u32 offset, u32 value)
{
//u32 data = readl(reg);
u32 data =ioread32(reg);
data = ((data & ~(mask<<offset)) | ((value<<offset) & (mask<<offset)));
STAR_MSG(STAR_VERB, "StarSetBitMask(%08x,mask:%08x,offset:%08x)=%08x(value)\n", reg, mask, offset, value);
//writel(data, reg);
iowrite32(data, reg);
}
/**
* @brief get value of biMask
* @param reg register
* @param mask bit mask to be get
* @param offset offset of bitMask
* @return the bitMask value
*/
static u32 __inline__ StarGetBitMask(u32 reg, u32 mask, u32 offset)
{
//u32 data = readl(reg);
u32 data =ioread32(reg);
data = ((data>>offset) & mask);
STAR_MSG(STAR_VERB, "StarGetBitMask(%08x,mask:%08x,offset:%08x)=%08x(data)\n", reg, mask, offset, data);
return data;
}
/**
* @brief get 32bit register value
* @param reg register
* @param bit bit to be checked if set or not
* @return 1: set, 0: not set
*/
static u32 __inline__ StarIsSetBit(u32 reg, u32 bit)
{
//u32 data = readl(reg);
u32 data =ioread32(reg);
data &= bit;
STAR_MSG(STAR_VERB, "StarIsSetBit(%08x,bit:%08x)=%08x\n", reg, bit, data);
return (data?1:0);
}
#endif /* _STAR_REGUTIL_H_ */
| 24.375 | 110 | 0.633786 |
aee42c579f0b0c779a61267784d8d00019ac7ef3 | 11,286 | h | C | Project/Temp/StagingArea/Data/il2cppOutput/Mono_Security_Mono_Security_X509_PKCS121362584794.h | Yuunagi-Yu/NumberDisk | f1cf414dbfe8d0094d3ef11b37839f6caf58ae9f | [
"MIT"
] | null | null | null | Project/Temp/StagingArea/Data/il2cppOutput/Mono_Security_Mono_Security_X509_PKCS121362584794.h | Yuunagi-Yu/NumberDisk | f1cf414dbfe8d0094d3ef11b37839f6caf58ae9f | [
"MIT"
] | null | null | null | Project/Temp/StagingArea/Data/il2cppOutput/Mono_Security_Mono_Security_X509_PKCS121362584794.h | Yuunagi-Yu/NumberDisk | f1cf414dbfe8d0094d3ef11b37839f6caf58ae9f | [
"MIT"
] | null | null | null | #pragma once
#include "il2cpp-config.h"
#ifndef _MSC_VER
# include <alloca.h>
#else
# include <malloc.h>
#endif
#include <stdint.h>
// System.Byte[]
struct ByteU5BU5D_t3397334013;
// System.Collections.ArrayList
struct ArrayList_t4252133567;
// Mono.Security.X509.X509CertificateCollection
struct X509CertificateCollection_t3592472866;
// System.Security.Cryptography.RandomNumberGenerator
struct RandomNumberGenerator_t2510243513;
// System.Collections.Generic.Dictionary`2<System.String,System.Int32>
struct Dictionary_2_t3986656710;
#include "mscorlib_System_Object2689449295.h"
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Mono.Security.X509.PKCS12
struct PKCS12_t1362584795 : public Il2CppObject
{
public:
// System.Byte[] Mono.Security.X509.PKCS12::_password
ByteU5BU5D_t3397334013* ____password_1;
// System.Collections.ArrayList Mono.Security.X509.PKCS12::_keyBags
ArrayList_t4252133567 * ____keyBags_2;
// System.Collections.ArrayList Mono.Security.X509.PKCS12::_secretBags
ArrayList_t4252133567 * ____secretBags_3;
// Mono.Security.X509.X509CertificateCollection Mono.Security.X509.PKCS12::_certs
X509CertificateCollection_t3592472866 * ____certs_4;
// System.Boolean Mono.Security.X509.PKCS12::_keyBagsChanged
bool ____keyBagsChanged_5;
// System.Boolean Mono.Security.X509.PKCS12::_secretBagsChanged
bool ____secretBagsChanged_6;
// System.Boolean Mono.Security.X509.PKCS12::_certsChanged
bool ____certsChanged_7;
// System.Int32 Mono.Security.X509.PKCS12::_iterations
int32_t ____iterations_8;
// System.Collections.ArrayList Mono.Security.X509.PKCS12::_safeBags
ArrayList_t4252133567 * ____safeBags_9;
// System.Security.Cryptography.RandomNumberGenerator Mono.Security.X509.PKCS12::_rng
RandomNumberGenerator_t2510243513 * ____rng_10;
public:
inline static int32_t get_offset_of__password_1() { return static_cast<int32_t>(offsetof(PKCS12_t1362584795, ____password_1)); }
inline ByteU5BU5D_t3397334013* get__password_1() const { return ____password_1; }
inline ByteU5BU5D_t3397334013** get_address_of__password_1() { return &____password_1; }
inline void set__password_1(ByteU5BU5D_t3397334013* value)
{
____password_1 = value;
Il2CppCodeGenWriteBarrier(&____password_1, value);
}
inline static int32_t get_offset_of__keyBags_2() { return static_cast<int32_t>(offsetof(PKCS12_t1362584795, ____keyBags_2)); }
inline ArrayList_t4252133567 * get__keyBags_2() const { return ____keyBags_2; }
inline ArrayList_t4252133567 ** get_address_of__keyBags_2() { return &____keyBags_2; }
inline void set__keyBags_2(ArrayList_t4252133567 * value)
{
____keyBags_2 = value;
Il2CppCodeGenWriteBarrier(&____keyBags_2, value);
}
inline static int32_t get_offset_of__secretBags_3() { return static_cast<int32_t>(offsetof(PKCS12_t1362584795, ____secretBags_3)); }
inline ArrayList_t4252133567 * get__secretBags_3() const { return ____secretBags_3; }
inline ArrayList_t4252133567 ** get_address_of__secretBags_3() { return &____secretBags_3; }
inline void set__secretBags_3(ArrayList_t4252133567 * value)
{
____secretBags_3 = value;
Il2CppCodeGenWriteBarrier(&____secretBags_3, value);
}
inline static int32_t get_offset_of__certs_4() { return static_cast<int32_t>(offsetof(PKCS12_t1362584795, ____certs_4)); }
inline X509CertificateCollection_t3592472866 * get__certs_4() const { return ____certs_4; }
inline X509CertificateCollection_t3592472866 ** get_address_of__certs_4() { return &____certs_4; }
inline void set__certs_4(X509CertificateCollection_t3592472866 * value)
{
____certs_4 = value;
Il2CppCodeGenWriteBarrier(&____certs_4, value);
}
inline static int32_t get_offset_of__keyBagsChanged_5() { return static_cast<int32_t>(offsetof(PKCS12_t1362584795, ____keyBagsChanged_5)); }
inline bool get__keyBagsChanged_5() const { return ____keyBagsChanged_5; }
inline bool* get_address_of__keyBagsChanged_5() { return &____keyBagsChanged_5; }
inline void set__keyBagsChanged_5(bool value)
{
____keyBagsChanged_5 = value;
}
inline static int32_t get_offset_of__secretBagsChanged_6() { return static_cast<int32_t>(offsetof(PKCS12_t1362584795, ____secretBagsChanged_6)); }
inline bool get__secretBagsChanged_6() const { return ____secretBagsChanged_6; }
inline bool* get_address_of__secretBagsChanged_6() { return &____secretBagsChanged_6; }
inline void set__secretBagsChanged_6(bool value)
{
____secretBagsChanged_6 = value;
}
inline static int32_t get_offset_of__certsChanged_7() { return static_cast<int32_t>(offsetof(PKCS12_t1362584795, ____certsChanged_7)); }
inline bool get__certsChanged_7() const { return ____certsChanged_7; }
inline bool* get_address_of__certsChanged_7() { return &____certsChanged_7; }
inline void set__certsChanged_7(bool value)
{
____certsChanged_7 = value;
}
inline static int32_t get_offset_of__iterations_8() { return static_cast<int32_t>(offsetof(PKCS12_t1362584795, ____iterations_8)); }
inline int32_t get__iterations_8() const { return ____iterations_8; }
inline int32_t* get_address_of__iterations_8() { return &____iterations_8; }
inline void set__iterations_8(int32_t value)
{
____iterations_8 = value;
}
inline static int32_t get_offset_of__safeBags_9() { return static_cast<int32_t>(offsetof(PKCS12_t1362584795, ____safeBags_9)); }
inline ArrayList_t4252133567 * get__safeBags_9() const { return ____safeBags_9; }
inline ArrayList_t4252133567 ** get_address_of__safeBags_9() { return &____safeBags_9; }
inline void set__safeBags_9(ArrayList_t4252133567 * value)
{
____safeBags_9 = value;
Il2CppCodeGenWriteBarrier(&____safeBags_9, value);
}
inline static int32_t get_offset_of__rng_10() { return static_cast<int32_t>(offsetof(PKCS12_t1362584795, ____rng_10)); }
inline RandomNumberGenerator_t2510243513 * get__rng_10() const { return ____rng_10; }
inline RandomNumberGenerator_t2510243513 ** get_address_of__rng_10() { return &____rng_10; }
inline void set__rng_10(RandomNumberGenerator_t2510243513 * value)
{
____rng_10 = value;
Il2CppCodeGenWriteBarrier(&____rng_10, value);
}
};
struct PKCS12_t1362584795_StaticFields
{
public:
// System.Int32 Mono.Security.X509.PKCS12::recommendedIterationCount
int32_t ___recommendedIterationCount_0;
// System.Int32 Mono.Security.X509.PKCS12::password_max_length
int32_t ___password_max_length_11;
// System.Collections.Generic.Dictionary`2<System.String,System.Int32> Mono.Security.X509.PKCS12::<>f__switch$map5
Dictionary_2_t3986656710 * ___U3CU3Ef__switchU24map5_12;
// System.Collections.Generic.Dictionary`2<System.String,System.Int32> Mono.Security.X509.PKCS12::<>f__switch$map6
Dictionary_2_t3986656710 * ___U3CU3Ef__switchU24map6_13;
// System.Collections.Generic.Dictionary`2<System.String,System.Int32> Mono.Security.X509.PKCS12::<>f__switch$map7
Dictionary_2_t3986656710 * ___U3CU3Ef__switchU24map7_14;
// System.Collections.Generic.Dictionary`2<System.String,System.Int32> Mono.Security.X509.PKCS12::<>f__switch$map8
Dictionary_2_t3986656710 * ___U3CU3Ef__switchU24map8_15;
// System.Collections.Generic.Dictionary`2<System.String,System.Int32> Mono.Security.X509.PKCS12::<>f__switch$mapC
Dictionary_2_t3986656710 * ___U3CU3Ef__switchU24mapC_16;
public:
inline static int32_t get_offset_of_recommendedIterationCount_0() { return static_cast<int32_t>(offsetof(PKCS12_t1362584795_StaticFields, ___recommendedIterationCount_0)); }
inline int32_t get_recommendedIterationCount_0() const { return ___recommendedIterationCount_0; }
inline int32_t* get_address_of_recommendedIterationCount_0() { return &___recommendedIterationCount_0; }
inline void set_recommendedIterationCount_0(int32_t value)
{
___recommendedIterationCount_0 = value;
}
inline static int32_t get_offset_of_password_max_length_11() { return static_cast<int32_t>(offsetof(PKCS12_t1362584795_StaticFields, ___password_max_length_11)); }
inline int32_t get_password_max_length_11() const { return ___password_max_length_11; }
inline int32_t* get_address_of_password_max_length_11() { return &___password_max_length_11; }
inline void set_password_max_length_11(int32_t value)
{
___password_max_length_11 = value;
}
inline static int32_t get_offset_of_U3CU3Ef__switchU24map5_12() { return static_cast<int32_t>(offsetof(PKCS12_t1362584795_StaticFields, ___U3CU3Ef__switchU24map5_12)); }
inline Dictionary_2_t3986656710 * get_U3CU3Ef__switchU24map5_12() const { return ___U3CU3Ef__switchU24map5_12; }
inline Dictionary_2_t3986656710 ** get_address_of_U3CU3Ef__switchU24map5_12() { return &___U3CU3Ef__switchU24map5_12; }
inline void set_U3CU3Ef__switchU24map5_12(Dictionary_2_t3986656710 * value)
{
___U3CU3Ef__switchU24map5_12 = value;
Il2CppCodeGenWriteBarrier(&___U3CU3Ef__switchU24map5_12, value);
}
inline static int32_t get_offset_of_U3CU3Ef__switchU24map6_13() { return static_cast<int32_t>(offsetof(PKCS12_t1362584795_StaticFields, ___U3CU3Ef__switchU24map6_13)); }
inline Dictionary_2_t3986656710 * get_U3CU3Ef__switchU24map6_13() const { return ___U3CU3Ef__switchU24map6_13; }
inline Dictionary_2_t3986656710 ** get_address_of_U3CU3Ef__switchU24map6_13() { return &___U3CU3Ef__switchU24map6_13; }
inline void set_U3CU3Ef__switchU24map6_13(Dictionary_2_t3986656710 * value)
{
___U3CU3Ef__switchU24map6_13 = value;
Il2CppCodeGenWriteBarrier(&___U3CU3Ef__switchU24map6_13, value);
}
inline static int32_t get_offset_of_U3CU3Ef__switchU24map7_14() { return static_cast<int32_t>(offsetof(PKCS12_t1362584795_StaticFields, ___U3CU3Ef__switchU24map7_14)); }
inline Dictionary_2_t3986656710 * get_U3CU3Ef__switchU24map7_14() const { return ___U3CU3Ef__switchU24map7_14; }
inline Dictionary_2_t3986656710 ** get_address_of_U3CU3Ef__switchU24map7_14() { return &___U3CU3Ef__switchU24map7_14; }
inline void set_U3CU3Ef__switchU24map7_14(Dictionary_2_t3986656710 * value)
{
___U3CU3Ef__switchU24map7_14 = value;
Il2CppCodeGenWriteBarrier(&___U3CU3Ef__switchU24map7_14, value);
}
inline static int32_t get_offset_of_U3CU3Ef__switchU24map8_15() { return static_cast<int32_t>(offsetof(PKCS12_t1362584795_StaticFields, ___U3CU3Ef__switchU24map8_15)); }
inline Dictionary_2_t3986656710 * get_U3CU3Ef__switchU24map8_15() const { return ___U3CU3Ef__switchU24map8_15; }
inline Dictionary_2_t3986656710 ** get_address_of_U3CU3Ef__switchU24map8_15() { return &___U3CU3Ef__switchU24map8_15; }
inline void set_U3CU3Ef__switchU24map8_15(Dictionary_2_t3986656710 * value)
{
___U3CU3Ef__switchU24map8_15 = value;
Il2CppCodeGenWriteBarrier(&___U3CU3Ef__switchU24map8_15, value);
}
inline static int32_t get_offset_of_U3CU3Ef__switchU24mapC_16() { return static_cast<int32_t>(offsetof(PKCS12_t1362584795_StaticFields, ___U3CU3Ef__switchU24mapC_16)); }
inline Dictionary_2_t3986656710 * get_U3CU3Ef__switchU24mapC_16() const { return ___U3CU3Ef__switchU24mapC_16; }
inline Dictionary_2_t3986656710 ** get_address_of_U3CU3Ef__switchU24mapC_16() { return &___U3CU3Ef__switchU24mapC_16; }
inline void set_U3CU3Ef__switchU24mapC_16(Dictionary_2_t3986656710 * value)
{
___U3CU3Ef__switchU24mapC_16 = value;
Il2CppCodeGenWriteBarrier(&___U3CU3Ef__switchU24mapC_16, value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
| 49.283843 | 174 | 0.829346 |
aee43efbde5b7a7149eee41a448cddbbe68f02be | 1,735 | h | C | examples/_breakouts/RotaryEncoderBreakout/HSVtoRGB.h | ZodiusInfuser/IOE_Arduino | d489dfd60d68b776bc5ad842f210e814fe162aae | [
"MIT"
] | 4 | 2020-08-19T02:38:26.000Z | 2022-02-22T18:14:15.000Z | examples/ToZero_InsPiRing/HSVtoRGB.h | ZodiusInfuser/ToZeroAdapters | 239d464cb6be0c155d5edca6ee759f62e228a0dc | [
"MIT"
] | 1 | 2020-08-29T16:32:08.000Z | 2020-08-29T22:26:56.000Z | examples/ToZero_InsPiRing/HSVtoRGB.h | ZodiusInfuser/ToZeroAdapters | 239d464cb6be0c155d5edca6ee759f62e228a0dc | [
"MIT"
] | 3 | 2020-08-24T19:28:37.000Z | 2021-12-30T13:01:07.000Z | #ifndef _HSVTORGB_h
#define _HSVTORGB_h
////////////////////////////////////////////////////////////////////////////////////////////////////
// FUNCTIONS
////////////////////////////////////////////////////////////////////////////////////////////////////
void HSVtoRGB(float hue, float sat, float val, byte& rOut, byte& gOut, byte& bOut)
{
////////////////////////////////
// Convert HSV values to RGB
// H(Hue): 0-360 degrees
// S(Saturation): 0-100 percent
// V(Value): 0-100 percent
//
// RGB out is in range 0->255.
// This method was found at:
// https://www.codespeedy.com/hsv-to-rgb-in-cpp/
////////////////////////////////
if(hue > 360.0f || hue < 0.0f || sat > 100.0f || sat < 0.0f || val > 100.0f || val < 0.0f)
{
//The given HSV values are not in valid range
rOut = 0;
gOut = 0;
bOut = 0;
return;
}
float s = sat / 100.0f;
float v = val / 100.0f;
float c = s * v;
float x = c * (1.0f - fabsf(fmodf(hue / 60.0f, 2.0f) - 1.0f));
float m = v - c;
float r, g, b;
if(hue >= 0.0f && hue < 60.0f)
r = c, g = x, b = 0.0f;
else if(hue >= 60.0f && hue < 120.0f)
r = x, g = c, b = 0.0f;
else if(hue >= 120.0f && hue < 180.0f)
r = 0.0f, g = c, b = x;
else if(hue >= 180.0f && hue < 240.0f)
r = 0.0f, g = x, b = c;
else if(hue >= 240.0f && hue < 300.0f)
r = x, g = 0.0f, b = c;
else
r = c, g = 0.0f, b = x;
rOut = (byte)((r + m) * 255.0f);
gOut = (byte)((g + m) * 255.0f);
bOut = (byte)((b + m) * 255.0f);
}
#endif
////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////
| 31.545455 | 100 | 0.368876 |
aee45f0540c0bba555772260a761d87760650b01 | 10,263 | c | C | PQCrypto-SIDH/src/P503/P503.c | himsen/muckle | 2d968d72b8adb4d4831066d21137d888153ac713 | [
"Apache-2.0"
] | 1 | 2020-02-04T20:55:43.000Z | 2020-02-04T20:55:43.000Z | PQCrypto-SIDH/src/P503/P503.c | himsen/muckle | 2d968d72b8adb4d4831066d21137d888153ac713 | [
"Apache-2.0"
] | null | null | null | PQCrypto-SIDH/src/P503/P503.c | himsen/muckle | 2d968d72b8adb4d4831066d21137d888153ac713 | [
"Apache-2.0"
] | 1 | 2020-02-04T16:21:48.000Z | 2020-02-04T16:21:48.000Z | /********************************************************************************************
* SIDH: an efficient supersingular isogeny cryptography library
*
* Abstract: supersingular isogeny parameters and generation of functions for P503
*********************************************************************************************/
#include "P503_api.h"
#include "P503_internal.h"
// Encoding of field elements, elements over Z_order, elements over GF(p^2) and elliptic curve points:
// --------------------------------------------------------------------------------------------------
// Elements over GF(p) and Z_order are encoded with the least significant octet (and digit) located at the leftmost position (i.e., little endian format).
// Elements (a+b*i) over GF(p^2), where a and b are defined over GF(p), are encoded as {a, b}, with a in the least significant position.
// Elliptic curve points P = (x,y) are encoded as {x, y}, with x in the least significant position.
// Internally, the number of digits used to represent all these elements is obtained by approximating the number of bits to the immediately greater multiple of 32.
// For example, a 503-bit field element is represented with Ceil(503 / 64) = 8 64-bit digits or Ceil(503 / 32) = 16 32-bit digits.
//
// Curve isogeny system "SIDHp503". Base curve: Montgomery curve By^2 = Cx^3 + Ax^2 + Cx defined over GF(p503^2), where A=0, B=1, C=1 and p503 = 2^250*3^159-1
//
const uint64_t p503[NWORDS64_FIELD] = { 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xABFFFFFFFFFFFFFF,
0x13085BDA2211E7A0, 0x1B9BF6C87B7E7DAF, 0x6045C6BDDA77A4D0, 0x004066F541811E1E };
const uint64_t p503p1[NWORDS64_FIELD] = { 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0xAC00000000000000,
0x13085BDA2211E7A0, 0x1B9BF6C87B7E7DAF, 0x6045C6BDDA77A4D0, 0x004066F541811E1E };
const uint64_t p503x2[NWORDS64_FIELD] = { 0xFFFFFFFFFFFFFFFE, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0x57FFFFFFFFFFFFFF,
0x2610B7B44423CF41, 0x3737ED90F6FCFB5E, 0xC08B8D7BB4EF49A0, 0x0080CDEA83023C3C };
// Order of Alice's subgroup
const uint64_t Alice_order[NWORDS64_ORDER] = { 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0400000000000000 };
// Order of Bob's subgroup
const uint64_t Bob_order[NWORDS64_ORDER] = { 0xC216F6888479E82B, 0xE6FDB21EDF9F6BC4, 0x1171AF769DE93406, 0x1019BD5060478798 };
// Alice's generator values {XPA0 + XPA1*i, XQA0, XRA0 + XRA1*i} in GF(p503^2), expressed in Montgomery representation
const uint64_t A_gen[5*NWORDS64_FIELD] = { 0xE7EF4AA786D855AF, 0xED5758F03EB34D3B, 0x09AE172535A86AA9, 0x237B9CC07D622723,
0xE3A284CBA4E7932D, 0x27481D9176C5E63F, 0x6A323FF55C6E71BF, 0x002ECC31A6FB8773, // XPA0
0x64D02E4E90A620B8, 0xDAB8128537D4B9F1, 0x4BADF77B8A228F98, 0x0F5DBDF9D1FB7D1B,
0xBEC4DB288E1A0DCC, 0xE76A8665E80675DB, 0x6D6F252E12929463, 0x003188BD1463FACC, // XPA1
0xB79D41025DE85D56, 0x0B867DA9DF169686, 0x740E5368021C827D, 0x20615D72157BF25C,
0xFF1590013C9B9F5B, 0xC884DCADE8C16CEA, 0xEBD05E53BF724E01, 0x0032FEF8FDA5748C, // XQA0
0x12E2E849AA0A8006, 0x41CF47008635A1E8, 0x9CD720A70798AED7, 0x42A820B42FCF04CF,
0x7BF9BAD32AAE88B1, 0xF619127A54090BBE, 0x1CB10D8F56408EAA, 0x001D6B54C3C0EDEB, // XRA0
0x34DB54931CBAAC36, 0x420A18CB8DD5F0C4, 0x32008C1A48C0F44D, 0x3B3BA772B1CFD44D,
0xA74B058FDAF13515, 0x095FC9CA7EEC17B4, 0x448E829D28F120F8, 0x00261EC3ED16A489 }; // XRA1
// Bob's generator values {XPB0 + XPB1*i, XQB0, XRB0 + XRB1*i} in GF(p503^2), expressed in Montgomery representation
const uint64_t B_gen[5*NWORDS64_FIELD] = { 0x7EDE37F4FA0BC727, 0xF7F8EC5C8598941C, 0xD15519B516B5F5C8, 0xF6D5AC9B87A36282,
0x7B19F105B30E952E, 0x13BD8B2025B4EBEE, 0x7B96D27F4EC579A2, 0x00140850CAB7E5DE, // XPB0
0x7764909DAE7B7B2D, 0x578ABB16284911AB, 0x76E2BFD146A6BF4D, 0x4824044B23AA02F0,
0x1105048912A321F3, 0xB8A2E482CF0F10C1, 0x42FF7D0BE2152085, 0x0018E599C5223352, // XPB1
0x4256C520FB388820, 0x744FD7C3BAAF0A13, 0x4B6A2DDDB12CBCB8, 0xE46826E27F427DF8,
0xFE4A663CD505A61B, 0xD6B3A1BAF025C695, 0x7C3BB62B8FCC00BD, 0x003AFDDE4A35746C, // XQB0
0x75601CD1E6C0DFCB, 0x1A9007239B58F93E, 0xC1F1BE80C62107AC, 0x7F513B898F29FF08,
0xEA0BEDFF43E1F7B2, 0x2C6D94018CBAE6D0, 0x3A430D31BCD84672, 0x000D26892ECCFE83, // XRB0
0x1119D62AEA3007A1, 0xE3702AA4E04BAE1B, 0x9AB96F7D59F990E7, 0xF58440E8B43319C0,
0xAF8134BEE1489775, 0xE7F7774E905192AA, 0xF54AE09308E98039, 0x001EF7A041A86112 }; // XRB1
// Montgomery constant Montgomery_R2 = (2^512)^2 mod p503
const uint64_t Montgomery_R2[NWORDS64_FIELD] = { 0x5289A0CF641D011F, 0x9B88257189FED2B9, 0xA3B365D58DC8F17A, 0x5BC57AB6EFF168EC,
0x9E51998BD84D4423, 0xBF8999CBAC3B5695, 0x46E9127BCE14CDB6, 0x003F6CFCE8B81771 };
// Value one in Montgomery representation
const uint64_t Montgomery_one[NWORDS64_FIELD] = { 0x00000000000003F9, 0x0000000000000000, 0x0000000000000000, 0xB400000000000000,
0x63CB1A6EA6DED2B4, 0x51689D8D667EB37D, 0x8ACD77C71AB24142, 0x0026FBAEC60F5953 };
// Value (2^256)^2 mod 3^159
const uint64_t Montgomery_Rprime[NWORDS64_ORDER] = { 0x0C2615CA3C5BAA99, 0x5A4FF3072AB6AA6A, 0xA6AFD4B039AD6AA2, 0x010DA06A26DD05CB };
// Value -(3^159)^-1 mod 2^256
const uint64_t Montgomery_rprime[NWORDS64_ORDER] = { 0x49C8A87190C0697D, 0x2EB7968EA0F0A558, 0x944257B696777FA2, 0xBAA4DDCD6139D2B3 };
// Value order_Bob/3 mod p503
const uint64_t Border_div3[NWORDS_ORDER] = { 0xEB5CFCD82C28A2B9, 0x4CFF3B5F9FDFCE96, 0xB07B3A7CDF4DBC02, 0x055DE9C5756D2D32 };
// Fixed parameters for isogeny tree computation
const unsigned int strat_Alice[MAX_Alice-1] = {
61, 32, 16, 8, 4, 2, 1, 1, 2, 1, 1, 4, 2, 1, 1, 2, 1, 1, 8, 4, 2, 1, 1, 2, 1, 1,
4, 2, 1, 1, 2, 1, 1, 16, 8, 4, 2, 1, 1, 2, 1, 1, 4, 2, 1, 1, 2, 1, 1, 8, 4, 2, 1,
1, 2, 1, 1, 4, 2, 1, 1, 2, 1, 1, 29, 16, 8, 4, 2, 1, 1, 2, 1, 1, 4, 2, 1, 1, 2, 1,
1, 8, 4, 2, 1, 1, 2, 1, 1, 4, 2, 1, 1, 2, 1, 1, 13, 8, 4, 2, 1, 1, 2, 1, 1, 4, 2,
1, 1, 2, 1, 1, 5, 4, 2, 1, 1, 2, 1, 1, 2, 1, 1, 1 };
const unsigned int strat_Bob[MAX_Bob-1] = {
71, 38, 21, 13, 8, 4, 2, 1, 1, 2, 1, 1, 4, 2, 1, 1, 2, 1, 1, 5, 4, 2, 1, 1, 2, 1,
1, 2, 1, 1, 1, 9, 5, 3, 2, 1, 1, 1, 1, 2, 1, 1, 1, 4, 2, 1, 1, 1, 2, 1, 1, 17, 9,
5, 3, 2, 1, 1, 1, 1, 2, 1, 1, 1, 4, 2, 1, 1, 1, 2, 1, 1, 8, 4, 2, 1, 1, 1, 2, 1,
1, 4, 2, 1, 1, 2, 1, 1, 33, 17, 9, 5, 3, 2, 1, 1, 1, 1, 2, 1, 1, 1, 4, 2, 1, 1, 1,
2, 1, 1, 8, 4, 2, 1, 1, 1, 2, 1, 1, 4, 2, 1, 1, 2, 1, 1, 16, 8, 4, 2, 1, 1, 1, 2,
1, 1, 4, 2, 1, 1, 2, 1, 1, 8, 4, 2, 1, 1, 2, 1, 1, 4, 2, 1, 1, 2, 1, 1 };
// Setting up macro defines and including GF(p), GF(p^2), curve, isogeny and kex functions
#define fpcopy fpcopy503
#define fpzero fpzero503
#define fpadd fpadd503
#define fpsub fpsub503
#define fpneg fpneg503
#define fpdiv2 fpdiv2_503
#define fpcorrection fpcorrection503
#define fpmul_mont fpmul503_mont
#define fpsqr_mont fpsqr503_mont
#define fpinv_mont fpinv503_mont
#define fpinv_chain_mont fpinv503_chain_mont
#define fpinv_mont_bingcd fpinv503_mont_bingcd
#define fp2copy fp2copy503
#define fp2zero fp2zero503
#define fp2add fp2add503
#define fp2sub fp2sub503
#define fp2neg fp2neg503
#define fp2div2 fp2div2_503
#define fp2correction fp2correction503
#define fp2mul_mont fp2mul503_mont
#define fp2sqr_mont fp2sqr503_mont
#define fp2inv_mont fp2inv503_mont
#define fp2inv_mont_bingcd fp2inv503_mont_bingcd
#define fpequal_non_constant_time fpequal503_non_constant_time
#define mp_add_asm mp_add503_asm
#define mp_subx2_asm mp_sub503x2_asm
#define mp_dblsubx2_asm mp_dblsub503x2_asm
#define crypto_kem_keypair crypto_kem_keypair_SIKEp503
#define crypto_kem_enc crypto_kem_enc_SIKEp503
#define crypto_kem_dec crypto_kem_dec_SIKEp503
#define random_mod_order_A random_mod_order_A_SIDHp503
#define random_mod_order_B random_mod_order_B_SIDHp503
#define EphemeralKeyGeneration_A EphemeralKeyGeneration_A_SIDHp503
#define EphemeralKeyGeneration_B EphemeralKeyGeneration_B_SIDHp503
#define EphemeralSecretAgreement_A EphemeralSecretAgreement_A_SIDHp503
#define EphemeralSecretAgreement_B EphemeralSecretAgreement_B_SIDHp503
#include "../fpx.c"
#include "../ec_isogeny.c"
#include "../sidh.c"
#include "../sike.c"
| 80.811024 | 187 | 0.586281 |
aee5981726a2a800db5d00da49045014dbca2be6 | 1,218 | h | C | sgutils.h | etranger-park/CS380_CG | 2cd735309d796353095dc8488f82448560e342f1 | [
"BSD-3-Clause"
] | null | null | null | sgutils.h | etranger-park/CS380_CG | 2cd735309d796353095dc8488f82448560e342f1 | [
"BSD-3-Clause"
] | null | null | null | sgutils.h | etranger-park/CS380_CG | 2cd735309d796353095dc8488f82448560e342f1 | [
"BSD-3-Clause"
] | null | null | null | #ifndef SGUTILS_H
#define SGUTILS_H
#include <vector>
#include "scenegraph.h"
struct RbtNodesScanner : public SgNodeVisitor {
typedef std::vector<std::tr1::shared_ptr<SgRbtNode> > SgRbtNodes;
SgRbtNodes& nodes_;
RbtNodesScanner(SgRbtNodes& nodes) : nodes_(nodes) {}
virtual bool visit(SgTransformNode& node) {
using namespace std;
using namespace tr1;
shared_ptr<SgRbtNode> rbtPtr = dynamic_pointer_cast<SgRbtNode>(node.shared_from_this());
if (rbtPtr)
nodes_.push_back(rbtPtr);
return true;
}
};
inline void dumpSgRbtNodes(std::tr1::shared_ptr<SgNode> root, std::vector<std::tr1::shared_ptr<SgRbtNode> >& rbtNodes) {
RbtNodesScanner scanner(rbtNodes);
root->accept(scanner);
}
inline void copyFrame(std::vector<std::tr1::shared_ptr<SgRbtNode> > &dist, std::vector<std::tr1::shared_ptr<SgRbtNode> > &src) {
std::vector<std::tr1::shared_ptr<SgRbtNode> >::iterator it = (src.begin());
for (; it != src.end(); it++) {
SgRbtNode *tmpRbt = new SgRbtNode();
memcpy(tmpRbt, &(*(*it)), sizeof(SgRbtNode));
std::tr1::shared_ptr<SgRbtNode> *rbtPtr = new std::tr1::shared_ptr<SgRbtNode>(tmpRbt);
//printf("src:%p / dest:%p \n", &(*(*it)), &(*rbtPtr));
dist.push_back(*rbtPtr);
}
}
#endif | 30.45 | 128 | 0.704433 |
aee5c1f255ab3a019841f22ee29ffad773bb0048 | 3,715 | h | C | src/programs/playground/JFactoryGenerator2.h | nathanwbrei/JANA2 | 716d4d01781caf33b0c93614fbb4e45fa2c0ae83 | [
"Apache-2.0"
] | null | null | null | src/programs/playground/JFactoryGenerator2.h | nathanwbrei/JANA2 | 716d4d01781caf33b0c93614fbb4e45fa2c0ae83 | [
"Apache-2.0"
] | null | null | null | src/programs/playground/JFactoryGenerator2.h | nathanwbrei/JANA2 | 716d4d01781caf33b0c93614fbb4e45fa2c0ae83 | [
"Apache-2.0"
] | null | null | null | //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Jefferson Science Associates LLC Copyright Notice:
//
// Copyright 251 2014 Jefferson Science Associates LLC All Rights Reserved. Redistribution
// and use in source and binary forms, with or without modification, are permitted as a
// licensed user 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. The name of the author may not be used to endorse or promote products derived
// from this software without specific prior written permission.
// This material resulted from work developed under a United States Government Contract.
// The Government retains a paid-up, nonexclusive, irrevocable worldwide license in such
// copyrighted data to reproduce, distribute copies to the public, prepare derivative works,
// perform publicly and display publicly and to permit others to do so.
// THIS SOFTWARE IS PROVIDED BY JEFFERSON SCIENCE ASSOCIATES LLC "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
// JEFFERSON SCIENCE ASSOCIATES, LLC OR THE U.S. GOVERNMENT BE LIABLE TO LICENSEE OR ANY
// THIRD PARTES 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.
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//
// Author: Nathan Brei
//
#ifndef JANA2_FACTORYGENERATOR_H
#define JANA2_FACTORYGENERATOR_H
#include "JAbstractFactory.h"
#include <typeindex>
/// Proposed new base class for FactoryGenerators.
/// Goals:
/// - Be able to create Factories lazily given (inner_type_index, tag)
/// - Be able to use different Factory impls for different tags
/// - Each Generator instantiates exactly one Factory
/// - Factory creation is decoupled from JFactorySets, etc
template<typename T>
struct FactoryGenerator {
virtual JAbstractFactory<T>* create(std::string tag) = 0;
virtual std::type_index get_inner_type_index() = 0;
virtual std::string get_tag() = 0;
};
/// Proposed default implementation for FactoryGenerators.
/// This should probably be sufficient for all use cases. Any additional
/// information should be a static member variable of the Factory itself,
/// and any additional logic would make more sense living in the Factor ctor.
template <typename OutType, typename InType, typename F = JAbstractFactoryT<OutType,InType>>
class FactoryGeneratorT : public FactoryGenerator<InType> {
std::string m_tag;
public:
explicit FactoryGeneratorT(std::string tag = "") : m_tag(std::move(tag)) {}
FactoryGeneratorT* create(std::string tag) override {
return new F(tag);
}
std::type_index get_inner_type_index() override {
return std::type_index(typeid(OutType));
}
std::string get_tag() override {
return m_tag;
}
};
#endif //JANA2_FACTORYGENERATOR_H
| 44.759036 | 99 | 0.719246 |
aeea2d289f2782154573e447116793996548ed71 | 254 | h | C | TFCrashSafeKit/NSArray+TFCrashSafe.h | shmxybfq/TFCrashSafeKit | 9b66a5241b43e7db95bedc942c38f00d2e60fa13 | [
"MIT"
] | 2 | 2019-08-26T06:36:40.000Z | 2020-07-21T08:49:47.000Z | TFCrashSafeKit/NSArray+TFCrashSafe.h | shmxybfq/TFCrashSafeKit | 9b66a5241b43e7db95bedc942c38f00d2e60fa13 | [
"MIT"
] | null | null | null | TFCrashSafeKit/NSArray+TFCrashSafe.h | shmxybfq/TFCrashSafeKit | 9b66a5241b43e7db95bedc942c38f00d2e60fa13 | [
"MIT"
] | null | null | null | //
// NSArray+TFCrashSafe.h
// TFCrashSafeKit
//
// Created by zhutaofeng on 2019/5/21.
// Copyright © 2019 ztf. All rights reserved.
//
#import <Foundation/Foundation.h>
@interface NSArray (TFCrashSafe)
+(void)useSafe_NSArray_TFCrashSafe;
@end
| 14.941176 | 46 | 0.716535 |
aeeb71c1b8d975d895fcdbd9ff3e47ac78fcceee | 4,364 | h | C | Synergy Editor TGC/Synergy Editor/SemanticParser.h | domydev/Dark-Basic-Pro | 237fd8d859782cb27b9d5994f3c34bc5372b6c04 | [
"MIT"
] | 231 | 2018-01-28T00:06:56.000Z | 2022-03-31T21:39:56.000Z | Synergy Editor TGC/Synergy Editor/SemanticParser.h | domydev/Dark-Basic-Pro | 237fd8d859782cb27b9d5994f3c34bc5372b6c04 | [
"MIT"
] | 9 | 2016-02-10T10:46:16.000Z | 2017-12-06T17:27:51.000Z | Synergy Editor TGC/Synergy Editor/SemanticParser.h | domydev/Dark-Basic-Pro | 237fd8d859782cb27b9d5994f3c34bc5372b6c04 | [
"MIT"
] | 66 | 2018-01-28T21:54:52.000Z | 2022-02-16T22:50:57.000Z | #pragma once
#include <vector>
#include "View.h"
#include "Doc.h"
class SemanticMessage
{
public:
CString file;
CString message;
int line;
SemanticMessage(CString newFile, CString newMessage, int newLine)
{
file = newFile;
message = newMessage;
line = newLine;
}
};
class SemanticFunction
{
public:
CString file;
CString function;
CString definition;
int line;
SemanticFunction(CString newFile, CString newFunction, CString newDefintion, int newLine)
{
file = newFile;
function = newFunction;
definition = newDefintion;
line = newLine;
}
};
class SemanticVariable
{
public:
CString file;
CString variable;
CString match; // uppercase
CString help; // Full variable definition
int line;
int endline;
CString type; // Variable type specified by the as keyword
CString typeMatch; // Variable type specified by the as keyword in uppercase
// Standard Constructor
SemanticVariable(CString newFile, CString newVariable, CString newMatch, CString newHelp, int newLine, CString newType = _T(""))
{
file = newFile;
variable = newVariable;
match = newMatch;
line = newLine;
help = newHelp;
endline = -1;
type = newType;
typeMatch = newType;
typeMatch.MakeUpper();
}
// Type variable constructor
SemanticVariable(CString newFile, CString newVariable, int newLine, CString newType)
{
file = newFile;
variable = newVariable;
match = newVariable;
match.MakeUpper();
help = newVariable + _T(" (Type Argument)");
line = newLine;
endline = -1;
type = newType;
typeMatch = newType;
typeMatch.MakeUpper();
}
// Function argument constructor
SemanticVariable(CString newFile, CString newVariable, int newLine)
{
file = newFile;
variable = newVariable;
match = newVariable;
match.MakeUpper();
help = newVariable + _T(" (Function Argument)");
line = newLine;
endline = -1;
}
};
class SemanticType
{
public:
CString file; // The owning file
CString type; // The type
CString match; // uppercase
int line; // The line
std::vector<SemanticVariable*> variables; // The variables
SemanticType(CString newFile, CString newType, CString newMatch, int newLine)
{
file = newFile;
type = newType;
match = newMatch;
line = newLine;
}
};
class SemanticLabel
{
public:
CString file;
CString label;
CString match; // uppercase
int line;
SemanticLabel(CString newFile, CString newLabel, CString newMatch, int newLine)
{
file = newFile;
label = newLabel;
match = newMatch;
line = newLine;
}
};
struct SemanticData
{
CString Text;
CString Filename;
int mode; // 0=Classview; 1=Msgbox
};
class SemanticParser
{
public:
const enum MODE { Classview, Msgbox };
static UINT ParseThread(LPVOID pParam);
static void CleanUp(bool ignoreLock);
static void SetClassView(HWND view);
static std::vector<SemanticMessage*> m_vMessages;
static std::vector<SemanticFunction*> m_vFunctions;
static std::vector<SemanticType*> m_vTypes;
static std::vector<SemanticVariable*> m_vVariables;
static std::vector<SemanticVariable*> m_vConstants;
static std::vector<SemanticLabel*> m_vLabels;
static std::vector<SemanticMessage*>::iterator mySEVectorIterator; // Errors
static std::vector<SemanticFunction*>::iterator mySFVectorIterator; // Functions
static std::vector<SemanticType*>::iterator mySTVectorIterator; // Types
static std::vector<SemanticLabel*>::iterator mySLVectorIterator; // Labels
static std::vector<SemanticVariable*>::iterator mySVVectorIterator; // Variables
static std::vector<SemanticVariable*>::iterator mySCVectorIterator; // Constants
static HWND m_ClassView;
static bool kill;
static CMutex m_Mutex;
static CMutex m_Running;
// IRM 20090910 - Storage for the current function name (if in a function)
static CString currentFunction;
static CString pathName;
static int mode;
static std::vector<CString> messages;
static int lineNumber;
static std::vector<SemanticVariable*> vTempVariables;
static bool inFunction;
static SemanticType* currentType;
private:
static void HandleGlobal(CString &line, CString &lineUpper, int offset, bool local, bool isConstant);
static void HandleDim(CString &line, CString &lineUpper, int offset);
static void HandleFunctionArgs(CString &line, int start, int end);
static bool IsLabel(CString &line);
static void HandleTypeVariable(CString &line, CString &lineUpper);
};
| 23.978022 | 129 | 0.740147 |
aeeca717f804e71a3db63918269d2261d154c7f6 | 121 | h | C | header.h | leimao/CPP_Debug_Docker | 78efbebbe42488da5901b90444c4ba6e08394aee | [
"MIT"
] | 7 | 2020-04-21T14:51:38.000Z | 2020-12-05T01:12:29.000Z | header.h | leimao/CPP_Debug_Docker | 78efbebbe42488da5901b90444c4ba6e08394aee | [
"MIT"
] | null | null | null | header.h | leimao/CPP_Debug_Docker | 78efbebbe42488da5901b90444c4ba6e08394aee | [
"MIT"
] | 6 | 2020-01-13T01:59:19.000Z | 2020-11-06T23:16:18.000Z | #ifndef HEADER_H
#define HEADER_H
int ComputeFactorial(int number);
double ComputeSeriesValue(double x, int n);
#endif | 15.125 | 43 | 0.793388 |
aeed479881b07eed861f7bb501b793472cd7e286 | 525 | h | C | Nextw/PCIe_Lib/C++/crc_check.h | iwoodsawyer/ethercat_explorer_nextw | 7f61b8dc9fdae732bab8560896f3725a62d4cd1b | [
"MIT"
] | null | null | null | Nextw/PCIe_Lib/C++/crc_check.h | iwoodsawyer/ethercat_explorer_nextw | 7f61b8dc9fdae732bab8560896f3725a62d4cd1b | [
"MIT"
] | null | null | null | Nextw/PCIe_Lib/C++/crc_check.h | iwoodsawyer/ethercat_explorer_nextw | 7f61b8dc9fdae732bab8560896f3725a62d4cd1b | [
"MIT"
] | null | null | null | #pragma once
#ifdef NEXTWPCIELIB_EXPORTS
#define NEXTWPCIELIB_API __declspec(dllexport)
#else
#define NEXTWPCIELIB_API __declspec(dllimport)
#endif
extern NEXTWPCIELIB_API unsigned char ecm_crc_table[256];
NEXTWPCIELIB_API unsigned char __stdcall cal_table_low_first(unsigned char value);
NEXTWPCIELIB_API unsigned char __stdcall cal_table_high_first(unsigned char value);
NEXTWPCIELIB_API void __stdcall create_crc_table(void);
NEXTWPCIELIB_API unsigned char __stdcall cal_crc_table(unsigned char *ptr, int len);
| 43.75 | 85 | 0.84381 |
aeeef43d467d551d7055b578447240fabe57cacf | 3,921 | c | C | ShellPkg/Library/UefiShellDebug1CommandsLib/SetSize.c | ray-linn/myedk2 | b6a8574cb6ba49044fe43a748b98f31d417ece07 | [
"Python-2.0",
"Zlib",
"BSD-2-Clause",
"MIT",
"BSD-2-Clause-Patent",
"BSD-3-Clause"
] | null | null | null | ShellPkg/Library/UefiShellDebug1CommandsLib/SetSize.c | ray-linn/myedk2 | b6a8574cb6ba49044fe43a748b98f31d417ece07 | [
"Python-2.0",
"Zlib",
"BSD-2-Clause",
"MIT",
"BSD-2-Clause-Patent",
"BSD-3-Clause"
] | null | null | null | ShellPkg/Library/UefiShellDebug1CommandsLib/SetSize.c | ray-linn/myedk2 | b6a8574cb6ba49044fe43a748b98f31d417ece07 | [
"Python-2.0",
"Zlib",
"BSD-2-Clause",
"MIT",
"BSD-2-Clause-Patent",
"BSD-3-Clause"
] | null | null | null | /** @file
Main file for SetSize shell Debug1 function.
(C) Copyright 2015 Hewlett-Packard Development Company, L.P.<BR>
Copyright (c) 2010 - 2018, Intel Corporation. All rights reserved.<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent
**/
#include "UefiShellDebug1CommandsLib.h"
/**
Function for 'setsize' command.
@param[in] ImageHandle Handle to the Image (NULL if Internal).
@param[in] SystemTable Pointer to the System Table (NULL if Internal).
**/
SHELL_STATUS
EFIAPI
ShellCommandRunSetSize (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EFI_STATUS Status;
LIST_ENTRY *Package;
CHAR16 *ProblemParam;
SHELL_STATUS ShellStatus;
CONST CHAR16 *Temp1;
UINTN NewSize;
UINTN LoopVar;
SHELL_FILE_HANDLE FileHandle;
ShellStatus = SHELL_SUCCESS;
Status = EFI_SUCCESS;
//
// initialize the shell lib (we must be in non-auto-init...)
//
Status = ShellInitialize ();
ASSERT_EFI_ERROR (Status);
Status = CommandInit ();
ASSERT_EFI_ERROR (Status);
//
// parse the command line
//
Status = ShellCommandLineParse (EmptyParamList, &Package, &ProblemParam, TRUE);
if (EFI_ERROR (Status)) {
if ((Status == EFI_VOLUME_CORRUPTED) && (ProblemParam != NULL)) {
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDebug1HiiHandle, L"setsize", ProblemParam);
FreePool (ProblemParam);
ShellStatus = SHELL_INVALID_PARAMETER;
} else {
ASSERT (FALSE);
}
} else {
if (ShellCommandLineGetCount (Package) < 3) {
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellDebug1HiiHandle, L"setsize");
ShellStatus = SHELL_INVALID_PARAMETER;
NewSize = 0;
} else {
Temp1 = ShellCommandLineGetRawValue (Package, 1);
if (!ShellIsHexOrDecimalNumber (Temp1, FALSE, FALSE)) {
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_SIZE_NOT_SPEC), gShellDebug1HiiHandle, L"setsize");
ShellStatus = SHELL_INVALID_PARAMETER;
NewSize = 0;
} else {
NewSize = ShellStrToUintn (Temp1);
}
}
for (LoopVar = 2; LoopVar < ShellCommandLineGetCount (Package) && ShellStatus == SHELL_SUCCESS; LoopVar++) {
Status = ShellOpenFileByName (ShellCommandLineGetRawValue (Package, LoopVar), &FileHandle, EFI_FILE_MODE_READ|EFI_FILE_MODE_WRITE, 0);
if (EFI_ERROR (Status)) {
Status = ShellOpenFileByName (ShellCommandLineGetRawValue (Package, LoopVar), &FileHandle, EFI_FILE_MODE_READ|EFI_FILE_MODE_WRITE|EFI_FILE_MODE_CREATE, 0);
}
if (EFI_ERROR (Status) && (LoopVar == 2)) {
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_FILE_NOT_SPEC), gShellDebug1HiiHandle, L"setsize");
ShellStatus = SHELL_INVALID_PARAMETER;
} else if (EFI_ERROR (Status)) {
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_OPEN_FAIL), gShellDebug1HiiHandle, L"setsize", ShellCommandLineGetRawValue (Package, LoopVar));
ShellStatus = SHELL_INVALID_PARAMETER;
break;
} else {
Status = FileHandleSetSize (FileHandle, NewSize);
if (Status == EFI_VOLUME_FULL) {
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_VOLUME_FULL), gShellDebug1HiiHandle, L"setsize");
ShellStatus = SHELL_VOLUME_FULL;
} else if (EFI_ERROR (Status)) {
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_SET_SIZE_FAIL), gShellDebug1HiiHandle, L"setsize", ShellCommandLineGetRawValue (Package, LoopVar));
ShellStatus = SHELL_INVALID_PARAMETER;
} else {
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_SET_SIZE_DONE), gShellDebug1HiiHandle, ShellCommandLineGetRawValue (Package, LoopVar));
}
ShellCloseFile (&FileHandle);
}
}
ShellCommandLineFreeVarList (Package);
}
return (ShellStatus);
}
| 36.305556 | 163 | 0.674318 |
aeef40e9fef1205363d5ddbe75eb759336ab8823 | 1,192 | h | C | internal/platform/implementation/windows/generated/winrt/impl/Windows.Embedded.DeviceLockdown.1.h | google/nearby | 1aeb1093a9864c73394d27598684f2e9287d6e4e | [
"Apache-2.0"
] | 69 | 2021-10-18T00:37:29.000Z | 2022-03-20T19:53:38.000Z | internal/platform/implementation/windows/generated/winrt/impl/Windows.Embedded.DeviceLockdown.1.h | google/nearby | 1aeb1093a9864c73394d27598684f2e9287d6e4e | [
"Apache-2.0"
] | 14 | 2021-10-13T19:49:27.000Z | 2022-03-31T22:19:13.000Z | internal/platform/implementation/windows/generated/winrt/impl/Windows.Embedded.DeviceLockdown.1.h | google/nearby | 1aeb1093a9864c73394d27598684f2e9287d6e4e | [
"Apache-2.0"
] | 22 | 2021-10-20T12:36:47.000Z | 2022-03-31T18:39:46.000Z | // WARNING: Please don't edit this file. It was generated by C++/WinRT v2.0.220531.1
#pragma once
#ifndef WINRT_Windows_Embedded_DeviceLockdown_1_H
#define WINRT_Windows_Embedded_DeviceLockdown_1_H
#include "winrt/impl/Windows.Embedded.DeviceLockdown.0.h"
WINRT_EXPORT namespace winrt::Windows::Embedded::DeviceLockdown
{
struct __declspec(empty_bases) IDeviceLockdownProfileInformation :
winrt::Windows::Foundation::IInspectable,
impl::consume_t<IDeviceLockdownProfileInformation>
{
IDeviceLockdownProfileInformation(std::nullptr_t = nullptr) noexcept {}
IDeviceLockdownProfileInformation(void* ptr, take_ownership_from_abi_t) noexcept : winrt::Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
};
struct __declspec(empty_bases) IDeviceLockdownProfileStatics :
winrt::Windows::Foundation::IInspectable,
impl::consume_t<IDeviceLockdownProfileStatics>
{
IDeviceLockdownProfileStatics(std::nullptr_t = nullptr) noexcept {}
IDeviceLockdownProfileStatics(void* ptr, take_ownership_from_abi_t) noexcept : winrt::Windows::Foundation::IInspectable(ptr, take_ownership_from_abi) {}
};
}
#endif
| 47.68 | 164 | 0.77349 |
aef002f8bc0db795ad1139050cd4125b3d4cd7e8 | 1,180 | h | C | System/Library/PrivateFrameworks/VideoProcessing.framework/VCPVideoMetaMotionSegment.h | lechium/tvOS135Headers | 46cd30d3f0f7962eaa0c3f925cd71f414c65e2ac | [
"MIT"
] | 2 | 2020-07-26T20:30:54.000Z | 2020-08-10T04:26:23.000Z | System/Library/PrivateFrameworks/VideoProcessing.framework/VCPVideoMetaMotionSegment.h | lechium/tvOS135Headers | 46cd30d3f0f7962eaa0c3f925cd71f414c65e2ac | [
"MIT"
] | 1 | 2020-07-26T20:45:31.000Z | 2020-08-09T09:30:46.000Z | System/Library/PrivateFrameworks/VideoProcessing.framework/VCPVideoMetaMotionSegment.h | lechium/tvOS135Headers | 46cd30d3f0f7962eaa0c3f925cd71f414c65e2ac | [
"MIT"
] | null | null | null | /*
* This header is generated by classdump-dyld 1.0
* on Sunday, June 7, 2020 at 11:26:19 AM Mountain Standard Time
* Operating System: Version 13.4.5 (Build 17L562)
* Image Source: /System/Library/PrivateFrameworks/VideoProcessing.framework/VideoProcessing
* classdump-dyld is licensed under GPLv3, Copyright © 2013-2016 by Elias Limneos.
*/
#import <VideoProcessing/VideoProcessing-Structs.h>
#import <VideoProcessing/VCPMetaSegment.h>
@interface VCPVideoMetaMotionSegment : VCPMetaSegment {
float _absMotion;
float _stabilityScore;
}
@property (assign) float absMotion; //@synthesize absMotion=_absMotion - In the implementation block
@property (assign) float stabilityScore; //@synthesize stabilityScore=_stabilityScore - In the implementation block
-(void)mergeSegment:(id)arg1 ;
-(void)finalizeAtTime:(SCD_Struct_VC6)arg1 ;
-(void)resetSegment:(float)arg1 atTime:(SCD_Struct_VC6)arg2 ;
-(void)updateSegment:(float)arg1 atTime:(SCD_Struct_VC6)arg2 ;
-(float)stabilityScore;
-(id)initWithAbsMotion:(float)arg1 atTime:(SCD_Struct_VC6)arg2 ;
-(float)absMotion;
-(void)setAbsMotion:(float)arg1 ;
-(void)setStabilityScore:(float)arg1 ;
@end
| 36.875 | 128 | 0.767797 |
aef0c8a10a59e7fb7d5784e1ec5ad5739c0df7fa | 6,182 | h | C | lte/gateway/c/oai/include/mme_app_messages_types.h | remo5000/magma | 1d1dd9a23800a8e07b1ce016776d93e12430ec15 | [
"BSD-3-Clause"
] | 2 | 2020-11-05T18:58:26.000Z | 2021-02-09T06:42:49.000Z | lte/gateway/c/oai/include/mme_app_messages_types.h | remo5000/magma | 1d1dd9a23800a8e07b1ce016776d93e12430ec15 | [
"BSD-3-Clause"
] | 10 | 2021-03-31T20:19:00.000Z | 2022-02-19T07:09:57.000Z | lte/gateway/c/oai/include/mme_app_messages_types.h | 119Vik/magma-1 | 107a7b374466a837fc0a49b283ba9d6ff1d702e3 | [
"BSD-3-Clause"
] | 3 | 2020-08-20T18:45:34.000Z | 2020-08-20T20:18:42.000Z | /*
* Copyright (c) 2015, EURECOM (www.eurecom.fr)
* 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.
*
* 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.
*
* The views and conclusions contained in the software and documentation are those
* of the authors and should not be interpreted as representing official policies,
* either expressed or implied, of the FreeBSD Project.
*/
/*! \file mme_app_messages_types.h
\brief
\author Sebastien ROUX, Lionel Gauthier
\company Eurecom
\email: lionel.gauthier@eurecom.fr
*/
#ifndef FILE_MME_APP_MESSAGES_TYPES_SEEN
#define FILE_MME_APP_MESSAGES_TYPES_SEEN
#include <stdint.h>
#include "bstrlib.h"
#include "3gpp_24.007.h"
#include "3gpp_36.401.h"
#include "common_types.h"
#include "nas/securityDef.h"
#include "nas/as_message.h"
#define MME_APP_CONNECTION_ESTABLISHMENT_CNF(mSGpTR) \
(mSGpTR)->ittiMsg.mme_app_connection_establishment_cnf
#define MME_APP_INITIAL_CONTEXT_SETUP_RSP(mSGpTR) \
(mSGpTR)->ittiMsg.mme_app_initial_context_setup_rsp
#define MME_APP_INITIAL_CONTEXT_SETUP_FAILURE(mSGpTR) \
(mSGpTR)->ittiMsg.mme_app_initial_context_setup_failure
#define MME_APP_S1AP_MME_UE_ID_NOTIFICATION(mSGpTR) \
(mSGpTR)->ittiMsg.mme_app_s1ap_mme_ue_id_notification
#define MME_APP_UL_DATA_IND(mSGpTR) (mSGpTR)->ittiMsg.mme_app_ul_data_ind
#define MME_APP_DL_DATA_CNF(mSGpTR) (mSGpTR)->ittiMsg.mme_app_dl_data_cnf
#define MME_APP_DL_DATA_REJ(mSGpTR) (mSGpTR)->ittiMsg.mme_app_dl_data_rej
typedef struct itti_mme_app_connection_establishment_cnf_s {
mme_ue_s1ap_id_t ue_id;
ambr_t ue_ambr;
// E-RAB to Be Setup List
uint8_t no_of_e_rabs; // spec says max 256, actually stay with BEARERS_PER_UE
// >>E-RAB ID
ebi_t e_rab_id[BEARERS_PER_UE];
// >>E-RAB Level QoS Parameters
qci_t e_rab_level_qos_qci[BEARERS_PER_UE];
// >>>Allocation and Retention Priority
priority_level_t e_rab_level_qos_priority_level[BEARERS_PER_UE];
// >>>Pre-emption Capability
pre_emption_capability_t
e_rab_level_qos_preemption_capability[BEARERS_PER_UE];
// >>>Pre-emption Vulnerability
pre_emption_vulnerability_t
e_rab_level_qos_preemption_vulnerability[BEARERS_PER_UE];
// >>Transport Layer Address
bstring transport_layer_address[BEARERS_PER_UE];
// >>GTP-TEID
teid_t gtp_teid[BEARERS_PER_UE];
// >>NAS-PDU (optional)
bstring nas_pdu[BEARERS_PER_UE];
// >>Correlation ID TODO? later...
// UE Security Capabilities
uint16_t ue_security_capabilities_encryption_algorithms;
uint16_t ue_security_capabilities_integrity_algorithms;
// Security key
uint8_t kenb[AUTH_KENB_SIZE];
bstring ue_radio_capability;
uint8_t presencemask;
#define S1AP_CSFB_INDICATOR_PRESENT (1 << 0)
s1ap_csfb_indicator_t cs_fallback_indicator;
// Trace Activation (optional)
// Handover Restriction List (optional)
// UE Radio Capability (optional)
// Subscriber Profile ID for RAT/Frequency priority (optional)
// CS Fallback Indicator (optional)
// SRVCC Operation Possible (optional)
// CSG Membership Status (optional)
// Registered LAI (optional)
// GUMMEI ID (optional)
// MME UE S1AP ID 2 (optional)
// Management Based MDT Allowed (optional)
} itti_mme_app_connection_establishment_cnf_t;
typedef struct itti_mme_app_initial_context_setup_rsp_s {
mme_ue_s1ap_id_t ue_id;
uint8_t no_of_e_rabs;
ebi_t e_rab_id[BEARERS_PER_UE];
bstring transport_layer_address[BEARERS_PER_UE];
s1u_teid_t gtp_teid[BEARERS_PER_UE];
} itti_mme_app_initial_context_setup_rsp_t;
typedef struct itti_mme_app_initial_context_setup_failure_s {
uint32_t mme_ue_s1ap_id;
} itti_mme_app_initial_context_setup_failure_t;
typedef struct itti_mme_app_delete_session_rsp_s {
/* UE identifier */
mme_ue_s1ap_id_t ue_id;
} itti_mme_app_delete_session_rsp_t;
typedef struct itti_mme_app_s1ap_mme_ue_id_notification_s {
enb_ue_s1ap_id_t enb_ue_s1ap_id;
mme_ue_s1ap_id_t mme_ue_s1ap_id;
sctp_assoc_id_t sctp_assoc_id;
} itti_mme_app_s1ap_mme_ue_id_notification_t;
typedef struct itti_mme_app_dl_data_cnf_s {
mme_ue_s1ap_id_t ue_id; /* UE lower layer identifier */
nas_error_code_t err_code; /* Transaction status */
} itti_mme_app_dl_data_cnf_t;
typedef struct itti_mme_app_dl_data_rej_s {
mme_ue_s1ap_id_t ue_id; /* UE lower layer identifier */
bstring nas_msg; /* Uplink NAS message */
int err_code;
} itti_mme_app_dl_data_rej_t;
typedef struct itti_mme_app_ul_data_ind_s {
mme_ue_s1ap_id_t ue_id; /* UE lower layer identifier */
bstring nas_msg; /* Uplink NAS message */
/* Indicating the Tracking Area from which the UE has sent the NAS message */
tai_t tai;
/* Indicating the cell from which the UE has sent the NAS message */
ecgi_t cgi;
} itti_mme_app_ul_data_ind_t;
#endif /* FILE_MME_APP_MESSAGES_TYPES_SEEN */
| 39.883871 | 82 | 0.764478 |
aef10af68c97b96c9648e3fddeb8e5c40c9c5e6e | 2,939 | c | C | W_eclipse1_3/ch06.Quake/jni/Quake/chase.c | 00wendi00/MyProject | 204a659c2d535d8ff588f6d926bf0edc7f417661 | [
"Apache-2.0"
] | 1 | 2019-04-28T11:57:07.000Z | 2019-04-28T11:57:07.000Z | W_eclipse1_3/ch06.Quake/jni/Quake/chase.c | 00wendi00/MyProject | 204a659c2d535d8ff588f6d926bf0edc7f417661 | [
"Apache-2.0"
] | null | null | null | W_eclipse1_3/ch06.Quake/jni/Quake/chase.c | 00wendi00/MyProject | 204a659c2d535d8ff588f6d926bf0edc7f417661 | [
"Apache-2.0"
] | null | null | null | /*
Copyright (C) 1996-1997 Id Software, Inc.
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 2
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, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
// chase.c -- chase camera code
#include "quakedef.h"
cvar_t chase_back = {"chase_back", "100"};
cvar_t chase_up = {"chase_up", "16"};
cvar_t chase_right = {"chase_right", "0"};
cvar_t chase_active = {"chase_active", "0"};
vec3_t chase_pos;
vec3_t chase_angles;
vec3_t chase_dest;
vec3_t chase_dest_angles;
void Chase_Init (void)
{
Cvar_RegisterVariable (&chase_back);
Cvar_RegisterVariable (&chase_up);
Cvar_RegisterVariable (&chase_right);
Cvar_RegisterVariable (&chase_active);
}
void Chase_Reset (void)
{
// for respawning and teleporting
// start position 12 units behind head
}
void TraceLine (vec3_t start, vec3_t end, vec3_t impact)
{
trace_t trace;
qboolean result;
memset (&trace, 0, sizeof(trace));
result = SV_RecursiveHullCheck (cl.worldmodel->hulls, 0, 0, 1, start, end, &trace);
// If result, don't use trace.endpos, otherwise view might suddenly point straight down
VectorCopy ((result ? end : trace.endpos), impact);
}
void Chase_Update (void)
{
int i;
float dist;
vec3_t forward, up, right;
vec3_t dest, stop;
// if can't see player, reset
AngleVectors (cl.viewangles, forward, right, up);
// calc exact destination
for (i=0 ; i<3 ; i++)
chase_dest[i] = r_refdef.vieworg[i]
- forward[i]*chase_back.value
- right[i]*chase_right.value;
chase_dest[2] = r_refdef.vieworg[2] + chase_up.value;
// find the spot the player is looking at
VectorMA (r_refdef.vieworg, 4096, forward, dest);
TraceLine (r_refdef.vieworg, dest, stop);
// calculate pitch to look at the same spot from camera
VectorSubtract (stop, r_refdef.vieworg, stop);
dist = DotProduct (stop, forward);
if (dist < 1)
dist = 1;
r_refdef.viewangles[PITCH] = -atan(stop[2] / dist) / M_PI * 180;
// chase_active 1 : keep view inside map except in noclip
// chase_active 2 : maintain chase_back distance even if view is outside map
if (chase_active.value == 1 && !(sv_player && sv_player->v.movetype == MOVETYPE_NOCLIP))
{
// Make sure view is inside map
TraceLine (r_refdef.vieworg, chase_dest, stop);
if (stop[0] != 0 || stop[1] != 0 || stop[2] != 0)
VectorCopy (stop, chase_dest);
}
// move towards destination
VectorCopy (chase_dest, r_refdef.vieworg);
}
| 27.990476 | 89 | 0.722695 |
aef2746bfb943dd9352a2fccbde91f97a7223d66 | 19,625 | c | C | openeuler-kernel/sound/soc/codecs/max9867.c | Ddnirvana/test-CI | dd7a0a71281075e8ab300bddbab4a9fa039958f0 | [
"MulanPSL-1.0"
] | 31 | 2021-04-27T08:50:40.000Z | 2022-03-01T02:26:21.000Z | openeuler-kernel/sound/soc/codecs/max9867.c | Ddnirvana/test-CI | dd7a0a71281075e8ab300bddbab4a9fa039958f0 | [
"MulanPSL-1.0"
] | 13 | 2021-07-10T04:36:17.000Z | 2022-03-03T10:50:05.000Z | openeuler-kernel/sound/soc/codecs/max9867.c | Ddnirvana/test-CI | dd7a0a71281075e8ab300bddbab4a9fa039958f0 | [
"MulanPSL-1.0"
] | 12 | 2021-04-06T02:23:10.000Z | 2022-02-28T11:43:19.000Z | // SPDX-License-Identifier: GPL-2.0
//
// MAX9867 ALSA SoC codec driver
//
// Copyright 2013-2015 Maxim Integrated Products
// Copyright 2018 Ladislav Michl <ladis@linux-mips.org>
//
#include <linux/delay.h>
#include <linux/i2c.h>
#include <linux/module.h>
#include <linux/regmap.h>
#include <sound/pcm_params.h>
#include <sound/soc.h>
#include <sound/tlv.h>
#include "max9867.h"
struct max9867_priv {
struct regmap *regmap;
const struct snd_pcm_hw_constraint_list *constraints;
unsigned int sysclk, pclk;
bool master, dsp_a;
unsigned int adc_dac_active;
};
static const char *const max9867_spmode[] = {
"Stereo Diff", "Mono Diff",
"Stereo Cap", "Mono Cap",
"Stereo Single", "Mono Single",
"Stereo Single Fast", "Mono Single Fast"
};
static const char *const max9867_filter_text[] = {"IIR", "FIR"};
static const char *const max9867_adc_dac_filter_text[] = {
"Disabled",
"Elliptical/16/256",
"Butterworth/16/500",
"Elliptical/8/256",
"Butterworth/8/500",
"Butterworth/8-24"
};
enum max9867_adc_dac {
MAX9867_ADC_LEFT,
MAX9867_ADC_RIGHT,
MAX9867_DAC_LEFT,
MAX9867_DAC_RIGHT,
};
static int max9867_adc_dac_event(struct snd_soc_dapm_widget *w,
struct snd_kcontrol *kcontrol, int event)
{
struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
struct max9867_priv *max9867 = snd_soc_component_get_drvdata(component);
enum max9867_adc_dac adc_dac;
if (!strcmp(w->name, "ADCL"))
adc_dac = MAX9867_ADC_LEFT;
else if (!strcmp(w->name, "ADCR"))
adc_dac = MAX9867_ADC_RIGHT;
else if (!strcmp(w->name, "DACL"))
adc_dac = MAX9867_DAC_LEFT;
else if (!strcmp(w->name, "DACR"))
adc_dac = MAX9867_DAC_RIGHT;
else
return 0;
if (SND_SOC_DAPM_EVENT_ON(event))
max9867->adc_dac_active |= BIT(adc_dac);
else if (SND_SOC_DAPM_EVENT_OFF(event))
max9867->adc_dac_active &= ~BIT(adc_dac);
return 0;
}
static int max9867_filter_get(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
struct max9867_priv *max9867 = snd_soc_component_get_drvdata(component);
unsigned int reg;
int ret;
ret = regmap_read(max9867->regmap, MAX9867_CODECFLTR, ®);
if (ret)
return -EINVAL;
if (reg & MAX9867_CODECFLTR_MODE)
ucontrol->value.enumerated.item[0] = 1;
else
ucontrol->value.enumerated.item[0] = 0;
return 0;
}
static int max9867_filter_set(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
struct max9867_priv *max9867 = snd_soc_component_get_drvdata(component);
unsigned int reg, mode = ucontrol->value.enumerated.item[0];
int ret;
if (mode > 1)
return -EINVAL;
/* don't allow change if ADC/DAC active */
if (max9867->adc_dac_active)
return -EBUSY;
/* read current filter mode */
ret = regmap_read(max9867->regmap, MAX9867_CODECFLTR, ®);
if (ret)
return -EINVAL;
if (mode)
mode = MAX9867_CODECFLTR_MODE;
/* check if change is needed */
if ((reg & MAX9867_CODECFLTR_MODE) == mode)
return 0;
/* shutdown codec before switching filter mode */
regmap_update_bits(max9867->regmap, MAX9867_PWRMAN,
MAX9867_PWRMAN_SHDN, 0);
/* switch filter mode */
regmap_update_bits(max9867->regmap, MAX9867_CODECFLTR,
MAX9867_CODECFLTR_MODE, mode);
/* out of shutdown now */
regmap_update_bits(max9867->regmap, MAX9867_PWRMAN,
MAX9867_PWRMAN_SHDN, MAX9867_PWRMAN_SHDN);
return 0;
}
static SOC_ENUM_SINGLE_EXT_DECL(max9867_filter, max9867_filter_text);
static SOC_ENUM_SINGLE_DECL(max9867_dac_filter, MAX9867_CODECFLTR, 0,
max9867_adc_dac_filter_text);
static SOC_ENUM_SINGLE_DECL(max9867_adc_filter, MAX9867_CODECFLTR, 4,
max9867_adc_dac_filter_text);
static SOC_ENUM_SINGLE_DECL(max9867_spkmode, MAX9867_MODECONFIG, 0,
max9867_spmode);
static const SNDRV_CTL_TLVD_DECLARE_DB_RANGE(max9867_master_tlv,
0, 2, TLV_DB_SCALE_ITEM(-8600, 200, 1),
3, 17, TLV_DB_SCALE_ITEM(-7800, 400, 0),
18, 25, TLV_DB_SCALE_ITEM(-2000, 200, 0),
26, 34, TLV_DB_SCALE_ITEM( -500, 100, 0),
35, 40, TLV_DB_SCALE_ITEM( 350, 50, 0),
);
static DECLARE_TLV_DB_SCALE(max9867_mic_tlv, 0, 100, 0);
static DECLARE_TLV_DB_SCALE(max9867_line_tlv, -600, 200, 0);
static DECLARE_TLV_DB_SCALE(max9867_adc_tlv, -1200, 100, 0);
static DECLARE_TLV_DB_SCALE(max9867_dac_tlv, -1500, 100, 0);
static DECLARE_TLV_DB_SCALE(max9867_dacboost_tlv, 0, 600, 0);
static const SNDRV_CTL_TLVD_DECLARE_DB_RANGE(max9867_micboost_tlv,
0, 2, TLV_DB_SCALE_ITEM(-2000, 2000, 1),
3, 3, TLV_DB_SCALE_ITEM(3000, 0, 0),
);
static const struct snd_kcontrol_new max9867_snd_controls[] = {
SOC_DOUBLE_R_TLV("Master Playback Volume", MAX9867_LEFTVOL,
MAX9867_RIGHTVOL, 0, 40, 1, max9867_master_tlv),
SOC_DOUBLE_R_TLV("Line Capture Volume", MAX9867_LEFTLINELVL,
MAX9867_RIGHTLINELVL, 0, 15, 1, max9867_line_tlv),
SOC_DOUBLE_R_TLV("Mic Capture Volume", MAX9867_LEFTMICGAIN,
MAX9867_RIGHTMICGAIN, 0, 20, 1, max9867_mic_tlv),
SOC_DOUBLE_R_TLV("Mic Boost Capture Volume", MAX9867_LEFTMICGAIN,
MAX9867_RIGHTMICGAIN, 5, 3, 0, max9867_micboost_tlv),
SOC_SINGLE("Digital Sidetone Volume", MAX9867_SIDETONE, 0, 31, 1),
SOC_SINGLE_TLV("Digital Playback Volume", MAX9867_DACLEVEL, 0, 15, 1,
max9867_dac_tlv),
SOC_SINGLE_TLV("Digital Boost Playback Volume", MAX9867_DACLEVEL, 4, 3, 0,
max9867_dacboost_tlv),
SOC_DOUBLE_TLV("Digital Capture Volume", MAX9867_ADCLEVEL, 4, 0, 15, 1,
max9867_adc_tlv),
SOC_ENUM("Speaker Mode", max9867_spkmode),
SOC_SINGLE("Volume Smoothing Switch", MAX9867_MODECONFIG, 6, 1, 0),
SOC_SINGLE("Line ZC Switch", MAX9867_MODECONFIG, 5, 1, 0),
SOC_ENUM_EXT("DSP Filter", max9867_filter, max9867_filter_get, max9867_filter_set),
SOC_ENUM("ADC Filter", max9867_adc_filter),
SOC_ENUM("DAC Filter", max9867_dac_filter),
SOC_SINGLE("Mono Playback Switch", MAX9867_IFC1B, 3, 1, 0),
};
/* Input mixer */
static const struct snd_kcontrol_new max9867_input_mixer_controls[] = {
SOC_DAPM_DOUBLE("Line Capture Switch", MAX9867_INPUTCONFIG, 7, 5, 1, 0),
SOC_DAPM_DOUBLE("Mic Capture Switch", MAX9867_INPUTCONFIG, 6, 4, 1, 0),
};
/* Output mixer */
static const struct snd_kcontrol_new max9867_output_mixer_controls[] = {
SOC_DAPM_DOUBLE_R("Line Bypass Switch",
MAX9867_LEFTLINELVL, MAX9867_RIGHTLINELVL, 6, 1, 1),
};
/* Sidetone mixer */
static const struct snd_kcontrol_new max9867_sidetone_mixer_controls[] = {
SOC_DAPM_DOUBLE("Sidetone Switch", MAX9867_SIDETONE, 6, 7, 1, 0),
};
/* Line out switch */
static const struct snd_kcontrol_new max9867_line_out_control =
SOC_DAPM_DOUBLE_R("Switch",
MAX9867_LEFTVOL, MAX9867_RIGHTVOL, 6, 1, 1);
/* DMIC mux */
static const char *const dmic_mux_text[] = {
"ADC", "DMIC"
};
static SOC_ENUM_SINGLE_DECL(left_dmic_mux_enum,
MAX9867_MICCONFIG, 5, dmic_mux_text);
static SOC_ENUM_SINGLE_DECL(right_dmic_mux_enum,
MAX9867_MICCONFIG, 4, dmic_mux_text);
static const struct snd_kcontrol_new max9867_left_dmic_mux =
SOC_DAPM_ENUM("DMICL Mux", left_dmic_mux_enum);
static const struct snd_kcontrol_new max9867_right_dmic_mux =
SOC_DAPM_ENUM("DMICR Mux", right_dmic_mux_enum);
static const struct snd_soc_dapm_widget max9867_dapm_widgets[] = {
SND_SOC_DAPM_INPUT("MICL"),
SND_SOC_DAPM_INPUT("MICR"),
SND_SOC_DAPM_INPUT("DMICL"),
SND_SOC_DAPM_INPUT("DMICR"),
SND_SOC_DAPM_INPUT("LINL"),
SND_SOC_DAPM_INPUT("LINR"),
SND_SOC_DAPM_PGA("Left Line Input", SND_SOC_NOPM, 0, 0, NULL, 0),
SND_SOC_DAPM_PGA("Right Line Input", SND_SOC_NOPM, 0, 0, NULL, 0),
SND_SOC_DAPM_MIXER_NAMED_CTL("Input Mixer", SND_SOC_NOPM, 0, 0,
max9867_input_mixer_controls,
ARRAY_SIZE(max9867_input_mixer_controls)),
SND_SOC_DAPM_MUX("DMICL Mux", SND_SOC_NOPM, 0, 0,
&max9867_left_dmic_mux),
SND_SOC_DAPM_MUX("DMICR Mux", SND_SOC_NOPM, 0, 0,
&max9867_right_dmic_mux),
SND_SOC_DAPM_ADC_E("ADCL", "HiFi Capture", SND_SOC_NOPM, 0, 0,
max9867_adc_dac_event,
SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
SND_SOC_DAPM_ADC_E("ADCR", "HiFi Capture", SND_SOC_NOPM, 0, 0,
max9867_adc_dac_event,
SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
SND_SOC_DAPM_MIXER("Digital", SND_SOC_NOPM, 0, 0,
max9867_sidetone_mixer_controls,
ARRAY_SIZE(max9867_sidetone_mixer_controls)),
SND_SOC_DAPM_MIXER_NAMED_CTL("Output Mixer", SND_SOC_NOPM, 0, 0,
max9867_output_mixer_controls,
ARRAY_SIZE(max9867_output_mixer_controls)),
SND_SOC_DAPM_DAC_E("DACL", "HiFi Playback", SND_SOC_NOPM, 0, 0,
max9867_adc_dac_event,
SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
SND_SOC_DAPM_DAC_E("DACR", "HiFi Playback", SND_SOC_NOPM, 0, 0,
max9867_adc_dac_event,
SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
SND_SOC_DAPM_SWITCH("Master Playback", SND_SOC_NOPM, 0, 0,
&max9867_line_out_control),
SND_SOC_DAPM_OUTPUT("LOUT"),
SND_SOC_DAPM_OUTPUT("ROUT"),
};
static const struct snd_soc_dapm_route max9867_audio_map[] = {
{"Left Line Input", NULL, "LINL"},
{"Right Line Input", NULL, "LINR"},
{"Input Mixer", "Mic Capture Switch", "MICL"},
{"Input Mixer", "Mic Capture Switch", "MICR"},
{"Input Mixer", "Line Capture Switch", "Left Line Input"},
{"Input Mixer", "Line Capture Switch", "Right Line Input"},
{"DMICL Mux", "DMIC", "DMICL"},
{"DMICR Mux", "DMIC", "DMICR"},
{"DMICL Mux", "ADC", "Input Mixer"},
{"DMICR Mux", "ADC", "Input Mixer"},
{"ADCL", NULL, "DMICL Mux"},
{"ADCR", NULL, "DMICR Mux"},
{"Digital", "Sidetone Switch", "ADCL"},
{"Digital", "Sidetone Switch", "ADCR"},
{"DACL", NULL, "Digital"},
{"DACR", NULL, "Digital"},
{"Output Mixer", "Line Bypass Switch", "Left Line Input"},
{"Output Mixer", "Line Bypass Switch", "Right Line Input"},
{"Output Mixer", NULL, "DACL"},
{"Output Mixer", NULL, "DACR"},
{"Master Playback", "Switch", "Output Mixer"},
{"LOUT", NULL, "Master Playback"},
{"ROUT", NULL, "Master Playback"},
};
static const unsigned int max9867_rates_44k1[] = {
11025, 22050, 44100,
};
static const struct snd_pcm_hw_constraint_list max9867_constraints_44k1 = {
.list = max9867_rates_44k1,
.count = ARRAY_SIZE(max9867_rates_44k1),
};
static const unsigned int max9867_rates_48k[] = {
8000, 16000, 32000, 48000,
};
static const struct snd_pcm_hw_constraint_list max9867_constraints_48k = {
.list = max9867_rates_48k,
.count = ARRAY_SIZE(max9867_rates_48k),
};
static int max9867_startup(struct snd_pcm_substream *substream,
struct snd_soc_dai *dai)
{
struct max9867_priv *max9867 =
snd_soc_component_get_drvdata(dai->component);
if (max9867->constraints)
snd_pcm_hw_constraint_list(substream->runtime, 0,
SNDRV_PCM_HW_PARAM_RATE, max9867->constraints);
return 0;
}
static int max9867_dai_hw_params(struct snd_pcm_substream *substream,
struct snd_pcm_hw_params *params, struct snd_soc_dai *dai)
{
int value;
unsigned long int rate, ratio;
struct snd_soc_component *component = dai->component;
struct max9867_priv *max9867 = snd_soc_component_get_drvdata(component);
unsigned int ni = DIV_ROUND_CLOSEST_ULL(96ULL * 0x10000 * params_rate(params),
max9867->pclk);
/* set up the ni value */
regmap_update_bits(max9867->regmap, MAX9867_AUDIOCLKHIGH,
MAX9867_NI_HIGH_MASK, (0xFF00 & ni) >> 8);
regmap_update_bits(max9867->regmap, MAX9867_AUDIOCLKLOW,
MAX9867_NI_LOW_MASK, 0x00FF & ni);
if (max9867->master) {
if (max9867->dsp_a) {
value = MAX9867_IFC1B_48X;
} else {
rate = params_rate(params) * 2 * params_width(params);
ratio = max9867->pclk / rate;
switch (params_width(params)) {
case 8:
case 16:
switch (ratio) {
case 2:
value = MAX9867_IFC1B_PCLK_2;
break;
case 4:
value = MAX9867_IFC1B_PCLK_4;
break;
case 8:
value = MAX9867_IFC1B_PCLK_8;
break;
case 16:
value = MAX9867_IFC1B_PCLK_16;
break;
default:
return -EINVAL;
}
break;
case 24:
value = MAX9867_IFC1B_48X;
break;
case 32:
value = MAX9867_IFC1B_64X;
break;
default:
return -EINVAL;
}
}
regmap_update_bits(max9867->regmap, MAX9867_IFC1B,
MAX9867_IFC1B_BCLK_MASK, value);
} else {
/*
* digital pll locks on to any externally supplied LRCLK signal
* and also enable rapid lock mode.
*/
regmap_update_bits(max9867->regmap, MAX9867_AUDIOCLKLOW,
MAX9867_RAPID_LOCK, MAX9867_RAPID_LOCK);
regmap_update_bits(max9867->regmap, MAX9867_AUDIOCLKHIGH,
MAX9867_PLL, MAX9867_PLL);
}
return 0;
}
static int max9867_mute(struct snd_soc_dai *dai, int mute, int direction)
{
struct snd_soc_component *component = dai->component;
struct max9867_priv *max9867 = snd_soc_component_get_drvdata(component);
return regmap_update_bits(max9867->regmap, MAX9867_DACLEVEL,
1 << 6, !!mute << 6);
}
static int max9867_set_dai_sysclk(struct snd_soc_dai *codec_dai,
int clk_id, unsigned int freq, int dir)
{
struct snd_soc_component *component = codec_dai->component;
struct max9867_priv *max9867 = snd_soc_component_get_drvdata(component);
int value = 0;
/* Set the prescaler based on the master clock frequency*/
if (freq >= 10000000 && freq <= 20000000) {
value |= MAX9867_PSCLK_10_20;
max9867->pclk = freq;
} else if (freq >= 20000000 && freq <= 40000000) {
value |= MAX9867_PSCLK_20_40;
max9867->pclk = freq / 2;
} else if (freq >= 40000000 && freq <= 60000000) {
value |= MAX9867_PSCLK_40_60;
max9867->pclk = freq / 4;
} else {
dev_err(component->dev,
"Invalid clock frequency %uHz (required 10-60MHz)\n",
freq);
return -EINVAL;
}
if (freq % 48000 == 0)
max9867->constraints = &max9867_constraints_48k;
else if (freq % 44100 == 0)
max9867->constraints = &max9867_constraints_44k1;
else
dev_warn(component->dev,
"Unable to set exact rate with %uHz clock frequency\n",
freq);
max9867->sysclk = freq;
value = value << MAX9867_PSCLK_SHIFT;
/* exact integer mode is not supported */
value &= ~MAX9867_FREQ_MASK;
regmap_update_bits(max9867->regmap, MAX9867_SYSCLK,
MAX9867_PSCLK_MASK, value);
return 0;
}
static int max9867_dai_set_fmt(struct snd_soc_dai *codec_dai,
unsigned int fmt)
{
struct snd_soc_component *component = codec_dai->component;
struct max9867_priv *max9867 = snd_soc_component_get_drvdata(component);
u8 iface1A, iface1B;
switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
case SND_SOC_DAIFMT_CBM_CFM:
max9867->master = true;
iface1A = MAX9867_MASTER;
iface1B = MAX9867_IFC1B_48X;
break;
case SND_SOC_DAIFMT_CBS_CFS:
max9867->master = false;
iface1A = iface1B = 0;
break;
default:
return -EINVAL;
}
switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
case SND_SOC_DAIFMT_I2S:
max9867->dsp_a = false;
iface1A |= MAX9867_I2S_DLY;
break;
case SND_SOC_DAIFMT_DSP_A:
max9867->dsp_a = true;
iface1A |= MAX9867_TDM_MODE | MAX9867_SDOUT_HIZ;
break;
default:
return -EINVAL;
}
/* Clock inversion bits, BCI and WCI */
switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
case SND_SOC_DAIFMT_NB_NF:
break;
case SND_SOC_DAIFMT_IB_IF:
iface1A |= MAX9867_WCI_MODE | MAX9867_BCI_MODE;
break;
case SND_SOC_DAIFMT_IB_NF:
iface1A |= MAX9867_BCI_MODE;
break;
case SND_SOC_DAIFMT_NB_IF:
iface1A |= MAX9867_WCI_MODE;
break;
default:
return -EINVAL;
}
regmap_write(max9867->regmap, MAX9867_IFC1A, iface1A);
regmap_update_bits(max9867->regmap, MAX9867_IFC1B,
MAX9867_IFC1B_BCLK_MASK, iface1B);
return 0;
}
static const struct snd_soc_dai_ops max9867_dai_ops = {
.set_sysclk = max9867_set_dai_sysclk,
.set_fmt = max9867_dai_set_fmt,
.mute_stream = max9867_mute,
.startup = max9867_startup,
.hw_params = max9867_dai_hw_params,
.no_capture_mute = 1,
};
static struct snd_soc_dai_driver max9867_dai[] = {
{
.name = "max9867-aif1",
.playback = {
.stream_name = "HiFi Playback",
.channels_min = 2,
.channels_max = 2,
.rates = SNDRV_PCM_RATE_8000_48000,
.formats = SNDRV_PCM_FMTBIT_S16_LE,
},
.capture = {
.stream_name = "HiFi Capture",
.channels_min = 2,
.channels_max = 2,
.rates = SNDRV_PCM_RATE_8000_48000,
.formats = SNDRV_PCM_FMTBIT_S16_LE,
},
.ops = &max9867_dai_ops,
.symmetric_rates = 1,
}
};
#ifdef CONFIG_PM
static int max9867_suspend(struct snd_soc_component *component)
{
snd_soc_component_force_bias_level(component, SND_SOC_BIAS_OFF);
return 0;
}
static int max9867_resume(struct snd_soc_component *component)
{
snd_soc_component_force_bias_level(component, SND_SOC_BIAS_STANDBY);
return 0;
}
#else
#define max9867_suspend NULL
#define max9867_resume NULL
#endif
static int max9867_set_bias_level(struct snd_soc_component *component,
enum snd_soc_bias_level level)
{
int err;
struct max9867_priv *max9867 = snd_soc_component_get_drvdata(component);
switch (level) {
case SND_SOC_BIAS_STANDBY:
if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_OFF) {
err = regcache_sync(max9867->regmap);
if (err)
return err;
err = regmap_write(max9867->regmap,
MAX9867_PWRMAN, 0xff);
if (err)
return err;
}
break;
case SND_SOC_BIAS_OFF:
err = regmap_write(max9867->regmap, MAX9867_PWRMAN, 0);
if (err)
return err;
regcache_mark_dirty(max9867->regmap);
break;
default:
break;
}
return 0;
}
static const struct snd_soc_component_driver max9867_component = {
.controls = max9867_snd_controls,
.num_controls = ARRAY_SIZE(max9867_snd_controls),
.dapm_routes = max9867_audio_map,
.num_dapm_routes = ARRAY_SIZE(max9867_audio_map),
.dapm_widgets = max9867_dapm_widgets,
.num_dapm_widgets = ARRAY_SIZE(max9867_dapm_widgets),
.suspend = max9867_suspend,
.resume = max9867_resume,
.set_bias_level = max9867_set_bias_level,
.idle_bias_on = 1,
.use_pmdown_time = 1,
.endianness = 1,
.non_legacy_dai_naming = 1,
};
static bool max9867_volatile_register(struct device *dev, unsigned int reg)
{
switch (reg) {
case MAX9867_STATUS:
case MAX9867_JACKSTATUS:
case MAX9867_AUXHIGH:
case MAX9867_AUXLOW:
return true;
default:
return false;
}
}
static const struct regmap_config max9867_regmap = {
.reg_bits = 8,
.val_bits = 8,
.max_register = MAX9867_REVISION,
.volatile_reg = max9867_volatile_register,
.cache_type = REGCACHE_RBTREE,
};
static int max9867_i2c_probe(struct i2c_client *i2c,
const struct i2c_device_id *id)
{
struct max9867_priv *max9867;
int ret, reg;
max9867 = devm_kzalloc(&i2c->dev, sizeof(*max9867), GFP_KERNEL);
if (!max9867)
return -ENOMEM;
i2c_set_clientdata(i2c, max9867);
max9867->regmap = devm_regmap_init_i2c(i2c, &max9867_regmap);
if (IS_ERR(max9867->regmap)) {
ret = PTR_ERR(max9867->regmap);
dev_err(&i2c->dev, "Failed to allocate regmap: %d\n", ret);
return ret;
}
ret = regmap_read(max9867->regmap, MAX9867_REVISION, ®);
if (ret < 0) {
dev_err(&i2c->dev, "Failed to read: %d\n", ret);
return ret;
}
dev_info(&i2c->dev, "device revision: %x\n", reg);
ret = devm_snd_soc_register_component(&i2c->dev, &max9867_component,
max9867_dai, ARRAY_SIZE(max9867_dai));
if (ret < 0)
dev_err(&i2c->dev, "Failed to register component: %d\n", ret);
return ret;
}
static const struct i2c_device_id max9867_i2c_id[] = {
{ "max9867", 0 },
{ }
};
MODULE_DEVICE_TABLE(i2c, max9867_i2c_id);
static const struct of_device_id max9867_of_match[] = {
{ .compatible = "maxim,max9867", },
{ }
};
MODULE_DEVICE_TABLE(of, max9867_of_match);
static struct i2c_driver max9867_i2c_driver = {
.driver = {
.name = "max9867",
.of_match_table = of_match_ptr(max9867_of_match),
},
.probe = max9867_i2c_probe,
.id_table = max9867_i2c_id,
};
module_i2c_driver(max9867_i2c_driver);
MODULE_AUTHOR("Ladislav Michl <ladis@linux-mips.org>");
MODULE_DESCRIPTION("ASoC MAX9867 driver");
MODULE_LICENSE("GPL");
| 29.203869 | 84 | 0.737732 |
aef2e6fbb807517447370a83ca263d351ce90fe6 | 2,544 | h | C | display/terminfo/TIvisual.h | antrik/libggi | e935e0ed84461dbc630ddbaf07209c5e964d332f | [
"MIT"
] | 1 | 2017-09-18T10:22:43.000Z | 2017-09-18T10:22:43.000Z | display/terminfo/TIvisual.h | antrik/libggi | e935e0ed84461dbc630ddbaf07209c5e964d332f | [
"MIT"
] | null | null | null | display/terminfo/TIvisual.h | antrik/libggi | e935e0ed84461dbc630ddbaf07209c5e964d332f | [
"MIT"
] | null | null | null | /* $Id: TIvisual.h,v 1.11 2007/04/29 06:58:06 cegger Exp $
*
* Copyright 1998 MenTaLguY - mentalg@geocities.com
*
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 AUTHOR(S) 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.
*/
#include <ggi/internal/ggi-dl.h>
#ifdef __GNUC__
# undef alloca
# define alloca __builtin_alloca
#else
# if HAVE_ALLOCA_H
# include <alloca.h>
# else
# ifdef _AIX
#pragma alloca
# else
# ifndef alloca /* predefined by HP cc +Olibcalls */
char *alloca ();
# endif
# endif
# endif
#endif
#ifdef HAVE_NCURSES_H
#include <ncurses.h>
#elif defined(HAVE_NCURSES_NCURSES_H)
#include <ncurses/ncurses.h>
#else
#include <curses.h>
#endif
struct TIhooks {
SCREEN *scr;
FILE *f_in, *f_out;
int f_private;
struct { int x, y; } origin;
int splitline;
int virgin;
chtype color16_table[256];
chtype charmap[256];
struct gg_plugin *inp;
PHYSZ_DATA
};
#define TERMINFO_PRIV(vis) ((struct TIhooks *)LIBGGI_PRIVATE(vis))
/* Prototypes
*/
void _terminfo_init_ncurses(void);
void _terminfo_finalize_ncurses(void);
SCREEN *_terminfo_new_screen(const char *term_type, FILE *out, FILE *in);
void _terminfo_select_screen(SCREEN *scr);
void _terminfo_release_screen(void);
void _terminfo_destroy_screen(void);
ggifunc_flush GGI_terminfo_flush;
ggifunc_getmode GGI_terminfo_getmode;
ggifunc_setmode GGI_terminfo_setmode;
ggifunc_checkmode GGI_terminfo_checkmode;
ggifunc_getapi GGI_terminfo_getapi;
ggifunc_setflags GGI_terminfo_setflags;
extern int paint_ncurses_window(struct ggi_visual *, WINDOW *, int, int);
extern void _GGI_terminfo_freedbs(struct ggi_visual *);
| 29.581395 | 77 | 0.767296 |
aef321bf31b8056f6769c42d5e022ecbd0887e1f | 1,826 | h | C | System/Library/PrivateFrameworks/AXMediaUtilities.framework/AXMTaggedText.h | lechium/tvOS124Headers | 11d1b56dd4c0ffd88b9eac43f87a5fd6f7228475 | [
"MIT"
] | 4 | 2019-08-27T18:03:47.000Z | 2021-09-18T06:29:00.000Z | System/Library/PrivateFrameworks/AXMediaUtilities.framework/AXMTaggedText.h | lechium/tvOS124Headers | 11d1b56dd4c0ffd88b9eac43f87a5fd6f7228475 | [
"MIT"
] | null | null | null | System/Library/PrivateFrameworks/AXMediaUtilities.framework/AXMTaggedText.h | lechium/tvOS124Headers | 11d1b56dd4c0ffd88b9eac43f87a5fd6f7228475 | [
"MIT"
] | null | null | null | /*
* This header is generated by classdump-dyld 1.0
* on Saturday, August 24, 2019 at 9:46:09 PM Mountain Standard Time
* Operating System: Version 12.4 (Build 16M568)
* Image Source: /System/Library/PrivateFrameworks/AXMediaUtilities.framework/AXMediaUtilities
* classdump-dyld is licensed under GPLv3, Copyright © 2013-2016 by Elias Limneos.
*/
#import <AXMediaUtilities/AXMediaUtilities-Structs.h>
#import <Foundation/NSMutableAttributedString.h>
@class NSMutableAttributedString, NSMutableDictionary, NSLocale, NSString;
@interface AXMTaggedText : NSMutableAttributedString {
NSMutableAttributedString* _attrString;
NSMutableDictionary* _globalAttributes;
/*^block*/id _evaluationBlock;
}
@property (nonatomic,readonly) NSLocale * locale;
@property (assign,getter=isSpeakable,nonatomic) BOOL speakable;
@property (nonatomic,readonly) NSString * speakableText;
+(id)textWithString:(id)arg1 locale:(id)arg2 evaluationBlock:(/*^block*/id)arg3 ;
-(NSString *)speakableText;
-(void)_evaluateIfNeeded;
-(BOOL)hasGlobalTag:(id)arg1 ;
-(void)addGlobalTag:(id)arg1 ;
-(void)removeGlobalTag:(id)arg1 ;
-(NSRange)_stringRange;
-(BOOL)_isEvaluated;
-(BOOL)isSpeakable;
-(id)_substringWithRange:(NSRange)arg1 ;
-(id)_initWithAttributedString:(id)arg1 ;
-(void)addTag:(id)arg1 withToken:(id)arg2 range:(NSRange)arg3 ;
-(void)setSpeakable:(BOOL)arg1 ;
-(BOOL)isRangeSpeakable:(NSRange)arg1 ;
-(void)_setNeedEvaluation;
-(id)string;
-(id)initWithString:(id)arg1 ;
-(id)debugDescription;
-(id)initWithString:(id)arg1 attributes:(id)arg2 ;
-(void)setAttributes:(id)arg1 range:(NSRange)arg2 ;
-(void)replaceCharactersInRange:(NSRange)arg1 withString:(id)arg2 ;
-(id)initWithAttributedString:(id)arg1 ;
-(id)attributesAtIndex:(unsigned long long)arg1 effectiveRange:(NSRange*)arg2 ;
-(NSLocale *)locale;
-(id)mutableString;
@end
| 35.115385 | 93 | 0.778751 |
aef5631eac58107cb56952399c0612611b5a5e7b | 1,029 | h | C | linsched-linsched-alpha/arch/arm/mach-s3c2410/include/mach/hardware.h | usenixatc2021/SoftRefresh_Scheduling | 589ba06c8ae59538973c22edf28f74a59d63aa14 | [
"MIT"
] | 55 | 2015-01-20T00:09:45.000Z | 2021-08-19T05:40:27.000Z | linsched-linsched-alpha/arch/arm/mach-s3c2410/include/mach/hardware.h | usenixatc2021/SoftRefresh_Scheduling | 589ba06c8ae59538973c22edf28f74a59d63aa14 | [
"MIT"
] | 1 | 2020-06-30T18:01:37.000Z | 2020-06-30T18:01:37.000Z | linsched-linsched-alpha/arch/arm/mach-s3c2410/include/mach/hardware.h | usenixatc2021/SoftRefresh_Scheduling | 589ba06c8ae59538973c22edf28f74a59d63aa14 | [
"MIT"
] | 36 | 2015-02-13T00:58:22.000Z | 2021-08-19T08:08:07.000Z | /* arch/arm/mach-s3c2410/include/mach/hardware.h
*
* Copyright (c) 2003 Simtec Electronics
* Ben Dooks <ben@simtec.co.uk>
*
* S3C2410 - hardware
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*/
#ifndef __ASM_ARCH_HARDWARE_H
#define __ASM_ARCH_HARDWARE_H
#ifndef __ASSEMBLY__
extern unsigned int s3c2410_modify_misccr(unsigned int clr, unsigned int chg);
#ifdef CONFIG_CPU_S3C2440
extern int s3c2440_set_dsc(unsigned int pin, unsigned int value);
#endif /* CONFIG_CPU_S3C2440 */
#ifdef CONFIG_CPU_S3C2412
extern int s3c2412_gpio_set_sleepcfg(unsigned int pin, unsigned int state);
#endif /* CONFIG_CPU_S3C2412 */
#endif /* __ASSEMBLY__ */
#include <asm/sizes.h>
#include <mach/map.h>
/* machine specific hardware definitions should go after this */
/* currently here until moved into config (todo) */
#define CONFIG_NO_MULTIWORD_IO
#endif /* __ASM_ARCH_HARDWARE_H */
| 23.930233 | 78 | 0.765792 |
aef610732dad596ea3e60611127dc2464e7c2b84 | 1,856 | h | C | Resources/WC_7_0_5_Headers/QRCodeViewController.h | shuangwei-Ye/WeChat_tweak | 0f496f38f0336908258d606dcbef7067a096926a | [
"MIT"
] | 2 | 2021-05-30T07:50:20.000Z | 2022-02-23T15:42:53.000Z | Resources/WC_7_0_5_Headers/QRCodeViewController.h | LP36911/WeChat_tweak | 0f496f38f0336908258d606dcbef7067a096926a | [
"MIT"
] | null | null | null | Resources/WC_7_0_5_Headers/QRCodeViewController.h | LP36911/WeChat_tweak | 0f496f38f0336908258d606dcbef7067a096926a | [
"MIT"
] | null | null | null | //
// Generated by class-dump 3.5 (64 bit).
//
// class-dump is Copyright (C) 1997-1998, 2000-2001, 2004-2013 by Steve Nygard.
//
#import "MMUIViewController.h"
#import "FoldableTipViewDelegate.h"
#import "IMMQRCodeExt.h"
#import "WCActionSheetDelegate.h"
@class CContact, FoldableTipView, MMAnimationTipView, NSString, QRCodeCardView;
@interface QRCodeViewController : MMUIViewController <FoldableTipViewDelegate, IMMQRCodeExt, WCActionSheetDelegate>
{
struct stWeixinEntryRow *m_aryEntryRow;
unsigned int m_arrEntryRowSize;
unsigned int m_curOperateType;
CContact *m_contact;
MMAnimationTipView *m_tipView;
QRCodeCardView *m_qrcodeCard;
_Bool m_bIsNotAllowAddMeByQRCode;
_Bool _isOpenedByScanQR;
FoldableTipView *m_abandonTipView;
}
- (void).cxx_destruct;
- (void)Operate:(id)arg1;
- (void)actionSheet:(id)arg1 clickedButtonAtIndex:(long long)arg2;
- (void)adjustSubviewRects;
- (_Bool)canShowFacebookShareEntrance;
- (void)dealloc;
- (void)getNextQRCode;
- (void)initRow;
- (void)initView;
- (id)initWithContact:(id)arg1;
- (void)onDownloadQRCodeFinish:(id)arg1 FooterWording:(id)arg2;
- (void)onFoldableTipViewClickCancel:(id)arg1;
- (void)onFoldableTipViewClickConfirm:(id)arg1;
- (void)onRevokeQRCode;
- (void)onShowAbandonTip:(id)arg1 TipID:(id)arg2 Wording:(id)arg3;
- (_Bool)preViewControllerIsKindOf:(Class)arg1;
- (void)revokeQRCode;
- (void)saveToAlbum;
- (void)scanQRCode;
- (void)setHasShowTip:(id)arg1;
- (void)shareChatRoomQRCode;
- (void)shareQRCode:(id)arg1;
- (void)userDidTakeScreenshot:(id)arg1;
- (void)viewDidLayoutSubviews;
- (void)viewDidLoad;
- (void)willAppear;
// Remaining properties
@property(readonly, copy) NSString *debugDescription;
@property(readonly, copy) NSString *description;
@property(readonly) unsigned long long hash;
@property(readonly) Class superclass;
@end
| 29.460317 | 115 | 0.765625 |
aef690e84c32051fdf5047ee1879e9f8d1ceb11b | 2,597 | h | C | System/Library/Frameworks/HealthKit.framework/HKWorkoutEvent.h | lechium/iOS1351Headers | 6bed3dada5ffc20366b27f7f2300a24a48a6284e | [
"MIT"
] | 2 | 2021-11-02T09:23:27.000Z | 2022-03-28T08:21:57.000Z | System/Library/Frameworks/HealthKit.framework/HKWorkoutEvent.h | lechium/iOS1351Headers | 6bed3dada5ffc20366b27f7f2300a24a48a6284e | [
"MIT"
] | null | null | null | System/Library/Frameworks/HealthKit.framework/HKWorkoutEvent.h | lechium/iOS1351Headers | 6bed3dada5ffc20366b27f7f2300a24a48a6284e | [
"MIT"
] | 1 | 2022-03-28T08:21:59.000Z | 2022-03-28T08:21:59.000Z | /*
* This header is generated by classdump-dyld 1.5
* on Friday, April 30, 2021 at 11:37:07 AM Mountain Standard Time
* Operating System: Version 13.5.1 (Build 17F80)
* Image Source: /System/Library/Frameworks/HealthKit.framework/HealthKit
* classdump-dyld is licensed under GPLv3, Copyright © 2013-2016 by Elias Limneos. Updated by Kevin Bradley.
*/
#import <HealthKit/HealthKit-Structs.h>
#import <libobjc.A.dylib/HKPersistableWorkoutEvent.h>
#import <libobjc.A.dylib/NSSecureCoding.h>
#import <libobjc.A.dylib/NSCopying.h>
@class NSUUID, NSDateInterval, NSError, NSDictionary, NSDate;
@interface HKWorkoutEvent : NSObject <HKPersistableWorkoutEvent, NSSecureCoding, NSCopying> {
long long _type;
NSDateInterval* _dateInterval;
NSDictionary* _metadata;
}
@property (readonly) long long type;
@property (copy,readonly) NSDate * date;
@property (copy,readonly) NSDateInterval * dateInterval; //@synthesize dateInterval=_dateInterval - In the implementation block
@property (copy,readonly) NSDictionary * metadata; //@synthesize metadata=_metadata - In the implementation block
@property (nonatomic,copy,readonly) NSUUID * sessionUUID;
@property (nonatomic,readonly) long long workoutEventType;
@property (nonatomic,copy,readonly) NSError * error;
+(BOOL)supportsSecureCoding;
+(id)_workoutEventWithInternalEvent:(id)arg1 ;
+(id)_newWorkoutEventWithType:(long long)arg1 dateInterval:(id)arg2 metadata:(id)arg3 ;
+(id)workoutEventWithType:(long long)arg1 dateInterval:(id)arg2 metadata:(id)arg3 ;
+(id)_workoutEventWithType:(long long)arg1 date:(id)arg2 metadata:(id)arg3 ;
+(id)_workoutEventWithType:(long long)arg1 dateInterval:(id)arg2 metadata:(id)arg3 ;
+(id)workoutEventWithType:(long long)arg1 date:(id)arg2 ;
+(id)workoutEventWithType:(long long)arg1 date:(id)arg2 metadata:(id)arg3 ;
-(id)init;
-(BOOL)isEqual:(id)arg1 ;
-(unsigned long long)hash;
-(id)description;
-(id)copyWithZone:(NSZone*)arg1 ;
-(long long)type;
-(long long)compare:(id)arg1 ;
-(void)encodeWithCoder:(id)arg1 ;
-(id)initWithCoder:(id)arg1 ;
-(NSDate *)date;
-(id)_init;
-(NSError *)error;
-(id)awakeAfterUsingCoder:(id)arg1 ;
-(NSDictionary *)metadata;
-(NSDateInterval *)dateInterval;
-(id)_validateConfiguration;
-(NSUUID *)sessionUUID;
-(void)_assertPropertiesValid;
-(id)initWithWorkoutEventType:(long long)arg1 sessionUUID:(id)arg2 dateInterval:(id)arg3 metadata:(id)arg4 error:(id)arg5 ;
-(long long)workoutEventType;
@end
| 42.57377 | 142 | 0.719677 |
aef6e65729b074321531cc7590a6a5e51cace31a | 2,583 | c | C | vendor/openssl/ssl/t1_hash.c | simnalamburt/ruby-packer | 0b8acf9b869760cd1420d579e2dd4e2d7520875b | [
"MIT"
] | 34 | 2015-02-04T18:03:14.000Z | 2020-11-10T06:45:28.000Z | vendor/openssl/ssl/t1_hash.c | simnalamburt/ruby-packer | 0b8acf9b869760cd1420d579e2dd4e2d7520875b | [
"MIT"
] | 5 | 2015-06-30T21:17:00.000Z | 2016-06-14T22:31:51.000Z | vendor/openssl/ssl/t1_hash.c | simnalamburt/ruby-packer | 0b8acf9b869760cd1420d579e2dd4e2d7520875b | [
"MIT"
] | 15 | 2015-10-29T14:21:58.000Z | 2022-01-19T07:33:14.000Z | /* $OpenBSD: t1_hash.c,v 1.2 2017/05/06 16:18:36 jsing Exp $ */
/*
* Copyright (c) 2017 Joel Sing <jsing@openbsd.org>
*
* Permission to use, copy, modify, and 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.
*/
#include "ssl_locl.h"
#include <openssl/ssl.h>
int
tls1_handshake_hash_init(SSL *s)
{
const EVP_MD *md;
long dlen;
void *data;
tls1_handshake_hash_free(s);
if (!ssl_get_handshake_evp_md(s, &md)) {
SSLerrorx(ERR_R_INTERNAL_ERROR);
goto err;
}
if ((S3I(s)->handshake_hash = EVP_MD_CTX_create()) == NULL) {
SSLerror(s, ERR_R_MALLOC_FAILURE);
goto err;
}
if (!EVP_DigestInit_ex(S3I(s)->handshake_hash, md, NULL)) {
SSLerror(s, ERR_R_EVP_LIB);
goto err;
}
dlen = BIO_get_mem_data(S3I(s)->handshake_buffer, &data);
if (dlen <= 0) {
SSLerror(s, SSL_R_BAD_HANDSHAKE_LENGTH);
goto err;
}
if (!tls1_handshake_hash_update(s, data, dlen)) {
SSLerror(s, ERR_R_EVP_LIB);
goto err;
}
return 1;
err:
tls1_handshake_hash_free(s);
return 0;
}
int
tls1_handshake_hash_update(SSL *s, const unsigned char *buf, size_t len)
{
if (S3I(s)->handshake_hash == NULL)
return 1;
return EVP_DigestUpdate(S3I(s)->handshake_hash, buf, len);
}
int
tls1_handshake_hash_value(SSL *s, const unsigned char *out, size_t len,
size_t *outlen)
{
EVP_MD_CTX *mdctx = NULL;
unsigned int mdlen;
int ret = 0;
if (EVP_MD_CTX_size(S3I(s)->handshake_hash) > len)
goto err;
if ((mdctx = EVP_MD_CTX_create()) == NULL) {
SSLerror(s, ERR_R_MALLOC_FAILURE);
goto err;
}
if (!EVP_MD_CTX_copy_ex(mdctx, S3I(s)->handshake_hash)) {
SSLerror(s, ERR_R_EVP_LIB);
goto err;
}
if (!EVP_DigestFinal_ex(mdctx, (unsigned char *)out, &mdlen)) {
SSLerror(s, ERR_R_EVP_LIB);
goto err;
}
if (outlen != NULL)
*outlen = mdlen;
ret = 1;
err:
EVP_MD_CTX_destroy(mdctx);
return (ret);
}
void
tls1_handshake_hash_free(SSL *s)
{
EVP_MD_CTX_destroy(S3I(s)->handshake_hash);
S3I(s)->handshake_hash = NULL;
}
| 23.0625 | 75 | 0.711576 |
aef781e8476d130f0794e20e962698add00b3c05 | 4,535 | h | C | usr/src/sbin/fdisk/mbrcode.h | sizeofvoid/ifconfigd | bdff4b2cec6d572c1450cb44f32c0bdab1b49e5f | [
"BSD-2-Clause"
] | 2 | 2020-04-15T13:39:01.000Z | 2020-08-28T01:27:00.000Z | usr/src/sbin/fdisk/mbrcode.h | sizeofvoid/ifconfigd | bdff4b2cec6d572c1450cb44f32c0bdab1b49e5f | [
"BSD-2-Clause"
] | null | null | null | usr/src/sbin/fdisk/mbrcode.h | sizeofvoid/ifconfigd | bdff4b2cec6d572c1450cb44f32c0bdab1b49e5f | [
"BSD-2-Clause"
] | 1 | 2020-08-28T01:25:41.000Z | 2020-08-28T01:25:41.000Z | /* $OpenBSD: mbrcode.h,v 1.3 2004/01/07 00:38:39 tom Exp $ */
/*
* Copyright (c) 2000 Tobias Weingartner
* 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.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
*/
/* Largely generated by:
* hexdump -ve '8/1 "0x%02x, " "\n"' /usr/mdec/mbr
*/
0xea, 0x05, 0x00, 0xc0, 0x07, 0x8c, 0xc8, 0x8e,
0xd0, 0xbc, 0xfc, 0xff, 0x8e, 0xd8, 0xb8, 0xa0,
0x07, 0x8e, 0xc0, 0x31, 0xf6, 0x31, 0xff, 0xb9,
0x00, 0x02, 0xfc, 0xf3, 0xa4, 0xea, 0x22, 0x00,
0xa0, 0x07, 0x1e, 0x07, 0x0e, 0x1f, 0xb4, 0x02,
0xcd, 0x16, 0xa8, 0x03, 0x74, 0x0a, 0xb0, 0x07,
0xe8, 0xcb, 0x00, 0x80, 0x0e, 0xb4, 0x01, 0x01,
0xf6, 0xc2, 0x80, 0x75, 0x08, 0xbe, 0x36, 0x01,
0xe8, 0xaf, 0x00, 0xb2, 0x80, 0xbe, 0xbe, 0x01,
0xb9, 0x04, 0x00, 0x8a, 0x04, 0x3c, 0x80, 0x74,
0x0f, 0x83, 0xc6, 0x10, 0xe2, 0xf5, 0xbe, 0x6a,
0x01, 0xe8, 0x96, 0x00, 0xfa, 0xf4, 0xeb, 0xfc,
0x88, 0xd0, 0x24, 0x0f, 0x04, 0x30, 0xa2, 0x27,
0x01, 0xb0, 0x34, 0x28, 0xc8, 0xa2, 0x34, 0x01,
0x56, 0xbe, 0x1a, 0x01, 0xf6, 0x06, 0xb4, 0x01,
0x01, 0x75, 0x01, 0x46, 0xe8, 0x73, 0x00, 0x5e,
0x26, 0xc7, 0x06, 0xfe, 0x01, 0x00, 0x00, 0xf6,
0x06, 0xb4, 0x01, 0x01, 0x75, 0x31, 0x88, 0x14,
0xbb, 0xaa, 0x55, 0xb4, 0x41, 0xcd, 0x13, 0x8a,
0x14, 0x72, 0x24, 0x81, 0xfb, 0x55, 0xaa, 0x75,
0x1e, 0xf6, 0xc1, 0x01, 0x74, 0x19, 0xb0, 0x2e,
0xe8, 0x53, 0x00, 0x66, 0x8b, 0x4c, 0x08, 0x66,
0x89, 0x0e, 0x12, 0x01, 0x56, 0xb4, 0x42, 0xbe,
0x0a, 0x01, 0xcd, 0x13, 0x5e, 0x73, 0x19, 0xb0,
0x3b, 0xe8, 0x3a, 0x00, 0x8a, 0x74, 0x01, 0x8b,
0x4c, 0x02, 0xb8, 0x01, 0x02, 0x31, 0xdb, 0xcd,
0x13, 0x73, 0x05, 0xbe, 0x52, 0x01, 0xeb, 0x81,
0xbe, 0x7d, 0x01, 0xe8, 0x14, 0x00, 0x26, 0x81,
0x3e, 0xfe, 0x01, 0x55, 0xaa, 0x75, 0x05, 0xea,
0x00, 0x7c, 0x00, 0x00, 0xbe, 0x61, 0x01, 0xe9,
0x67, 0xff, 0x50, 0xfc, 0xac, 0x84, 0xc0, 0x74,
0x0f, 0xe8, 0x02, 0x00, 0xeb, 0xf6, 0x50, 0x53,
0xb4, 0x0e, 0xbb, 0x01, 0x00, 0xcd, 0x10, 0x5b,
0x58, 0xc3, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00,
0xc0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x21, 0x55, 0x73, 0x69, 0x6e, 0x67,
0x20, 0x64, 0x72, 0x69, 0x76, 0x65, 0x20, 0x58,
0x2c, 0x20, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74,
0x69, 0x6f, 0x6e, 0x20, 0x59, 0x00, 0x4d, 0x42,
0x52, 0x20, 0x6f, 0x6e, 0x20, 0x66, 0x6c, 0x6f,
0x70, 0x70, 0x79, 0x20, 0x6f, 0x72, 0x20, 0x6f,
0x6c, 0x64, 0x20, 0x42, 0x49, 0x4f, 0x53, 0x0d,
0x0a, 0x00, 0x0d, 0x0a, 0x52, 0x65, 0x61, 0x64,
0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x0d, 0x0a,
0x00, 0x4e, 0x6f, 0x20, 0x4f, 0x2f, 0x53, 0x0d,
0x0a, 0x00, 0x4e, 0x6f, 0x20, 0x61, 0x63, 0x74,
0x69, 0x76, 0x65, 0x20, 0x70, 0x61, 0x72, 0x74,
0x69, 0x74, 0x69, 0x6f, 0x6e, 0x0d, 0x0a, 0x00,
0x90, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4f, 0x78,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00,
0x01, 0x00, 0xa6, 0xff, 0xff, 0xff, 0x00, 0x00,
0x00, 0x00, 0xff, 0xff, 0xff, 0x7f, 0x55, 0xaa
| 48.763441 | 76 | 0.693054 |
aef813273f4ef20d853a7b2e6c52ba74124da2e9 | 5,102 | c | C | src/lib/crypto/t_cts.c | zapfbandit/krb5 | 02f6ef7257c2b2d5a2db3d570944ba3cfa9319ee | [
"MIT",
"Unlicense"
] | null | null | null | src/lib/crypto/t_cts.c | zapfbandit/krb5 | 02f6ef7257c2b2d5a2db3d570944ba3cfa9319ee | [
"MIT",
"Unlicense"
] | null | null | null | src/lib/crypto/t_cts.c | zapfbandit/krb5 | 02f6ef7257c2b2d5a2db3d570944ba3cfa9319ee | [
"MIT",
"Unlicense"
] | null | null | null | /*
* lib/crypto/vectors.c
*
* Copyright 2001, 2007 by the Massachusetts Institute of Technology.
* All Rights Reserved.
*
* Export of this software from the United States of America may
* require a specific license from the United States Government.
* It is the responsibility of any person or organization contemplating
* export to obtain such a license before exporting.
*
* WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
* distribute this software and its documentation for any purpose and
* without fee is hereby granted, provided that the above copyright
* notice appear in all copies and that both that copyright notice and
* this permission notice appear in supporting documentation, and that
* the name of M.I.T. not be used in advertising or publicity pertaining
* to distribution of the software without specific, written prior
* permission. Furthermore if you modify this software you must label
* your software as modified software and not distribute it in such a
* fashion that it might be confused with the original M.I.T. software.
* M.I.T. makes no representations about the suitability of
* this software for any purpose. It is provided "as is" without express
* or implied warranty.
*
*
* Test vectors for crypto code, matching data submitted for inclusion
* with RFC1510bis.
*
* N.B.: Doesn't compile -- this file uses some routines internal to our
* crypto library which are declared "static" and thus aren't accessible
* without modifying the other sources.
*/
#include <assert.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include "hash_provider.h"
#define ASIZE(ARRAY) (sizeof(ARRAY)/sizeof(ARRAY[0]))
const char *whoami;
static void printhex (size_t len, const char *p)
{
while (len--)
printf ("%02x", 0xff & *p++);
}
static void printstringhex (const char *p) { printhex (strlen (p), p); }
static void printdata (krb5_data *d) { printhex (d->length, d->data); }
static void printkey (krb5_keyblock *k) { printhex (k->length, k->contents); }
#define JURISIC "Juri\305\241i\304\207" /* hi Miro */
#define ESZETT "\303\237"
#define GCLEF "\360\235\204\236" /* outside BMP, woo hoo! */
static void
keyToData (krb5_keyblock *k, krb5_data *d)
{
d->length = k->length;
d->data = k->contents;
}
void check_error (int r, int line) {
if (r != 0) {
fprintf (stderr, "%s:%d: %s\n", __FILE__, line,
error_message (r));
exit (1);
}
}
#define CHECK check_error(r, __LINE__)
extern struct krb5_enc_provider krb5int_enc_des3;
struct krb5_enc_provider *enc = &krb5int_enc_des3;
extern struct krb5_enc_provider krb5int_enc_aes128, krb5int_enc_aes256;
static void printd (const char *descr, krb5_data *d) {
int i, j;
const int r = 16;
printf("%s:", descr);
for (i = 0; i < d->length; i += r) {
printf("\n %04x: ", i);
for (j = i; j < i + r && j < d->length; j++)
printf(" %02x", 0xff & d->data[j]);
#ifdef SHOW_TEXT
for (; j < i + r; j++)
printf(" ");
printf(" ");
for (j = i; j < i + r && j < d->length; j++) {
int c = 0xff & d->data[j];
printf("%c", isprint(c) ? c : '.');
}
#endif
}
printf("\n");
}
static void printk(const char *descr, krb5_keyblock *k) {
krb5_data d;
d.data = k->contents;
d.length = k->length;
printd(descr, &d);
}
static void test_cts()
{
static const char input[4*16] =
"I would like the General Gau's Chicken, please, and wonton soup.";
static const unsigned char aeskey[16] = "chicken teriyaki";
static const int lengths[] = { 17, 31, 32, 47, 48, 64 };
extern krb5_error_code krb5int_aes_encrypt(const krb5_keyblock *,
const krb5_data *,
const krb5_data *,
krb5_data *);
int i;
char outbuf[64], encivbuf[16], decivbuf[16], outbuf2[64];
krb5_data in, out, enciv, deciv, out2;
krb5_keyblock key;
krb5_error_code err;
in.data = input;
out.data = outbuf;
out2.data = outbuf2;
enciv.length = deciv.length = 16;
enciv.data = encivbuf;
deciv.data = decivbuf;
key.contents = aeskey;
key.length = 16;
memset(enciv.data, 0, 16);
printk("AES 128-bit key", &key);
for (i = 0; i < sizeof(lengths)/sizeof(lengths[0]); i++) {
memset(enciv.data, 0, 16);
memset(deciv.data, 0, 16);
printf("\n");
in.length = out.length = lengths[i];
printd("IV", &enciv);
err = krb5int_aes_encrypt(&key, &enciv, &in, &out);
if (err) {
printf("error %ld from krb5int_aes_encrypt\n", (long)err);
exit(1);
}
printd("Input", &in);
printd("Output", &out);
printd("Next IV", &enciv);
out2.length = out.length;
err = krb5int_aes_decrypt(&key, &deciv, &out, &out2);
if (err) {
printf("error %ld from krb5int_aes_decrypt\n", (long)err);
exit(1);
}
if (!data_eq(out2, in)) {
printd("Decryption result DOESN'T MATCH", &out2);
exit(1);
}
if (memcmp(enciv.data, deciv.data, 16)) {
printd("Decryption IV result DOESN'T MATCH", &deciv);
exit(1);
}
}
}
int main (int argc, char **argv)
{
whoami = argv[0];
test_cts();
return 0;
}
| 28.824859 | 78 | 0.651901 |
aef9efe680ca827ec4764dba12be73d4fecaea56 | 10,796 | h | C | Stereolabs/Source/Stereolabs/Public/Utilities/StereolabsFunctionLibrary.h | stereolabs/zed-unreal-plugin | 0fabf29edc84db1126f0c4f73b9ce501e322be96 | [
"MIT"
] | 38 | 2018-02-27T22:53:56.000Z | 2022-02-10T05:46:51.000Z | Stereolabs/Source/Stereolabs/Public/Utilities/StereolabsFunctionLibrary.h | stereolabs/zed-unreal-plugin | 0fabf29edc84db1126f0c4f73b9ce501e322be96 | [
"MIT"
] | 14 | 2018-05-26T03:15:16.000Z | 2022-03-02T14:34:10.000Z | Stereolabs/Source/Stereolabs/Public/Utilities/StereolabsFunctionLibrary.h | stereolabs/zed-unreal-plugin | 0fabf29edc84db1126f0c4f73b9ce501e322be96 | [
"MIT"
] | 16 | 2018-01-23T22:55:34.000Z | 2021-12-20T18:34:08.000Z | //======= Copyright (c) Stereolabs Corporation, All rights reserved. ===============
#pragma once
#include "Engine.h"
#include "kismet/BlueprintFunctionLibrary.h"
#include "Stereolabs/Public/Core/StereolabsCoreGlobals.h"
#include "Stereolabs/Public/Core/StereolabsCameraProxy.h"
#include "StereolabsFunctionLibrary.generated.h"
DECLARE_LOG_CATEGORY_EXTERN(SLFunctionLibrary, Log, All);
UCLASS()
class STEREOLABS_API USlFunctionLibrary : public UBlueprintFunctionLibrary
{
GENERATED_BODY()
public:
/*
* Retrieve the camera proxy instance. Can be null.
* @return The camera proxy instance
*/
UFUNCTION(BlueprintPure, meta = (DisplayName = "GetCameraProxy", Keywords = "get zed camera proxy"), Category = "Stereolabs")
static USlCameraProxy* GetCameraProxy()
{
return GSlCameraProxy;
}
/*
* @return True if in grab thread
*/
UFUNCTION(BlueprintPure, meta = (DisplayName = "IsInGrabThread", Keywords = "get zed in grab thread"), Category = "Stereolabs")
static bool IsInGrabThread()
{
return IsInSlGrabThread();
}
/*
* Convert a depth retrieved using GetDepth to the distance from camera
* @param ViewportHelper The viewport helper of the current view
* @param ScreenPosition The screen position of the depth
* @param Depth The depth
* @return The distance from the camera
*/
UFUNCTION(BlueprintPure, meta = (DisplayName = "ConvertDepthToDistance", Keywords = "get zed depth to distance"), Category = "Stereolabs")
static float ConvertDepthToDistance(const FSlViewportHelper& ViewportHelper, const FVector2D& ScreenPosition, float Depth);
/*
* Convert a depth to the distance from camera
* @param CameraParameters The camera parameters used to retrieve the depth
* @param Position The position of the depth in the depth mat
* @param Depth The depth
* @return The distance from the camera
*/
UFUNCTION(BlueprintPure, meta = (DisplayName = "ConvertCustomDepthToDistance", Keywords = "get zed depth to distance"), Category = "Stereolabs")
static float ConvertCustomDepthToDistance(const FSlCameraParameters& CameraParameters, const FVector2D& Position, float Depth);
/*
* Compute rendering plane size
* @param VerticalFOV Zed vertical FOV
* @param PlaneDistance Plane rendering distance from camera
* @param ImageResolution Zed image resolution
* @return size width/height of the plane
*/
UFUNCTION(BlueprintPure, meta = (DisplayName = "GetRenderPlaneSize", Keywords = "get zed render plane size"), Category = "Stereolabs")
static FVector2D GetRenderPlaneSize(const FIntPoint& ImageResolution, float VerticalFOV, float PlaneDistance);
/*
* Compute rendering plane size using gamma
* @param PerceptionDistance The distance at which objects will have their correct size
* @param ImageResolution Zed image resolution
* @param PerceptionDistance Distance at which object match their real size
* @param ZedFocal Zed focal
* @param PlaneDistance Plane rendering distance from camera
* @return size width/height of the plane
*/
UFUNCTION(BlueprintPure, meta = (WorldContext = "WorldContextObject", DisplayName = "GetRenderPlaneSizeWithGamma", Keywords = "get zed render plane size with gamma"), Category = "Stereolabs")
static FVector2D GetRenderPlaneSizeWithGamma(UObject* WorldContextObject, const FIntPoint& ImageResolution, float PerceptionDistance, float ZedFocal, float PlaneDistance);
/*
* Compute optical center offsets for left/right images
* @paramI mageResolution Zed image resolution
* @param Distance Distance from camera
* @return the x/y offset for each eye
*/
UFUNCTION(BlueprintPure, meta = (DisplayName = "GetOpticalCentersOffsets", Keywords = "get zed optical centers offsets"), Category = "Stereolabs")
static FVector4 GetOpticalCentersOffsets(const FIntPoint& ImageResolution, float Distance);
/*
* Get the optical center offset for the selected eye
* @param Eye The eye
* @return The offsets
*/
UFUNCTION(BlueprintPure, meta = (DisplayName = "GetOffCenterProjectionOffset", Keywords = "get zed off center projection offset"), Category = "Stereolabs")
static FVector2D GetOffCenterProjectionOffset(ESlEye Eye = ESlEye::E_Left);
/*
* Get the projection matrix for a scene capture
* @param ProjectionMatrix The projection matrix
* @param Eye The eye
*/
UFUNCTION(BlueprintPure, meta = (DisplayName = "GetSceneCaptureProjectionMatrix", Keywords = "get zed projection matrix"), Category = "Stereolabs")
static void GetSceneCaptureProjectionMatrix(FMatrix& ProjectionMatrix, ESlEye Eye = ESlEye::E_Left);
/*
* Convert sl::ERROR_CODE to string
* @param ErrorCode The sl:ERROR_CODE to convert
* @return The converted string
*/
UFUNCTION(BlueprintPure, meta = (DisplayName = "ErrorCodeToString", Keywords = "zed error code to string"), Category = "Stereolabs")
static FString ErrorCodeToString(ESlErrorCode ErrorCode);
/*
* Set the resolution of a FZEDSpatialMappingParameters struct
* @param NewResolution The new resolution
*/
UFUNCTION(BlueprintCallable, meta = (DisplayName = "SetResolution", Keywords = "set resolution"), Category = "Stereolabs")
static void SetResolutionPreset(UPARAM(ref) FSlSpatialMappingParameters& SpatialMappingParameters, ESlSpatialMappingResolution NewResolution)
{
SpatialMappingParameters.SetResolution(NewResolution);
}
/*
* Set the resolution of a FSlSpatialMappingParameters struct
* @param NewResolution The new resolution
*/
UFUNCTION(BlueprintCallable, meta = (DisplayName = "SetResolution", Keywords = "set resolution"), Category = "Stereolabs")
static void SetResolutionValue(UPARAM(ref) FSlSpatialMappingParameters& SpatialMappingParameters, float NewResolution)
{
SpatialMappingParameters.SetResolution(NewResolution);
}
/*
* Set the max range of a FSlSpatialMappingParameters struct
* @param NewMaxRange The new max range
*/
UFUNCTION(BlueprintCallable, meta = (DisplayName = "SetMaxRange", Keywords = "set max range"), Category = "Stereolabs")
static void SetMaxRangePreset(UPARAM(ref) FSlSpatialMappingParameters& SpatialMappingParameters, ESlSpatialMappingRange NewMaxRange)
{
SpatialMappingParameters.SetMaxRange(NewMaxRange);
}
/*
* Set the max range of a FSlSpatialMappingParameters struct
* @param NewMaxRange The new max range
*/
UFUNCTION(BlueprintCallable, meta = (DisplayName = "SetMaxRange", Keywords = "set max range"), Category = "Stereolabs")
static void SetMaxRangeValue(UPARAM(ref) FSlSpatialMappingParameters& SpatialMappingParameters, float NewMaxRange)
{
SpatialMappingParameters.SetMaxRange(NewMaxRange);
}
/*
* Set the min range of a FSlSpatialMappingParameters struct
* @param SpatialMappingParameters The struct
* @param NewMinRange The new min range
*/
/*UFUNCTION(BlueprintCallable, meta = (DisplayName = "SetMinRange", Keywords = "set min range"), Category = "Stereolabs")
static void SetMinRangeValue(FSlSpatialMappingParameters& SpatialMappingParameters, float NewMinRange)
{
SpatialMappingParameters.SetMinRange(NewMinRange);
}*/
/*
* Clear mesh data
*/
UFUNCTION(BlueprintCallable, meta = (DisplayName = "ClearMeshData", Keywords = "clear mesh data"), Category = "Stereolabs")
static void ClearMeshData(UPARAM(ref) FSlMeshData& MeshData)
{
MeshData.Clear();
}
/** Converts a FSlTimestamp into a string */
UFUNCTION(BlueprintPure, meta = (DisplayName = "ToString (SlTimestamp)", CompactNodeTitle = "->", BlueprintAutocast), Category = "Stereolabs")
static FString Conv_TimestampToString(const FSlTimestamp& InTimestamp)
{
return InTimestamp.ToString();
}
/** return true if A is equal to B (A == B) */
UFUNCTION(BlueprintPure, meta = (DisplayName = "== (timestamp)", CompactNodeTitle = "==", Keywords = "=="), Category = "Stereolabs")
static bool EqualEqual_TimestampTimestamp(const FSlTimestamp& A, const FSlTimestamp& B)
{
return A.timestamp.data_ns == B.timestamp.data_ns;
}
/** return true if A is not equal to B (A != B) */
UFUNCTION(BlueprintPure, meta = (DisplayName = "!= (timestamp)", CompactNodeTitle = "!=", Keywords = "!="), Category = "Stereolabs")
static bool NotEqual_TimestampTimestamp(const FSlTimestamp& A, const FSlTimestamp& B)
{
return A.timestamp.data_ns != B.timestamp.data_ns;
}
/** return true if A is less than B (A < B) */
UFUNCTION(BlueprintPure, meta = (DisplayName = "< (timestamp)", CompactNodeTitle = "<", Keywords = "<"), Category = "Stereolabs")
static bool Less_TimestampTimestamp(const FSlTimestamp& A, const FSlTimestamp& B)
{
return A.timestamp.data_ns < B.timestamp.data_ns;
}
/** return true if A is less than or equal to B (A <= B) */
UFUNCTION(BlueprintPure, meta = (DisplayName = "<= (timestamp)", CompactNodeTitle = "<=", Keywords = "<="), Category = "Stereolabs")
static bool LessEqual_TimestampTimestamp(const FSlTimestamp& A, const FSlTimestamp& B)
{
return A.timestamp.data_ns <= B.timestamp.data_ns;
}
/** return true if A is greater than B (A > B) */
UFUNCTION(BlueprintPure, meta = (DisplayName = "> (timestamp)", CompactNodeTitle = ">", Keywords = ">"), Category = "Stereolabs")
static bool Greater_TimestampTimestamp(const FSlTimestamp& A, const FSlTimestamp& B)
{
return A.timestamp.data_ns > B.timestamp.data_ns;
}
/** return true if A is greater than or equal to B (A >= B) */
UFUNCTION(BlueprintPure, meta = (DisplayName = ">= (timestamp)", CompactNodeTitle = ">=", Keywords = ">="), Category = "Stereolabs")
static bool GreaterEqual_TimestampTimestamp(const FSlTimestamp& A, const FSlTimestamp& B)
{
return A.timestamp.data_ns >= B.timestamp.data_ns;
}
/** Addition (A + B) */
UFUNCTION(BlueprintPure, meta = (DisplayName = "timestamp + timestamp", CompactNodeTitle = "+", Keywords = "+ add plus"), Category = "Stereolabs")
static FSlTimestamp Add_TimestampTimestamp(const FSlTimestamp& A, const FSlTimestamp& B)
{
return FSlTimestamp(A.timestamp + B.timestamp);
}
/** Subtraction (A - B) */
UFUNCTION(BlueprintPure, meta = (DisplayName = "timestamp - timestamp", CompactNodeTitle = "-", Keywords = "- substract minus"), Category = "Stereolabs")
static FSlTimestamp Substract_TimestampTimestamp(const FSlTimestamp& A, const FSlTimestamp& B)
{
return FSlTimestamp(A.timestamp - B.timestamp);
}
/** Generate texture from txt file */
UFUNCTION(BlueprintCallable, meta = (DisplayName = "GenerateTextureFromTxtFile", Keywords = "texture"), Category = "Stereolabs")
static UTexture2D* GenerateTextureFromTxtFile(const FString filepath);
static UTexture2D* GenerateTextureFromSlMat(const sl::Mat* mat);
/** Return HMD HFocal et VFocal lenght*/
UFUNCTION(BlueprintPure, meta = (DisplayName = "HmdFocal", Keywords = "Focal"), Category = "Stereolabs")
static FVector2D GetHmdFocale();
}; | 43.708502 | 192 | 0.744442 |
aefd4e5db4fc111802c041cb3d361207d3842acc | 1,294 | h | C | projects/client/general/resourceful/source/resourceful/Resource_Manager.h | silentorb/mythic-cpp | 97319d158800d77e1a944c47c13523662bc07e08 | [
"MIT"
] | null | null | null | projects/client/general/resourceful/source/resourceful/Resource_Manager.h | silentorb/mythic-cpp | 97319d158800d77e1a944c47c13523662bc07e08 | [
"MIT"
] | null | null | null | projects/client/general/resourceful/source/resourceful/Resource_Manager.h | silentorb/mythic-cpp | 97319d158800d77e1a944c47c13523662bc07e08 | [
"MIT"
] | null | null | null | #pragma once
#include <vector>
#include "Resource.h"
#include <memory>
#include <string>
using namespace std;
namespace resourceful {
class Resource_Manager {
const string name;
vector<unique_ptr<Resource>> resources;
Resource_Manager &operator=(const Resource_Manager &) = delete;
Resource_Manager(Resource_Manager const &) = delete;
public:
Resource_Manager(const string name) : name(name) {}
~Resource_Manager();
// void free() override;
// void load() override;
void release() {
for (auto &resource: resources) {
resource->release();
}
}
void load() {
for (auto &resource: resources) {
resource->load();
}
}
void add_resource(Resource *resource) {
resources.push_back(unique_ptr<Resource>(resource));
}
void add_resource(std::unique_ptr<Resource> resource) {
resources.push_back(std::move(resource));
}
void remove_resource(Resource *resource);
vector<unique_ptr<Resource>>::iterator begin() {
return resources.begin();
}
vector<unique_ptr<Resource>>::iterator end() {
return resources.end();
}
};
}
| 21.566667 | 70 | 0.580371 |
aefd5b4ca008a90ff50d85ef8b0aa129cade1170 | 6,706 | h | C | src/bin/fl/fsm.h | mfernan2/VossII | e1c1142c9c94255995c13efe2e1b7af4ae03f2e2 | [
"Apache-2.0"
] | null | null | null | src/bin/fl/fsm.h | mfernan2/VossII | e1c1142c9c94255995c13efe2e1b7af4ae03f2e2 | [
"Apache-2.0"
] | null | null | null | src/bin/fl/fsm.h | mfernan2/VossII | e1c1142c9c94255995c13efe2e1b7af4ae03f2e2 | [
"Apache-2.0"
] | null | null | null | //-------------------------------------------------------------------
// Copyright 2020 Carl-Johan Seger
// SPDX-License-Identifier: Apache-2.0
//-------------------------------------------------------------------
/********************************************************************
* *
* Original author: Carl-Johan Seger 2019 *
* *
*********************************************************************/
/* fsm.h -- header for fsm.c */
#ifdef EXPORT_FORWARD_DECL
/* --- Forward declarations that need to be exported to earlier .h files --- */
typedef struct ilist_rec *ilist_ptr;
/* ----- Function prototypes for public functions ----- */
void Fsm_Init();
void Fsm_Install_Functions();
#else /* EXPORT_FORWARD_DECL */
/* ----------------------- Main include file ------------------------------- */
#ifndef FSM_H
#define FSM_H
#include "fl.h" /* Global data types and include files */
typedef struct ilist_rec {
int from;
int to;
int size;
ilist_ptr next;
} ilist_rec;
typedef union {
formula f;
bexpr bp;
arbi_T ai;
} gbv;
typedef struct vec_info_rec *vec_info_ptr;
typedef struct vec_info_rec {
string local_name;
string hierarchy;
vec_ptr declaration;
string signature;
int size:31;
unint transient:1;
ilist_ptr map;
string value_list;
} vec_info_rec;
typedef struct vis_io_rec *vis_io_ptr;
typedef struct vis_io_rec {
string f_vec;
ilist_ptr acts;
vis_io_ptr next;
} vis_io_rec;
typedef struct vis_rec *vis_ptr;
typedef struct vis_rec {
int draw_level;
int id;
string pfn; // Draw function
vis_io_ptr fa_inps;
vis_io_ptr fa_outs;
} vis_rec;
typedef struct vis_list_rec *vis_list_ptr;
typedef struct vis_list_rec {
vis_ptr vp;
vis_list_ptr next;
} vis_list_rec;
// FSM datastructure
typedef struct fsm_rec *fsm_ptr;
typedef struct fsm_rec {
int mark; // Used for g.c.
fsm_ptr next; // Only used for free list
// Real content
string sha256_sig;
string top_name;
int ranks;
hash_record all_name_tbl;
rec_mgr vec_info_rec_mgr;
rec_mgr ilist_rec_mgr;
rec_mgr vec_rec_mgr;
rec_mgr range_rec_mgr;
rec_mgr idx_list_rec_mgr;
buffer nodes;
buffer composites;
buffer top_inps;
buffer top_outs;
rec_mgr vis_io_rec_mgr;
rec_mgr vis_rec_mgr;
rec_mgr vis_list_rec_mgr;
} fsm_rec;
typedef struct ncomp_rec *ncomp_ptr;
typedef void (*wl_op)(ncomp_ptr);
typedef struct idx_list_rec *idx_list_ptr;
typedef struct idx_list_rec {
int idx;
idx_list_ptr next;
} idx_list_rec;
typedef struct mem_data_rec *mem_data_ptr;
typedef struct mem_data_rec {
int addr_size;
int lines;
int data_size;
} mem_data_rec;
// Individual composites
typedef struct ncomp_rec {
unint size;
unint rank:30;
unint phase_delay:1;
unint flag:1; // General purpose bit
wl_op op;
union {
arbi_T value;
string name;
int extension_size;
mem_data_rec mem;
idx_list_ptr idx_list;
} arg;
ilist_ptr inps;
ilist_ptr outs;
} ncomp_rec;
typedef struct nnode_rec *nnode_ptr;
typedef struct nnode_rec {
vec_info_ptr vec;
unint idx:27; // I think 134 million nodes are enough....
unint has_phase_event:1;
unint has_weak:1;
unint has_ant:1;
unint has_cons:1;
unint has_trace:1;
int composite:30;
unint is_top_input:1;
unint is_top_output:1;
idx_list_ptr fanouts;
vis_list_ptr draw_info;
} nnode_rec;
typedef enum {use_bdds, use_bexprs, use_ints} value_type;
typedef enum {
start_weak = 0,
start_ant = 1,
start_cons = 2,
start_trace = 3,
end_weak = 4,
end_ant = 5,
end_cons = 6,
end_trace = 7
} event_type;
typedef struct event_rec *event_ptr;
typedef struct event_rec {
event_type type;
int nd_idx;
int time;
gbv H;
gbv L;
} event_rec;
typedef struct weak_rec *weak_ptr;
typedef struct weak_rec {
gbv when;
int nd_idx;
int from;
int to;
} weak_rec;
typedef struct ant_rec *ant_ptr;
typedef struct ant_rec {
gbv when;
int nd_idx;
gbv value;
int from;
int to;
} ant_rec;
typedef struct trace_event_rec *trace_event_ptr;
typedef struct trace_event_rec {
int time;
gbv H;
gbv L;
trace_event_ptr next;
} trace_event_rec;
typedef struct trace_rec *trace_ptr;
typedef struct trace_rec {
int nd_idx;
trace_event_ptr events;
} trace_rec;
typedef struct ste_rec *ste_ptr;
typedef struct ste_rec {
int mark; // For g.c.
ste_ptr next; // Only used for free list
// Real content
fsm_ptr fsm;
value_type type;
bool active; // Currently being simulated
int max_time; // Time to which it is run
gbv validTrajectory;
gbv checkTrajectory;
gbv assertion_OK;
gbv check_OK;
hash_record trace_tbl;
rec_mgr trace_event_rec_mgr;
rec_mgr trace_rec_mgr;
} ste_rec;
// Simulation state
typedef struct state_rec *state_ptr;
typedef struct state_rec {
buffer values;
} state_rec;
typedef struct sch_rec *sch_ptr;
typedef struct sch_list_rec *sch_list_ptr;
typedef struct sch_list_rec {
sch_ptr sch;
sch_list_ptr next;
} sch_list_rec;
typedef struct sch_rec {
string vec;
string pfn;
sch_list_ptr children;
} sch_rec;
typedef struct sch_inst_rec *sch_inst_ptr;
typedef struct sch_inst_rec {
sch_ptr sch;
hash_record done;
buffer anon_buf;
sch_inst_ptr next;
} sch_inst_rec;
typedef struct vstate_rec *vstate_ptr;
typedef struct vstate_rec {
int mark; // For g.c.
vstate_ptr next; // Only used for free list
// Real content
fsm_ptr fsm; // Circuit
hash_record stop_nds;
hash_record ifc_nds;
rec_mgr sch_rec_mgr;
rec_mgr sch_list_rec_mgr;
rec_mgr sch_inst_rec_mgr;
//
sch_inst_ptr old_versions;
sch_ptr sch; // Draw tree
hash_record done;
buffer anon_buf;
} vstate_rec;
typedef struct node_comp_pair_rec *node_comp_pair_ptr;
typedef struct node_comp_pair_rec {
nnode_ptr np;
int comp_idx;
} node_comp_pair_rec;
#endif /* FSM_H */
#endif /* EXPORT_FORWARD_DECL */
| 24.035842 | 79 | 0.599612 |
aefd5e66630427863f45f1e2066120e79cab3d0d | 4,093 | h | C | components/autofill/core/browser/randomized_encoder.h | zealoussnow/chromium | fd8a8914ca0183f0add65ae55f04e287543c7d4a | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | 575 | 2015-06-18T23:58:20.000Z | 2022-03-23T09:32:39.000Z | components/autofill/core/browser/randomized_encoder.h | zealoussnow/chromium | fd8a8914ca0183f0add65ae55f04e287543c7d4a | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | 113 | 2015-05-04T09:58:14.000Z | 2022-01-31T19:35:03.000Z | components/autofill/core/browser/randomized_encoder.h | zealoussnow/chromium | fd8a8914ca0183f0add65ae55f04e287543c7d4a | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | 52 | 2015-07-14T10:40:50.000Z | 2022-03-15T01:11:49.000Z | // Copyright 2018 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef COMPONENTS_AUTOFILL_CORE_BROWSER_RANDOMIZED_ENCODER_H_
#define COMPONENTS_AUTOFILL_CORE_BROWSER_RANDOMIZED_ENCODER_H_
#include <memory>
#include <string>
#include "base/strings/string_piece.h"
#include "components/autofill/core/browser/proto/server.pb.h"
#include "components/autofill/core/common/signatures.h"
class PrefService;
namespace autofill {
// Encodes string values using the differential-privacy scheme as described
// in go/autofill-metadata-upload (Google internal link).
class RandomizedEncoder {
public:
struct EncodingInfo {
AutofillRandomizedValue_EncodingType encoding_type;
size_t chunk_length_in_bytes;
size_t bit_offset;
size_t bit_stride;
};
// Form-level data-type identifiers.
static const char FORM_ID[];
static const char FORM_NAME[];
static const char FORM_ACTION[];
static const char FORM_URL[];
static const char FORM_CSS_CLASS[];
static const char FORM_BUTTON_TITLES[];
// Field-level data-type identifiers.
static const char FIELD_ID[];
static const char FIELD_NAME[];
static const char FIELD_CONTROL_TYPE[];
static const char FIELD_LABEL[];
static const char FIELD_ARIA_LABEL[];
static const char FIELD_ARIA_DESCRIPTION[];
static const char FIELD_CSS_CLASS[];
static const char FIELD_PLACEHOLDER[];
static const char FIELD_INITIAL_VALUE_HASH[];
static const char kUrlKeyedAnonymizedDataCollectionEnabled[];
// Factory Function
static std::unique_ptr<RandomizedEncoder> Create(PrefService* pref_service);
RandomizedEncoder(std::string seed,
AutofillRandomizedValue_EncodingType encoding_type,
bool anonymous_url_collection_is_enabled);
// Encode |data_value| using this instance's |encoding_type_|.
// If |data_type!=FORM_URL|, the output value's length is limited by
// |kEncodedChunkLengthInBytes|.
std::string Encode(FormSignature form_signature,
FieldSignature field_signature,
base::StringPiece data_type,
base::StringPiece data_value) const;
// Used for testing, converts |data_value| to UTF-8 and calls Encode().
std::string EncodeForTesting(FormSignature form_signature,
FieldSignature field_signature,
base::StringPiece data_type,
base::StringPiece16 data_value) const;
AutofillRandomizedValue_EncodingType encoding_type() const {
DCHECK(encoding_info_);
return encoding_info_
? encoding_info_->encoding_type
: AutofillRandomizedValue_EncodingType_UNSPECIFIED_ENCODING_TYPE;
}
bool AnonymousUrlCollectionIsEnabled() const {
return anonymous_url_collection_is_enabled_;
}
protected:
// Get the pseudo-random string to use at the coin bit-field. This function
// is internal, but exposed here to facilitate testing.
std::string GetCoins(FormSignature form_signature,
FieldSignature field_signature,
base::StringPiece data_type,
int encoding_length) const;
// Get the pseudo-random string to use at the noise bit-field. This function
// is internal, but exposed here to facilitate testing.
std::string GetNoise(FormSignature form_signature,
FieldSignature field_signature,
base::StringPiece data_type,
int encoding_length) const;
// For |data_type==FORM_URL|, returns required chunk count to fit
// |data_value|, but max |kMaxChunks|. Otherwise, returns 1.
int GetChunkCount(base::StringPiece data_value,
base::StringPiece data_type) const;
private:
const std::string seed_;
const EncodingInfo* const encoding_info_;
const bool anonymous_url_collection_is_enabled_;
};
} // namespace autofill
#endif // COMPONENTS_AUTOFILL_CORE_BROWSER_RANDOMIZED_ENCODER_H_
| 37.550459 | 80 | 0.717567 |