text stringlengths 8 4.13M |
|---|
use bytes::Bytes;
use std::error::Error;
use zmq_rs::{Socket, SocketType};
use zmq_rs::{SubSocket, ZmqMessage};
#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
let mut socket = zmq_rs::SubSocket::connect("127.0.0.1:5556")
.await
.expect("Failed to connect");
socket.subscribe("").await?;
for i in 0..10 {
println!("Message {}", i);
let data = socket.recv().await?;
let repl = String::from_utf8(data)?;
dbg!(repl);
}
Ok(())
}
|
use anyhow::Error;
use futures::StreamExt;
use std::sync::Arc;
use tokio::net::{TcpListener, TcpStream};
use tokio::sync::Mutex as AsyncMutex;
use tokio_stream::wrappers::TcpListenerStream;
use tokio_tungstenite::tungstenite::handshake::server::{Request, Response};
use tokio_tungstenite::WebSocketStream;
struct ServerState {
devices: std::collections::HashMap<usize /* device id */, DeviceState>,
}
struct DeviceState {
disconnect_tx: tokio::sync::oneshot::Sender<()>,
}
#[tokio::main(flavor = "multi_thread")]
async fn main() -> Result<(), Error> {
println!("Hello, world!");
// Listen to incoming WebSocket connections
let socket = TcpListener::bind("127.0.0.1:8081").await.unwrap();
let mut incoming = TcpListenerStream::new(socket);
// Init state
let server_state = ServerState { devices: std::collections::HashMap::new() };
let server_state = Arc::new(AsyncMutex::new(server_state));
// Dispatch connections
while let Some(stream) = incoming.next().await {
let stream = stream.expect("Failed to accept stream");
tokio::spawn(accept_connection(stream, server_state.clone()));
}
Ok(())
}
/// This function accepts the connection, does the WS handshake and does error
/// handling once the connection handling returns.
async fn accept_connection(stream: TcpStream, server_state: Arc<AsyncMutex<ServerState>>) {
// Do the WebSocket handshake
let ws_callback = |_req: &Request, resp: Response| {
/* Some registration logic omitted */
Ok(resp)
};
let mut ws_stream = match tokio_tungstenite::accept_hdr_async(stream, ws_callback).await {
Ok(stream) => stream,
Err(e) => {
// Most probably a non-websocket connection attempt
println!("Error in stream: {:?}", e);
return;
}
};
match accept_connection_inner(&mut ws_stream, server_state.clone()).await {
Ok(_) => println!("Connection terminated"),
Err(e) => println!("Error: {:?}", e),
}
}
/// This function accepts the stream and processes it.
async fn accept_connection_inner(
ws_stream: &mut WebSocketStream<TcpStream>,
server_state: Arc<AsyncMutex<ServerState>>,
) -> Result<(), Error> {
println!("Accept connection");
// Here, in the real code, we establish an additional connection to another
// TCP server (called "proxy socket" from now on). Messages from the server
// are framed and relayed to the WebSocket server, and vice versa. This
// happens even without authentication (since the TCP connection has its
// own auth).
// 1. Send server-hello message
// 2. Auth loop: select! between ws stream and proxy socket.
let device_id = 42; // Determined in the auth handshake
// 3. If successful, create a one-shot channel for disconnecting the
// connection. Then register it in the state.
let (disconnect_tx, disconnect_rx) = tokio::sync::oneshot::channel();
let device = DeviceState { disconnect_tx };
server_state.lock().await.devices.insert(device_id, device);
// 4. Send server-info message
// 5. Check disconnect_rx.try_recv()
// 6. Send queued messages in a loop, check disconnect_rx after every message
// 7. Check disconnect_rx.try_recv()
// 8. Send another control message
// 9. Main loop: select! between ws stream, proxy socket and disconnect_rx
Ok(())
}
|
#[doc = r" Register block"]
#[repr(C)]
pub struct RegisterBlock {
_reserved0: [u8; 16usize],
#[doc = "0x10 - Code memory page size in bytes."]
pub codepagesize: CODEPAGESIZE,
#[doc = "0x14 - Code memory size in pages."]
pub codesize: CODESIZE,
_reserved1: [u8; 16usize],
#[doc = "0x28 - Length of code region 0 in bytes."]
pub clenr0: CLENR0,
#[doc = "0x2c - Pre-programmed factory code present."]
pub ppfc: PPFC,
_reserved2: [u8; 4usize],
#[doc = "0x34 - Number of individualy controllable RAM blocks."]
pub numramblock: NUMRAMBLOCK,
#[doc = "0x38 - Size of RAM block in bytes."]
pub sizeramblock: [SIZERAMBLOCK; 4],
_reserved3: [u8; 20usize],
#[doc = "0x5c - Configuration identifier."]
pub configid: CONFIGID,
#[doc = "0x60 - Device identifier."]
pub deviceid: [DEVICEID; 2],
_reserved4: [u8; 24usize],
#[doc = "0x80 - Encryption root."]
pub er: [ER; 4],
#[doc = "0x90 - Identity root."]
pub ir: [IR; 4],
#[doc = "0xa0 - Device address type."]
pub deviceaddrtype: DEVICEADDRTYPE,
#[doc = "0xa4 - Device address."]
pub deviceaddr: [DEVICEADDR; 2],
}
#[doc = "Code memory page size in bytes."]
pub struct CODEPAGESIZE {
register: ::vcell::VolatileCell<u32>,
}
#[doc = "Code memory page size in bytes."]
pub mod codepagesize;
#[doc = "Code memory size in pages."]
pub struct CODESIZE {
register: ::vcell::VolatileCell<u32>,
}
#[doc = "Code memory size in pages."]
pub mod codesize;
#[doc = "Length of code region 0 in bytes."]
pub struct CLENR0 {
register: ::vcell::VolatileCell<u32>,
}
#[doc = "Length of code region 0 in bytes."]
pub mod clenr0;
#[doc = "Pre-programmed factory code present."]
pub struct PPFC {
register: ::vcell::VolatileCell<u32>,
}
#[doc = "Pre-programmed factory code present."]
pub mod ppfc;
#[doc = "Number of individualy controllable RAM blocks."]
pub struct NUMRAMBLOCK {
register: ::vcell::VolatileCell<u32>,
}
#[doc = "Number of individualy controllable RAM blocks."]
pub mod numramblock;
#[doc = "Size of RAM block in bytes."]
pub struct SIZERAMBLOCK {
register: ::vcell::VolatileCell<u32>,
}
#[doc = "Size of RAM block in bytes."]
pub mod sizeramblock;
#[doc = "Configuration identifier."]
pub struct CONFIGID {
register: ::vcell::VolatileCell<u32>,
}
#[doc = "Configuration identifier."]
pub mod configid;
#[doc = "Device identifier."]
pub struct DEVICEID {
register: ::vcell::VolatileCell<u32>,
}
#[doc = "Device identifier."]
pub mod deviceid;
#[doc = "Encryption root."]
pub struct ER {
register: ::vcell::VolatileCell<u32>,
}
#[doc = "Encryption root."]
pub mod er;
#[doc = "Identity root."]
pub struct IR {
register: ::vcell::VolatileCell<u32>,
}
#[doc = "Identity root."]
pub mod ir;
#[doc = "Device address type."]
pub struct DEVICEADDRTYPE {
register: ::vcell::VolatileCell<u32>,
}
#[doc = "Device address type."]
pub mod deviceaddrtype;
#[doc = "Device address."]
pub struct DEVICEADDR {
register: ::vcell::VolatileCell<u32>,
}
#[doc = "Device address."]
pub mod deviceaddr;
|
use std::{fmt};
use crate::{block};
extern crate prusti_contracts;
use prusti_contracts::*;
#[non_exhaustive]
#[derive(Clone, PartialEq, Eq)]
pub struct SignedHeader {
pub header: block::Header,
}
impl fmt::Debug for SignedHeader {
#[trusted]
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("SignedHeader")
.finish()
}
}
|
use std::cmp::{min, max};
use std::f64::INFINITY;
use std::mem::replace;
use {Point};
/// Agglomerative clustering, i.e., hierarchical bottum-up clustering.
///
/// How the clustering actually behaves depends on the linkage criterion, which is
/// mainly defined by the implementator and distance of two points.
pub trait AgglomerativeClustering {
/// Clusters the given list of points.
///
/// Starting with each element in its own cluster, iteratively merges the two most similar
/// clusters until a certain distance `threshold` is reached. The remaining
/// clusters are returned. The clusters are represented by vectors of indices into
/// the original data.
///
/// If you need to cluster certain points repeatidly with different thresholds, it might
/// makes sense to use `compute_dendrogram()` to build a full dendrogram and use its
/// `cut_at()` method to extract clusters afterwards.
///
/// The default implementation uses `compute_dendrogram()` and `cut_at()` to cluster.
fn cluster<P: Point>(&self, points: &[P], threshold: f64) -> Vec<Vec<usize>> {
self.compute_dendrogram(points).cut_at(threshold)
}
/// Computes the dendrogram describing the merging process exhaustively.
///
/// The leafs of the returned dendrogram contain the indices into the original set
/// of points.
///
/// Despite one being interested in the dendrogram itself, it might make sense to use
/// the returned `Dendrogram` to find various clusters given different thresholds using
/// the `cut_at` method.
fn compute_dendrogram<P: Point>(&self, points: &[P]) -> Box<Dendrogram<usize>>;
}
/// A linkage cirterion used for agglomerative clustering.
///
/// Implementing this trait means to define a linkage criterion, which is defined by its
/// method to compute the inter-cluster distance.
pub trait LinkageCriterion {
/// Compute the distance between cluster `a` and cluster `b`.
///
/// The supplied function `dist` can be used to retrieve the distance between two points given
/// their indices.
fn distance<F: Fn(usize, usize) -> f64>(&self, dist: F, a: &[usize], b: &[usize]) -> f64;
}
/// Minimum or single-linkage clustering.
///
/// **Criterion:** `min { d(a, b) | a ∈ A, b ∈ B }`
///
/// For an optimal clustering algorithm using this criterion have a look at `SLINK`.
/// It produces the same results as the naive algorithm given this criterion, but has
/// much better performance characteristics.
pub struct SingleLinkage;
impl LinkageCriterion for SingleLinkage {
fn distance<F: Fn(usize, usize) -> f64>(&self, dist: F, a: &[usize], b: &[usize]) -> f64 {
let mut min_d = INFINITY;
for &i in a {
for &j in b {
let d = dist(i, j);
if d < min_d {
min_d = d;
}
}
}
return min_d;
}
}
/// Maximum or complete-linkage clustering.
///
/// **Criterion:** `max { d(a, b) | a ? A, b ? B }`
///
/// Use `CLINK` if you need a better performing algorithm, but beware, `CLINK`
/// might not produce the same result as the naive algorithm given this criterion.
pub struct CompleteLinkage;
impl LinkageCriterion for CompleteLinkage {
fn distance<F: Fn(usize, usize) -> f64>(&self, dist: F, a: &[usize], b: &[usize]) -> f64 {
let mut max_d = 0.0;
for &i in a {
for &j in b {
let d = dist(i, j);
if d > max_d {
max_d = d;
}
}
}
return max_d;
}
}
struct Cluster {
max_index: usize,
elements: Vec<usize>,
dendrogram: Box<Dendrogram<usize>>
}
/// Generic but naive agglomerative (bottom-up) clustering.
///
/// A naive implementation of agglomerative clustering generic over any linkage
/// criterion. It can be used with any linkage criterion, thus it cannot apply certain
/// optimizations. Check the implementations of `AgglomerativeClustering` to see if there is
/// an optimized implementation for a certain criterion.
///
/// The general case has a O( n^3 ) time complexity and O( n^2 ) space complexity. Beware,
/// they might be even worse depending on the linkage criterion.
pub struct NaiveBottomUp<L: LinkageCriterion> {
linkage: L,
}
impl<L: LinkageCriterion> NaiveBottomUp<L> {
/// Create a new setting for bottom-up clustering given a certain `linkage` criterion.
pub fn new(linkage: L) -> Self {
NaiveBottomUp {
linkage: linkage
}
}
fn cluster_naively<P: Point>(&self, points: &[P], threshold: f64) -> Vec<Cluster> {
let point_distances: Vec<Vec<f64>> = (0..points.len()).map(|i| {
(0..i).map(|j| points[i].dist(&points[j])).collect()
}).collect();
let dist = |i: usize, j: usize| point_distances[max(i,j)][min(i,j)];
let mut cluster_distances = point_distances.clone();
let mut clusters: Vec<_> = (0..points.len()).map(|i| Cluster {
max_index: i,
elements: vec![i],
dendrogram: Box::new(Dendrogram::Leaf(i))
}).collect();
while clusters.len() > 1 {
let mut min_dist = INFINITY;
let mut merge = (0, 0);
for i in 1..clusters.len() {
for j in 0..i {
let a = clusters[i].max_index;
let b = clusters[j].max_index;
let d = cluster_distances[max(a, b)][min(a, b)];
if d < min_dist {
min_dist = d;
merge = (i, j);
}
}
}
if min_dist > threshold {
break;
}
let a = clusters.swap_remove(merge.0);
let b = clusters.swap_remove(merge.1);
let mut c = Cluster {
max_index: max(a.max_index, b.max_index),
elements: a.elements,
dendrogram: Box::new(Dendrogram::Branch(min_dist, a.dendrogram, b.dendrogram))
};
c.elements.extend(b.elements);
for i in &clusters {
cluster_distances[max(c.max_index, i.max_index)][min(c.max_index, i.max_index)] =
self.linkage.distance(&dist, &*c.elements, &i.elements);
}
clusters.push(c);
}
clusters
}
}
impl<L: LinkageCriterion> AgglomerativeClustering for NaiveBottomUp<L> {
fn cluster<P: Point>(&self, points: &[P], threshold: f64) -> Vec<Vec<usize>> {
self.cluster_naively(points, threshold).into_iter().map(|c| c.elements).collect()
}
fn compute_dendrogram<P: Point>(&self, points: &[P]) -> Box<Dendrogram<usize>> {
self.cluster_naively(points, INFINITY).pop().unwrap().dendrogram
}
}
/// Optimal single-linkage clustering using the SLINK algorithm.
///
/// Uses an implementation of the optimal SLINK [[1]](#slink) algorithm with
/// O( n^2 ) time and O( n ) space complexity. Produces the same result as
/// naive bottom-up clustering given the single-linkage criterion.
///
/// # References
///
/// * <a name="slink">[1]</a>: Sibson, R. (1973). *SLINK: an optimally efficient algorithm for
/// the single-link cluster method.* The Computer Journal, 16(1), 30-34.
pub struct SLINK;
impl AgglomerativeClustering for SLINK {
fn cluster<P: Point>(&self, points: &[P], threshold: f64) -> Vec<Vec<usize>> {
slink(points, threshold).into_iter().map(|c| c.elements).collect()
}
fn compute_dendrogram<P: Point>(&self, points: &[P]) -> Box<Dendrogram<usize>> {
slink(points, INFINITY).pop().unwrap().dendrogram
}
}
/// Optimal complete-linkage clustering using the CLINK algorithm.
///
/// Uses an implementation of the optimal CLINK [[1]](#clink) algorithm with
/// O( n^2 ) time and O( n ) space complexity.
///
/// **Beware:** It depends on the order of the elements and doesn't always return the best
/// dendrogram. Thus it _might not_ return the same result as the naive bottom-up approach
/// given the complete-linkage criterion.
///
/// # References
///
/// * <a name="clink">[1]</a>: Defays, D. (1977). *An efficient algorithm for a complete link
/// method. The Computer Journal*, 20(4), 364-366.
pub struct CLINK;
impl AgglomerativeClustering for CLINK {
fn cluster<P: Point>(&self, points: &[P], threshold: f64) -> Vec<Vec<usize>> {
clink(points, threshold).into_iter().map(|c| c.elements).collect()
}
fn compute_dendrogram<P: Point>(&self, points: &[P]) -> Box<Dendrogram<usize>> {
clink(points, INFINITY).pop().unwrap().dendrogram
}
}
// the SLINK algorithm to perform optimal single linkage clustering
fn slink<P: Point>(points: &[P], threshold: f64) -> Vec<Cluster> {
using_pointer_representation(points, threshold, |n, pi, lambda, em| {
for i in 0..n {
if lambda[i] >= em[i] {
em[pi[i]] = em[pi[i]].min(lambda[i]);
lambda[i] = em[i];
pi[i] = n;
} else {
em[pi[i]] = em[pi[i]].min(em[i]);
}
}
for i in 0..n {
if lambda[i] >= lambda[pi[i]] {
pi[i] = n;
}
}
})
}
// the CLINK algorithm to perform optimal complete linkage clustering
fn clink<P: Point>(points: &[P], threshold: f64) -> Vec<Cluster> {
using_pointer_representation(points, threshold, |n, pi, lambda, em| {
for i in 0..n {
if lambda[i] < em[i] {
em[pi[i]] = em[pi[i]].max(em[i]);
em[i] = INFINITY;
}
}
let mut a = n - 1;
for i in (0..n).rev() {
if lambda[i] >= em[pi[i]] {
if em[i] < em[a] {
a = i;
}
} else {
em[i] = INFINITY;
}
}
let mut b = replace(&mut pi[a], n);
let mut c = replace(&mut lambda[a], em[a]);
if a < n - 1 {
while b < n - 1 {
b = replace(&mut pi[b], n);
c = replace(&mut lambda[b], c);
}
if b == n - 1 {
pi[b] = n;
lambda[b] = c;
}
}
for i in 0..n {
if pi[pi[i]] == n && lambda[i] >= lambda[pi[i]] {
pi[i] = n;
}
}
})
}
fn using_pointer_representation<P, F>(points: &[P], threshold: f64, f: F) -> Vec<Cluster>
where P: Point, F: Fn(usize, &mut Vec<usize>, &mut Vec<f64>, &mut Vec<f64>)
{
let mut pi = vec![0; points.len()];
let mut lambda = vec![0.0; points.len()];
let mut em = vec![0.0; points.len()];
pi[0] = 0;
lambda[0] = INFINITY;
for n in 1..points.len() {
pi[n] = n;
lambda[n] = INFINITY;
for i in 0..n {
em[i] = points[i].dist(&points[n]);
}
f(n, &mut pi, &mut lambda, &mut em);
}
// convert pointer representation to dendrogram
let mut dendrograms: Vec<_> = (0..points.len()).map(|i| Some(Cluster {
max_index: i,
elements: vec![i],
dendrogram: Box::new(Dendrogram::Leaf(i))
})).collect();
let mut idx: Vec<_> = (0..points.len()).collect();
idx.sort_by(|&a, &b| lambda[a].partial_cmp(&lambda[b]).unwrap());
for i in 0..points.len()-1 {
let leaf = idx[i];
if lambda[leaf] > threshold {
break;
}
let merge = pi[leaf];
let a = replace(&mut dendrograms[leaf], None).unwrap();
let b = replace(&mut dendrograms[merge], None).unwrap();
let mut c = Cluster {
max_index: max(a.max_index, b.max_index),
elements: a.elements,
dendrogram: Box::new(if leaf < merge {
Dendrogram::Branch(lambda[leaf], a.dendrogram, b.dendrogram)
} else {
Dendrogram::Branch(lambda[leaf], b.dendrogram, a.dendrogram)
})
};
c.elements.extend(b.elements);
dendrograms[max(leaf, merge)] = Some(c);
}
dendrograms.into_iter().filter_map(|x| x).collect()
}
/// A hierarchical tree structure describing the merge operations.
#[derive(Clone, Debug)]
pub enum Dendrogram<T> {
/// The union of two sub-trees (clusters) and their distance.
Branch(f64, Box<Dendrogram<T>>, Box<Dendrogram<T>>),
/// The leaf node contains an element.
Leaf(T)
}
impl<T: Clone> Dendrogram<T> {
/// Extract clusters given a certain threshold `threshold`.
pub fn cut_at(&self, threshold: f64) -> Vec<Vec<T>> {
let mut dendrograms = vec![self];
let mut clusters = vec![];
while let Some(dendrogram) = dendrograms.pop() {
match dendrogram {
&Dendrogram::Leaf(ref i) => clusters.push(vec![i.clone()]),
&Dendrogram::Branch(d, ref a, ref b) => {
if d < threshold {
clusters.push(dendrogram.into_iter().map(|i| i.clone()).collect());
} else {
dendrograms.push(a);
dendrograms.push(b);
}
}
}
}
return clusters;
}
}
impl<T: PartialEq> PartialEq for Dendrogram<T> {
fn eq(&self, other: &Self) -> bool {
if let (&Dendrogram::Leaf(ref a), &Dendrogram::Leaf(ref b)) = (self, other) {
a == b
} else if let (&Dendrogram::Branch(d1, ref a1, ref b1),
&Dendrogram::Branch(d2, ref a2, ref b2)) = (self, other)
{
d1 == d2 && ((a1 == a2 && b1 == b2) || (a1 == b2 && a2 == b1))
} else {
false
}
}
}
/// An `Iterator` over all elements contained in an `Dendrogram`.
#[derive(Clone, Debug)]
pub struct Elements<'a, T: 'a> {
items: Vec<&'a Dendrogram<T>>
}
impl<'a, T> Iterator for Elements<'a, T> {
type Item = &'a T;
fn next(&mut self) -> Option<Self::Item> {
self.items.pop().and_then(|item| {
match item {
&Dendrogram::Branch(_, ref a, ref b) => {
self.items.push(a);
self.items.push(b);
self.next()
},
&Dendrogram::Leaf(ref p) => Some(p)
}
})
}
}
impl<'a, T> IntoIterator for &'a Dendrogram<T> {
type Item = &'a T;
type IntoIter = Elements<'a, T>;
fn into_iter(self) -> Self::IntoIter {
Elements {
items: vec![self]
}
}
}
#[cfg(test)]
mod tests {
use permutohedron::Heap;
use quickcheck::{Arbitrary, Gen, TestResult, quickcheck};
use Euclid;
use super::{AgglomerativeClustering, NaiveBottomUp, SingleLinkage,
CompleteLinkage, SLINK, CLINK};
#[test]
fn single_dendrogram() {
fn prop(points: Vec<Euclid<[f64; 2]>>) -> TestResult {
if points.len() == 0 {
return TestResult::discard();
}
let optimal = SLINK.compute_dendrogram(&*points);
let naive = NaiveBottomUp::new(SingleLinkage).compute_dendrogram(&*points);
TestResult::from_bool(optimal == naive)
}
quickcheck(prop as fn(Vec<Euclid<[f64; 2]>>) -> TestResult);
}
#[test]
fn single_cluster() {
fn prop(points: Vec<Euclid<[f64; 2]>>, threshold: f64) -> TestResult {
if points.len() == 0 || threshold <= 0.0 {
return TestResult::discard();
}
let optimal = SLINK.cluster(&*points, threshold);
let naive = NaiveBottomUp::new(SingleLinkage).cluster(&*points, threshold);
TestResult::from_bool(eq_clusters(&optimal, &naive))
}
quickcheck(prop as fn(Vec<Euclid<[f64; 2]>>, f64) -> TestResult);
}
#[test]
fn dendrogram_cut_at() {
fn prop(points: Vec<Euclid<[f64; 2]>>, threshold: f64) -> TestResult {
if points.len() == 0 || threshold <= 0.0 {
return TestResult::discard();
}
let algo = NaiveBottomUp::new(SingleLinkage);
let one = algo.cluster(&*points, threshold);
let two = algo.compute_dendrogram(&*points).cut_at(threshold);
TestResult::from_bool(eq_clusters(&one, &two))
}
quickcheck(prop as fn(Vec<Euclid<[f64; 2]>>, f64) -> TestResult);
}
fn eq_clusters(a: &Vec<Vec<usize>>, b: &Vec<Vec<usize>>) -> bool {
for a in a {
let mut matched = true;
for b in b {
matched = true;
for i in a {
if !b.contains(&i) {
matched = false;
break;
}
}
if matched {
break;
}
}
if !matched {
return false;
}
}
return true;
}
/*
#[test]
fn complete() {
// CLINK is not equal to complete linnkage, it depends on the order of the elements
// thus we perform an exhaustive comparison to the native algorithm on all possible
// permutations using only small sets of elements
fn prop(points: Vec<Euclid<[f64; 2]>>) -> TestResult {
if points.len() == 0 || points.len() > 6 || points.len() < 4 {
return TestResult::discard();
}
let naive = NaiveBottomUp::new(CompleteLinkage).compute_dendrogram(&*points);
let mut new = points.clone();
for points in Heap::new(&mut *new) {
let optimal = CLINK.compute_dendrogram(&*points);
if naive == optimal {
//panic!("got it");
return TestResult::from_bool(true);
}
}
TestResult::from_bool(false)
}
quickcheck(prop as fn(Vec<Euclid<[f64; 2]>>) -> TestResult);
}
*/
impl Arbitrary for Euclid<[f64; 2]> {
fn arbitrary<G: Gen>(g: &mut G) -> Self {
Euclid([Arbitrary::arbitrary(g), Arbitrary::arbitrary(g)])
}
}
}
#[cfg(all(test, feature = "unstable"))]
mod benches {
use rand::{XorShiftRng, Rng};
use test::Bencher;
use Euclid;
use super::{AgglomerativeClustering, NaiveBottomUp, SingleLinkage, SLINK,
CompleteLinkage, CLINK};
macro_rules! benches {
($($name: ident, $l: expr, $d: expr, $n: expr;)*) => {
$(
#[bench]
fn $name(b: &mut Bencher) {
let mut rng = XorShiftRng::new_unseeded();
let points = (0..$n)
.map(|_| Euclid(rng.gen::<[f64; $d]>()))
.collect::<Vec<_>>();
b.iter(|| $l.compute_dendrogram(&*points))
}
)*
}
}
benches! {
slink_d1_n0010, SLINK, 1, 10;
slink_d1_n0100, SLINK, 1, 100;
slink_d1_n1000, SLINK, 1, 1000;
naive_single_d1_n0010, NaiveBottomUp::new(SingleLinkage), 1, 10;
naive_single_d1_n0100, NaiveBottomUp::new(SingleLinkage), 1, 100;
//naive_single_d1_n1000, NaiveBottomUp::new(SingleLinkage), 1, 1000;
clink_d1_n0010, CLINK, 1, 10;
clink_d1_n0100, CLINK, 1, 100;
clink_d1_n1000, CLINK, 1, 1000;
naive_complete_d1_n0010, NaiveBottomUp::new(CompleteLinkage), 1, 10;
naive_complete_d1_n0100, NaiveBottomUp::new(CompleteLinkage), 1, 100;
//naive_complete_d1_n1000, NaiveBottomUp::new(CompleteLinkage), 1, 1000;
}
}
|
use std::fmt::Display;
use crate::types::list::{List, ListItem};
use super::value::Value;
#[derive(Debug, Clone)]
pub struct DotPair {
pub left: Value,
pub right: Value,
}
impl Display for DotPair {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut buffer = String::new();
buffer.push_str(format!("({}", self.left.content).as_str());
let mut list = List::new(self.right.clone());
while let ListItem::Middle(value) = list.next() {
buffer.push_str(format!(" {}", value.content).as_str());
}
match list.next() {
ListItem::Last(v) => buffer.push_str(format!(" . {})", v.content).as_str()),
ListItem::End => buffer.push(')'),
ListItem::Middle(_) => unreachable!(),
}
write!(f, "{}", buffer)
}
}
|
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
pub fn serialize_operation_add_tags_to_on_premises_instances(
input: &crate::input::AddTagsToOnPremisesInstancesInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_add_tags_to_on_premises_instances_input(
&mut object,
input,
);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_batch_get_application_revisions(
input: &crate::input::BatchGetApplicationRevisionsInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_batch_get_application_revisions_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_batch_get_applications(
input: &crate::input::BatchGetApplicationsInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_batch_get_applications_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_batch_get_deployment_groups(
input: &crate::input::BatchGetDeploymentGroupsInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_batch_get_deployment_groups_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_batch_get_deployment_instances(
input: &crate::input::BatchGetDeploymentInstancesInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_batch_get_deployment_instances_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_batch_get_deployments(
input: &crate::input::BatchGetDeploymentsInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_batch_get_deployments_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_batch_get_deployment_targets(
input: &crate::input::BatchGetDeploymentTargetsInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_batch_get_deployment_targets_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_batch_get_on_premises_instances(
input: &crate::input::BatchGetOnPremisesInstancesInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_batch_get_on_premises_instances_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_continue_deployment(
input: &crate::input::ContinueDeploymentInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_continue_deployment_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_create_application(
input: &crate::input::CreateApplicationInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_create_application_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_create_deployment(
input: &crate::input::CreateDeploymentInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_create_deployment_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_create_deployment_config(
input: &crate::input::CreateDeploymentConfigInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_create_deployment_config_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_create_deployment_group(
input: &crate::input::CreateDeploymentGroupInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_create_deployment_group_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_delete_application(
input: &crate::input::DeleteApplicationInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_delete_application_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_delete_deployment_config(
input: &crate::input::DeleteDeploymentConfigInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_delete_deployment_config_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_delete_deployment_group(
input: &crate::input::DeleteDeploymentGroupInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_delete_deployment_group_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_delete_git_hub_account_token(
input: &crate::input::DeleteGitHubAccountTokenInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_delete_git_hub_account_token_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_delete_resources_by_external_id(
input: &crate::input::DeleteResourcesByExternalIdInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_delete_resources_by_external_id_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_deregister_on_premises_instance(
input: &crate::input::DeregisterOnPremisesInstanceInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_deregister_on_premises_instance_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_get_application(
input: &crate::input::GetApplicationInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_get_application_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_get_application_revision(
input: &crate::input::GetApplicationRevisionInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_get_application_revision_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_get_deployment(
input: &crate::input::GetDeploymentInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_get_deployment_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_get_deployment_config(
input: &crate::input::GetDeploymentConfigInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_get_deployment_config_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_get_deployment_group(
input: &crate::input::GetDeploymentGroupInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_get_deployment_group_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_get_deployment_instance(
input: &crate::input::GetDeploymentInstanceInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_get_deployment_instance_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_get_deployment_target(
input: &crate::input::GetDeploymentTargetInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_get_deployment_target_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_get_on_premises_instance(
input: &crate::input::GetOnPremisesInstanceInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_get_on_premises_instance_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_list_application_revisions(
input: &crate::input::ListApplicationRevisionsInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_list_application_revisions_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_list_applications(
input: &crate::input::ListApplicationsInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_list_applications_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_list_deployment_configs(
input: &crate::input::ListDeploymentConfigsInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_list_deployment_configs_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_list_deployment_groups(
input: &crate::input::ListDeploymentGroupsInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_list_deployment_groups_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_list_deployment_instances(
input: &crate::input::ListDeploymentInstancesInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_list_deployment_instances_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_list_deployments(
input: &crate::input::ListDeploymentsInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_list_deployments_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_list_deployment_targets(
input: &crate::input::ListDeploymentTargetsInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_list_deployment_targets_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_list_git_hub_account_token_names(
input: &crate::input::ListGitHubAccountTokenNamesInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_list_git_hub_account_token_names_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_list_on_premises_instances(
input: &crate::input::ListOnPremisesInstancesInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_list_on_premises_instances_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_list_tags_for_resource(
input: &crate::input::ListTagsForResourceInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_list_tags_for_resource_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_put_lifecycle_event_hook_execution_status(
input: &crate::input::PutLifecycleEventHookExecutionStatusInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_put_lifecycle_event_hook_execution_status_input(
&mut object,
input,
);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_register_application_revision(
input: &crate::input::RegisterApplicationRevisionInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_register_application_revision_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_register_on_premises_instance(
input: &crate::input::RegisterOnPremisesInstanceInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_register_on_premises_instance_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_remove_tags_from_on_premises_instances(
input: &crate::input::RemoveTagsFromOnPremisesInstancesInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_remove_tags_from_on_premises_instances_input(
&mut object,
input,
);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_skip_wait_time_for_instance_termination(
input: &crate::input::SkipWaitTimeForInstanceTerminationInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_skip_wait_time_for_instance_termination_input(
&mut object,
input,
);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_stop_deployment(
input: &crate::input::StopDeploymentInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_stop_deployment_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_tag_resource(
input: &crate::input::TagResourceInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_tag_resource_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_untag_resource(
input: &crate::input::UntagResourceInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_untag_resource_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_update_application(
input: &crate::input::UpdateApplicationInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_update_application_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_update_deployment_group(
input: &crate::input::UpdateDeploymentGroupInput,
) -> Result<smithy_http::body::SdkBody, smithy_types::Error> {
let mut out = String::new();
let mut object = smithy_json::serialize::JsonObjectWriter::new(&mut out);
crate::json_ser::serialize_structure_update_deployment_group_input(&mut object, input);
object.finish();
Ok(smithy_http::body::SdkBody::from(out))
}
|
use lazy_static::lazy_static;
use pulldown_cmark::{html::push_html, Parser};
use std::include_str;
use web_sys::Node;
use yew::{virtual_dom::VNode, Component, ComponentLink, Html, ShouldRender};
const HELP_TEXT: &str = include_str!("help.md");
lazy_static! {
static ref HELP_HTML: String = {
let mut html_output = String::new();
push_html(&mut html_output, Parser::new(HELP_TEXT));
html_output
};
}
pub struct Help;
impl Component for Help {
type Message = ();
type Properties = ();
fn create(_: Self::Properties, _: ComponentLink<Self>) -> Self {
Help
}
fn update(&mut self, _: Self::Message) -> ShouldRender {
false
}
fn change(&mut self, _: Self::Properties) -> ShouldRender {
false
}
fn view(&self) -> Html {
let html = web_sys::window()
.unwrap()
.document()
.unwrap()
.create_element("div")
.unwrap();
html.set_inner_html(&HELP_HTML);
html.set_attribute("class", "mui-container").unwrap();
VNode::VRef(Node::from(html))
}
}
|
use crate::{
conn::AmConnCore,
protocol::parts::{am_rs_core::AmRsCore, TypeId},
HdbError, HdbResult, HdbValue,
};
#[cfg(feature = "async")]
use crate::protocol::util_async;
#[cfg(feature = "sync")]
use crate::protocol::util_sync;
#[cfg(feature = "sync")]
use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
#[cfg(feature = "sync")]
pub(crate) fn parse_blob_sync(
am_conn_core: &AmConnCore,
o_am_rscore: &Option<AmRsCore>,
nullable: bool,
rdr: &mut dyn std::io::Read,
) -> HdbResult<HdbValue<'static>> {
let (is_null, is_data_included, is_last_data) = parse_lob_1_sync(rdr)?;
if is_null {
if nullable {
Ok(HdbValue::NULL)
} else {
Err(HdbError::Impl("found null value for not-null BLOB column"))
}
} else {
let (_, length, locator_id, data) = parse_lob_2_sync(rdr, is_data_included)?;
Ok(HdbValue::SYNC_BLOB(crate::sync::BLob::new(
am_conn_core,
o_am_rscore,
is_last_data,
length,
locator_id,
data,
)))
}
}
#[cfg(feature = "async")]
pub(crate) async fn parse_blob_async<R: std::marker::Unpin + tokio::io::AsyncReadExt>(
am_conn_core: &AmConnCore,
o_am_rscore: &Option<AmRsCore>,
nullable: bool,
rdr: &mut R,
) -> HdbResult<HdbValue<'static>> {
let (is_null, is_data_included, is_last_data) = parse_lob_1_async(rdr).await?;
if is_null {
if nullable {
Ok(HdbValue::NULL)
} else {
Err(HdbError::Impl("found null value for not-null BLOB column"))
}
} else {
let (_, length, locator_id, data) = parse_lob_2_async(rdr, is_data_included).await?;
Ok(HdbValue::ASYNC_BLOB(crate::a_sync::BLob::new(
am_conn_core,
o_am_rscore,
is_last_data,
length,
locator_id,
data,
)))
}
}
#[cfg(feature = "sync")]
pub(crate) fn parse_clob_sync(
am_conn_core: &AmConnCore,
o_am_rscore: &Option<AmRsCore>,
nullable: bool,
rdr: &mut dyn std::io::Read,
) -> HdbResult<HdbValue<'static>> {
let (is_null, is_data_included, is_last_data) = parse_lob_1_sync(rdr)?;
if is_null {
if nullable {
Ok(HdbValue::NULL)
} else {
Err(HdbError::Impl("found null value for not-null CLOB column"))
}
} else {
let (char_length, byte_length, locator_id, data) = parse_lob_2_sync(rdr, is_data_included)?;
Ok(HdbValue::SYNC_CLOB(crate::sync::CLob::new(
am_conn_core,
o_am_rscore,
is_last_data,
char_length,
byte_length,
locator_id,
data,
)?))
}
}
#[cfg(feature = "async")]
pub(crate) async fn parse_clob_async<R: std::marker::Unpin + tokio::io::AsyncReadExt>(
am_conn_core: &AmConnCore,
o_am_rscore: &Option<AmRsCore>,
nullable: bool,
rdr: &mut R,
) -> HdbResult<HdbValue<'static>> {
let (is_null, is_data_included, is_last_data) = parse_lob_1_async(rdr).await?;
if is_null {
if nullable {
Ok(HdbValue::NULL)
} else {
Err(HdbError::Impl("found null value for not-null CLOB column"))
}
} else {
let (char_length, byte_length, locator_id, data) =
parse_lob_2_async(rdr, is_data_included).await?;
Ok(HdbValue::ASYNC_CLOB(crate::a_sync::CLob::new(
am_conn_core,
o_am_rscore,
is_last_data,
char_length,
byte_length,
locator_id,
data,
)?))
}
}
#[cfg(feature = "sync")]
pub(crate) fn parse_nclob_sync(
am_conn_core: &AmConnCore,
o_am_rscore: &Option<AmRsCore>,
nullable: bool,
type_id: TypeId,
rdr: &mut dyn std::io::Read,
) -> HdbResult<HdbValue<'static>> {
let (is_null, is_data_included, is_last_data) = parse_lob_1_sync(rdr)?;
if is_null {
if nullable {
Ok(HdbValue::NULL)
} else {
Err(HdbError::Impl("found null value for not-null NCLOB column"))
}
} else {
let (char_length, byte_length, locator_id, data) = parse_lob_2_sync(rdr, is_data_included)?;
Ok(match type_id {
TypeId::TEXT | TypeId::NCLOB => HdbValue::SYNC_NCLOB(crate::sync::NCLob::new(
am_conn_core,
o_am_rscore,
is_last_data,
char_length,
byte_length,
locator_id,
data,
)?),
_ => return Err(HdbError::Impl("unexpected type id for nclob")),
})
}
}
#[cfg(feature = "async")]
pub(crate) async fn parse_nclob_async<R: std::marker::Unpin + tokio::io::AsyncReadExt>(
am_conn_core: &AmConnCore,
o_am_rscore: &Option<AmRsCore>,
nullable: bool,
type_id: TypeId,
rdr: &mut R,
) -> HdbResult<HdbValue<'static>> {
let (is_null, is_data_included, is_last_data) = parse_lob_1_async(rdr).await?;
if is_null {
if nullable {
Ok(HdbValue::NULL)
} else {
Err(HdbError::Impl("found null value for not-null NCLOB column"))
}
} else {
let (char_length, byte_length, locator_id, data) =
parse_lob_2_async(rdr, is_data_included).await?;
Ok(match type_id {
TypeId::TEXT | TypeId::NCLOB => HdbValue::ASYNC_NCLOB(crate::a_sync::NCLob::new(
am_conn_core,
o_am_rscore,
is_last_data,
char_length,
byte_length,
locator_id,
data,
)?),
_ => return Err(HdbError::Impl("unexpected type id for nclob")),
})
}
}
#[cfg(feature = "sync")]
fn parse_lob_1_sync(rdr: &mut dyn std::io::Read) -> HdbResult<(bool, bool, bool)> {
let _data_type = rdr.read_u8()?; // I1
let options = rdr.read_u8()?; // I1
let is_null = (options & 0b1_u8) != 0;
let is_data_included = (options & 0b_10_u8) != 0;
let is_last_data = (options & 0b100_u8) != 0;
Ok((is_null, is_data_included, is_last_data))
}
#[cfg(feature = "async")]
async fn parse_lob_1_async<R: std::marker::Unpin + tokio::io::AsyncReadExt>(
rdr: &mut R,
) -> HdbResult<(bool, bool, bool)> {
let _data_type = rdr.read_u8().await?; // I1
let options = rdr.read_u8().await?; // I1
let is_null = (options & 0b1_u8) != 0;
let is_data_included = (options & 0b10_u8) != 0;
let is_last_data = (options & 0b100_u8) != 0;
Ok((is_null, is_data_included, is_last_data))
}
#[cfg(feature = "sync")]
fn parse_lob_2_sync(
rdr: &mut dyn std::io::Read,
is_data_included: bool,
) -> HdbResult<(u64, u64, u64, Vec<u8>)> {
util_sync::skip_bytes(2, rdr)?; // U2 (filler)
let total_char_length = rdr.read_u64::<LittleEndian>()?; // I8
let total_byte_length = rdr.read_u64::<LittleEndian>()?; // I8
let locator_id = rdr.read_u64::<LittleEndian>()?; // I8
let chunk_length = rdr.read_u32::<LittleEndian>()?; // I4
if is_data_included {
let data = util_sync::parse_bytes(chunk_length as usize, rdr)?; // B[chunk_length]
Ok((total_char_length, total_byte_length, locator_id, data))
} else {
Ok((
total_char_length,
total_byte_length,
locator_id,
Vec::<u8>::new(),
))
}
}
#[cfg(feature = "async")]
async fn parse_lob_2_async<R: std::marker::Unpin + tokio::io::AsyncReadExt>(
rdr: &mut R,
is_data_included: bool,
) -> HdbResult<(u64, u64, u64, Vec<u8>)> {
util_async::skip_bytes(2, rdr).await?; // U2 (filler)
let total_char_length = rdr.read_u64_le().await?; // I8
let total_byte_length = rdr.read_u64_le().await?; // I8
let locator_id = rdr.read_u64_le().await?; // I8
let chunk_length = rdr.read_u32_le().await?; // I4
if is_data_included {
let data = util_async::parse_bytes(chunk_length as usize, rdr).await?; // B[chunk_length]
Ok((total_char_length, total_byte_length, locator_id, data))
} else {
Ok((
total_char_length,
total_byte_length,
locator_id,
Vec::<u8>::new(),
))
}
}
#[cfg(feature = "sync")]
#[allow(clippy::cast_possible_truncation)]
pub(crate) fn emit_lob_header_sync(
length: u64,
offset: &mut i32,
w: &mut dyn std::io::Write,
) -> HdbResult<()> {
// bit 0: not used; bit 1: data is included; bit 2: no more data remaining
w.write_u8(0b000_u8)?; // I1 Bit set for options
w.write_i32::<LittleEndian>(length as i32)?; // I4 LENGTH OF VALUE
w.write_i32::<LittleEndian>(*offset)?; // I4 position
*offset += length as i32;
Ok(())
}
#[cfg(feature = "async")]
#[allow(clippy::cast_possible_truncation)]
pub(crate) async fn emit_lob_header_async<W: std::marker::Unpin + tokio::io::AsyncWriteExt>(
length: u64,
offset: &mut i32,
w: &mut W,
) -> HdbResult<()> {
// bit 0: not used; bit 1: data is included; bit 2: no more data remaining
w.write_u8(0b000_u8).await?; // I1 Bit set for options
w.write_i32_le(length as i32).await?; // I4 LENGTH OF VALUE
w.write_i32_le(*offset).await?; // I4 position
*offset += length as i32;
Ok(())
}
|
#![cfg(test)]
use super::{
app::{App, AppLifeCycle, AppRunner, StandardAppTimer, SyncAppRunner},
assets::{database::AssetsDatabase, protocols::prefab::PrefabAsset},
fetch::engines::map::MapFetchEngine,
hierarchy::{hierarchy_find_world, HierarchyChangeRes, Name, Parent},
localization::Localization,
log::{logger_setup, DefaultLogger},
prefab::*,
state::{State, StateChange},
};
use specs::prelude::*;
use std::collections::HashMap;
struct Counter {
pub times: isize,
}
impl Component for Counter {
type Storage = VecStorage<Self>;
}
struct CounterSystem;
impl<'s> System<'s> for CounterSystem {
type SystemData = (WriteExpect<'s, AppLifeCycle>, WriteStorage<'s, Counter>);
fn run(&mut self, (mut lifecycle, mut counters): Self::SystemData) {
for counter in (&mut counters).join() {
counter.times -= 1;
println!("counter: {:?}", counter.times);
if counter.times <= 0 {
lifecycle.running = false;
}
}
}
}
struct PrintableSystem;
impl<'s> System<'s> for PrintableSystem {
type SystemData = ReadStorage<'s, Name>;
fn run(&mut self, names: Self::SystemData) {
for name in (&names).join() {
println!("name: {:?}", name.0);
}
}
}
#[derive(Default)]
struct Example {
root: Option<Entity>,
}
impl State for Example {
fn on_enter(&mut self, world: &mut World) {
world.create_entity().with(Counter { times: 10 }).build();
let root = world.create_entity().with(Name("root".into())).build();
world
.create_entity()
.with(Parent(root))
.with(Name("child".into()))
.build();
self.root = Some(root);
}
fn on_process(&mut self, world: &mut World) -> StateChange {
if let Some(root) = self.root {
world.delete_entity(root).unwrap();
self.root = None;
}
StateChange::None
}
}
#[test]
fn test_general() {
let app = App::build()
.with_system(CounterSystem, "counter", &[])
.with_system(PrintableSystem, "names", &[])
.build(Example::default(), StandardAppTimer::default());
let mut runner = AppRunner::new(app);
drop(runner.run(SyncAppRunner::default()));
}
#[derive(Default)]
struct ExamplePrefab {
phase: usize,
}
impl State for ExamplePrefab {
fn on_enter(&mut self, world: &mut World) {
world
.write_resource::<AssetsDatabase>()
.load("prefab://scene.yaml")
.unwrap();
}
fn on_process(&mut self, world: &mut World) -> StateChange {
match self.phase {
0 => {
if let Some(asset) = world
.read_resource::<AssetsDatabase>()
.asset_by_path("prefab://scene.yaml")
{
let prefab = asset
.get::<PrefabAsset>()
.expect("scene.ron is not a prefab asset")
.get();
let entities = world
.write_resource::<PrefabManager>()
.load_scene_from_prefab_world(prefab, world)
.unwrap();
self.phase = 1;
println!("scene.yaml asset finally loaded: {:?}", entities);
} else {
println!("scene.yaml asset not loaded yet");
}
StateChange::None
}
_ => StateChange::Pop,
}
}
}
#[test]
fn test_prefabs() {
let prefab = PrefabScene {
autoload: false,
template_name: None,
dependencies: vec![],
entities: vec![
PrefabSceneEntity::Data(PrefabSceneEntityData {
uid: Some("uidname".to_owned()),
components: {
let mut map = HashMap::new();
map.insert(
"Name".to_owned(),
PrefabValue::String("some name".to_owned()),
);
map
},
}),
PrefabSceneEntity::Template("some template".to_owned()),
],
};
println!("Prefab string:\n{}", prefab.to_prefab_string().unwrap());
let mut files = HashMap::new();
files.insert(
"scene.yaml".to_owned(),
br#"
entities:
- Data:
components:
Name: hello
Tag: greting
NonPersistent:
"#
.to_vec(),
);
let app = App::build()
.with_bundle(
crate::assets::bundle_installer,
(MapFetchEngine::new(files), |_| {}),
)
.with_bundle(crate::prefab::bundle_installer, |_| {})
.build(ExamplePrefab::default(), StandardAppTimer::default());
let mut runner = AppRunner::new(app);
drop(runner.run(SyncAppRunner::default()));
}
#[test]
fn test_hierarchy_find() {
let mut app = App::build().build_empty(StandardAppTimer::default());
let root = app
.world_mut()
.create_entity()
.with(Name("root".into()))
.build();
let child_a = app
.world_mut()
.create_entity()
.with(Name("a".into()))
.with(Parent(root))
.build();
let child_b = app
.world_mut()
.create_entity()
.with(Name("b".into()))
.with(Parent(child_a))
.build();
let child_c = app
.world_mut()
.create_entity()
.with(Name("c".into()))
.with(Parent(root))
.build();
app.process();
assert_eq!(hierarchy_find_world(root, "", app.world()), Some(root));
assert_eq!(hierarchy_find_world(root, ".", app.world()), Some(root));
assert_eq!(hierarchy_find_world(root, "..", app.world()), None);
assert_eq!(hierarchy_find_world(root, "a", app.world()), Some(child_a));
assert_eq!(hierarchy_find_world(root, "a/", app.world()), Some(child_a));
assert_eq!(
hierarchy_find_world(root, "a/.", app.world()),
Some(child_a)
);
assert_eq!(hierarchy_find_world(root, "a/..", app.world()), Some(root));
assert_eq!(hierarchy_find_world(root, "a/../..", app.world()), None);
assert_eq!(hierarchy_find_world(root, "b", app.world()), None);
assert_eq!(hierarchy_find_world(root, "c", app.world()), Some(child_c));
assert_eq!(hierarchy_find_world(root, "c/", app.world()), Some(child_c));
assert_eq!(
hierarchy_find_world(root, "c/.", app.world()),
Some(child_c)
);
assert_eq!(hierarchy_find_world(root, "c/..", app.world()), Some(root));
assert_eq!(hierarchy_find_world(root, "c/../..", app.world()), None);
assert_eq!(
hierarchy_find_world(root, "a/b", app.world()),
Some(child_b)
);
assert_eq!(
hierarchy_find_world(root, "a/b/", app.world()),
Some(child_b)
);
assert_eq!(
hierarchy_find_world(root, "a/b/", app.world()),
Some(child_b)
);
assert_eq!(
hierarchy_find_world(root, "a/b/..", app.world()),
Some(child_a)
);
assert_eq!(
hierarchy_find_world(root, "a/b/../..", app.world()),
Some(root)
);
assert_eq!(
hierarchy_find_world(root, "a/b/../../..", app.world()),
None
);
assert_eq!(
hierarchy_find_world(root, "a/b/../../..", app.world()),
None
);
}
#[test]
fn test_hierarchy_add_remove() {
fn sorted(container: &[Entity]) -> Vec<Entity> {
let mut result = container.to_vec();
result.sort();
result
}
let mut app = App::build().build_empty(StandardAppTimer::default());
{
let changes = app.world().read_resource::<HierarchyChangeRes>();
assert_eq!(changes.added(), &[]);
assert_eq!(changes.removed(), &[]);
}
let root = app
.world_mut()
.create_entity()
.with(Name("root".into()))
.build();
let e1 = app.world_mut().create_entity().with(Parent(root)).build();
app.process();
{
let changes = app.world().read_resource::<HierarchyChangeRes>();
assert_eq!(sorted(changes.added()), sorted(&[root, e1]));
assert_eq!(changes.removed(), &[]);
}
app.process();
{
let changes = app.world().read_resource::<HierarchyChangeRes>();
assert_eq!(changes.added(), &[]);
assert_eq!(changes.removed(), &[]);
}
app.world_mut().delete_entity(root).unwrap();
app.world_mut().delete_entity(e1).unwrap();
app.process();
{
let changes = app.world().read_resource::<HierarchyChangeRes>();
assert_eq!(changes.added(), &[]);
assert_eq!(sorted(changes.removed()), sorted(&[root, e1]));
}
}
#[test]
fn test_logger() {
logger_setup(DefaultLogger);
info!("my logger {}", "info");
warn!("my logger {}", "warn");
error!("my logger {}", "error");
}
#[test]
fn test_localization() {
let mut loc = Localization::default();
loc.add_text(
"hello",
"lang",
"Hello |@name|, you've got |@score| points! \\| |@bye",
);
loc.set_current_language(Some("lang".to_owned()));
// let text = loc.format_text("hello", &[("name", "Person"), ("score", &42.to_string())]).unwrap();
let text = localization_format_text!(loc, "hello", "name" => "Person", "score" => 42).unwrap();
assert_eq!(text, "Hello Person, you've got 42 points! | {@bye}");
}
|
use crate::{structure::*, Object, Scene};
use glam::Vec3;
pub fn ray_color(scene: &Scene, ray: Ray, obj: &Box<dyn Object>, hit: Intersection, max_bounce: u32) -> Vec3 {
let mat: Material = obj.material();
let ambient_color: Vec3 = mat.ambient_color * scene.ambient_light;
let mut lights_color = Vec3::zero();
let n = hit.normal;
let v = (ray.origin - hit.position).normalize();
scene.lights.iter().for_each(|light| {
let li: Vec3 = (light.position - hit.position).normalize();
// TODO: Shoot a shadow ray to determine if the light should affect the intersection point
if is_light_visible(scene, &hit, light) {
// Diffuse contribution
let diffuse = mat.diffuse_color * li.dot(n).max(0.0);
// TODO: Specular contribution
let specular = mat.specular_color * n.dot((li + v).normalize()).max(0.0).powf(mat.specular_exponent);
let d = light.position - hit.position;
lights_color += (diffuse + specular) * light.intensity / d.length_squared();
}
});
// TODO: Compute the color of the reflected ray and add its contribution to the current point color.
let r = 2.0 * n.dot(v) * n - v;
let reflect_ray = Ray {
origin: hit.position + r * 0.0001,
direction: r,
};
let reflection_color = match find_nearest_object(scene, &reflect_ray) {
Some((obj, hit)) => {
if max_bounce != 0 {
mat.reflection_color * ray_color(scene, reflect_ray, obj, hit, max_bounce - 1)
} else { Vec3::zero() }
},
None => Vec3::zero(),
};
// TODO: Compute the color of the refracted ray and add its contribution to the current point color.
// Make sure to check for total internal reflection before shooting a new ray.
let dt = v.dot(n);
let discriminant = 1.0 - mat.refraction_index.powi(2) * (1.0 - dt * dt);
let refraction_color = match discriminant {
x if x > 0.0 => {
let t = (mat.refraction_index * (v - dt * n) - n * discriminant.sqrt()).normalize();
let refract_ray = Ray {
origin: hit.position + t * 0.0001,
direction: r,
};
match find_nearest_object(scene, &refract_ray) {
Some((obj, hit)) => {
if max_bounce != 0 {
mat.refraction_color * ray_color(scene, refract_ray, obj, hit, max_bounce - 1)
} else { Vec3::zero() }
},
None => Vec3::zero(),
}
},
_ => Vec3::zero(),
};
ambient_color + lights_color + reflection_color + refraction_color
}
pub fn find_nearest_object<'a>(scene: &'a Scene, ray: &Ray) -> Option<(&'a Box<dyn Object>, Intersection)> {
let mut nearest: Option<(&'a Box<dyn Object>, Intersection)> = None;
let mut distance = -1.0;
// TODO:
//
// Find the object in the scene that intersects the ray first
// The function must return 'nullptr' if no object is hit, otherwise it must
// return a pointer to the hit object, and set the parameters of the argument
// 'hit' to their expected values.
scene.objects.iter().for_each(|obj| {
match obj.intersect(ray) {
Some(i) => {
let current_distance = (i.position - ray.origin).length();
match nearest {
None => {
nearest = Some((obj, i));
distance = current_distance;
},
Some(_) => {
if current_distance < distance {
nearest = Some((obj, i));
distance = current_distance;
}
},
}
},
None => {},
}
});
nearest
}
pub fn is_light_visible(scene: &Scene, hit: &Intersection, light: &Light) -> bool {
// TODO: Determine if the light is visible here
let direction = (light.position - hit.position).normalize();
let shadow_ray = Ray {
origin: hit.position + direction * 0.0001,
direction,
};
match find_nearest_object(scene, &shadow_ray) {
Some(_) => false,
None => true,
}
}
pub fn shoot_ray(scene: &Scene, ray: Ray, max_bounce: u32) -> Vec3 {
match find_nearest_object(scene, &ray) {
Some((obj, hit)) => ray_color(scene, ray, obj, hit, max_bounce),
None => scene.background_color
}
}
|
use crate::postgres::protocol::TypeId;
use crate::types::TypeInfo;
use std::borrow::Borrow;
use std::fmt;
use std::fmt::Display;
use std::hash::{Hash, Hasher};
use std::ops::Deref;
use std::sync::Arc;
/// Type information for a Postgres SQL type.
#[derive(Debug, Clone)]
pub struct PgTypeInfo {
pub(crate) id: Option<TypeId>,
pub(crate) name: SharedStr,
}
impl PgTypeInfo {
pub(crate) fn new(id: TypeId, name: impl Into<SharedStr>) -> Self {
Self {
id: Some(id),
name: name.into(),
}
}
/// Create a `PgTypeInfo` from a type name.
///
/// The OID for the type will be fetched from Postgres on bind or decode of
/// a value of this type. The fetched OID will be cached per-connection.
pub const fn with_name(name: &'static str) -> Self {
Self {
id: None,
name: SharedStr::Static(name),
}
}
#[doc(hidden)]
pub fn type_feature_gate(&self) -> Option<&'static str> {
match self.id? {
TypeId::DATE | TypeId::TIME | TypeId::TIMESTAMP | TypeId::TIMESTAMPTZ => Some("chrono"),
TypeId::UUID => Some("uuid"),
TypeId::JSON | TypeId::JSONB => Some("json"),
// we can support decoding `PgNumeric` but it's decidedly less useful to the layman
TypeId::NUMERIC => Some("bigdecimal"),
TypeId::CIDR | TypeId::INET => Some("ipnetwork"),
_ => None,
}
}
}
impl Display for PgTypeInfo {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self.name)
}
}
impl PartialEq<PgTypeInfo> for PgTypeInfo {
fn eq(&self, other: &PgTypeInfo) -> bool {
// Postgres is strongly typed (mostly) so the rules that make sense here are equivalent
// to the rules that make sense in [compatible]
self.compatible(other)
}
}
impl TypeInfo for PgTypeInfo {
fn compatible(&self, other: &Self) -> bool {
if let (Some(self_id), Some(other_id)) = (self.id, other.id) {
return match (self_id, other_id) {
(TypeId::CIDR, TypeId::INET)
| (TypeId::INET, TypeId::CIDR)
| (TypeId::ARRAY_CIDR, TypeId::ARRAY_INET)
| (TypeId::ARRAY_INET, TypeId::ARRAY_CIDR) => true,
// the following text-like types are compatible
(TypeId::VARCHAR, other)
| (TypeId::TEXT, other)
| (TypeId::BPCHAR, other)
| (TypeId::NAME, other)
| (TypeId::UNKNOWN, other)
if match other {
TypeId::VARCHAR
| TypeId::TEXT
| TypeId::BPCHAR
| TypeId::NAME
| TypeId::UNKNOWN => true,
_ => false,
} =>
{
true
}
// the following text-like array types are compatible
(TypeId::ARRAY_VARCHAR, other)
| (TypeId::ARRAY_TEXT, other)
| (TypeId::ARRAY_BPCHAR, other)
| (TypeId::ARRAY_NAME, other)
if match other {
TypeId::ARRAY_VARCHAR
| TypeId::ARRAY_TEXT
| TypeId::ARRAY_BPCHAR
| TypeId::ARRAY_NAME => true,
_ => false,
} =>
{
true
}
// JSON <=> JSONB
(TypeId::JSON, other) | (TypeId::JSONB, other)
if match other {
TypeId::JSON | TypeId::JSONB => true,
_ => false,
} =>
{
true
}
_ => self_id.0 == other_id.0,
};
}
// If the type names match, the types are equivalent (and compatible)
// If the type names are the empty string, they are invalid type names
if (&*self.name == &*other.name) && !self.name.is_empty() {
return true;
}
// TODO: More efficient way to do case insensitive comparison
if !self.name.is_empty() && (&*self.name.to_lowercase() == &*other.name.to_lowercase()) {
return true;
}
false
}
}
/// Copy of `Cow` but for strings; clones guaranteed to be cheap.
#[derive(Clone, Debug, PartialEq, Eq)]
pub(crate) enum SharedStr {
Static(&'static str),
Arc(Arc<str>),
}
impl Deref for SharedStr {
type Target = str;
fn deref(&self) -> &str {
match self {
SharedStr::Static(s) => s,
SharedStr::Arc(s) => s,
}
}
}
impl Hash for SharedStr {
fn hash<H: Hasher>(&self, state: &mut H) {
// Forward the hash to the string representation of this
// A derive(Hash) encodes the enum discriminant
(&**self).hash(state);
}
}
impl Borrow<str> for SharedStr {
fn borrow(&self) -> &str {
&**self
}
}
impl<'a> From<&'a SharedStr> for SharedStr {
fn from(s: &'a SharedStr) -> Self {
s.clone()
}
}
impl From<&'static str> for SharedStr {
fn from(s: &'static str) -> Self {
SharedStr::Static(s)
}
}
impl From<String> for SharedStr {
#[inline]
fn from(s: String) -> Self {
SharedStr::Arc(s.into())
}
}
impl fmt::Display for SharedStr {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
fmt.pad(self)
}
}
|
/// An "Abstract Syntax Tree" that fairly closely resembles the structure of an AWK program. This
/// is the representation that the parser returns. A couple of basic desugaring rules are applied
/// that translate a `Prog` into a bare `Stmt`, along with its accompanying function definitions.
/// Those materials are consumed by the `cfg` module, which produces an untyped SSA form.
///
/// A couple things to note:
/// * The Expr and Stmt types are trees supporting arbitrary nesting. With limited exceptions, we
/// do not allocate each node separately on the heap. We instead use an arena for these
/// allocations. This is a win on all fronts: it's strictly faster because allocation is
/// extremely cheap, and destructors are fairly cheap, _and_ it's much easier to program because
/// references are Copy.
/// * The common way of introducing AWK: that it is a language structured around patterns and
/// actions to execute when the input matches that pattern is desugared in this module. We do
/// not handle it specially.
///
/// TODO It is not clear that this is the right move long-term: lots of regex implementations
/// (like HyperScan, or BurntSushi's engine in use here) achieve higher throughput by matching a
/// string against several patterns at once. There is probably a transormation we could do here
/// to take advantage of that, but it would probably involve building out def-use chains (which
/// we currently don't do), and we'd want to verify that performance didn't degrade when the
/// patterns are _not sparse_ in the input.
use crate::arena::{self, Arena};
use crate::builtins::Function;
use crate::common::{Either, FileSpec, Stage};
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub enum Unop {
Column,
Not,
Neg,
Pos,
}
static_map!(
UNOPS<&'static str, Unop>,
["$", Unop::Column],
["!", Unop::Not],
["-", Unop::Neg],
["+", Unop::Pos]
);
pub struct FunDec<'a, 'b, I> {
pub name: I,
pub args: Vec<I>,
pub body: &'a Stmt<'a, 'b, I>,
}
pub enum Pattern<'a, 'b, I> {
Null,
Bool(&'a Expr<'a, 'b, I>),
Comma(&'a Expr<'a, 'b, I>, &'a Expr<'a, 'b, I>),
}
pub struct Prog<'a, 'b, I> {
// We allocate as much from the arena as we can, except for things that will be allocated as
// vectors anyway.
// FS
pub field_sep: Option<&'b [u8]>,
pub prelude_vardecs: Vec<(I, &'a Expr<'a, 'b, I>)>,
// OFS
pub output_sep: Option<&'b [u8]>,
// ORS
pub output_record_sep: Option<&'b [u8]>,
pub decs: arena::Vec<'a, FunDec<'a, 'b, I>>,
pub begin: arena::Vec<'a, &'a Stmt<'a, 'b, I>>,
pub prepare: arena::Vec<'a, &'a Stmt<'a, 'b, I>>,
pub end: arena::Vec<'a, &'a Stmt<'a, 'b, I>>,
pub pats: arena::Vec<'a, (Pattern<'a, 'b, I>, Option<&'a Stmt<'a, 'b, I>>)>,
pub stage: Stage<()>,
pub argv: Vec<&'b str>,
pub parse_header: bool,
}
fn parse_header<'a, 'b, I: From<&'b str> + Clone>(
arena: &'a Arena,
begin: &mut arena::Vec<'a, &'a Stmt<'a, 'b, I>>,
) {
use {self::Expr::*, Stmt::*};
// Pick an illegal frawk identifier.
const LOOP_VAR: &'static str = "--";
// Append the following to begin:
// if (getline > 0) {
// for (LOOP_VAR=1; LOOP_VAR <= NF; ++LOOP_VAR)
// FI[$LOOP_VAR] = LOOP_VAR;
// update_used_fields()
// }
let loop_var = arena.alloc(Var(LOOP_VAR.into()));
let init = arena.alloc(Expr(arena.alloc(Assign(loop_var, arena.alloc(ILit(1))))));
let cond = arena.alloc(Binop(
self::Binop::LTE,
loop_var,
arena.alloc(Var("NF".into())),
));
let update = arena.alloc(Expr(arena.alloc(Inc {
is_inc: true,
is_post: false,
x: loop_var,
})));
let body = arena.alloc(Expr(arena.alloc(Call(
Either::Right(Function::SetFI),
arena.alloc_slice(&[loop_var, loop_var]),
))));
let block = arena.new_vec_from_slice(&[
arena.alloc(For(Some(init), Some(cond), Some(update), body)),
arena.alloc(Expr(
arena.alloc(Call(Either::Right(Function::UpdateUsedFields), &[])),
)),
]);
begin.push(arena.alloc(If(
arena.alloc(Binop(
self::Binop::GT,
arena.alloc(ReadStdin),
arena.alloc(ILit(0)),
)),
arena.alloc(Block(block)),
/*else*/ None,
)));
}
impl<'a, 'b, I: From<&'b str> + Clone> Prog<'a, 'b, I> {
pub(crate) fn from_stage(arena: &'a Arena, stage: Stage<()>) -> Self {
Prog {
field_sep: None,
prelude_vardecs: Vec::new(),
output_sep: None,
output_record_sep: None,
decs: arena.new_vec(),
begin: arena.new_vec(),
prepare: arena.new_vec(),
end: arena.new_vec(),
pats: arena.new_vec(),
argv: Vec::new(),
parse_header: false,
stage,
}
}
pub(crate) fn desugar_stage(&self, arena: &'a Arena) -> Stage<&'a Stmt<'a, 'b, I>> {
use {self::Binop::*, self::Expr::*, Stmt::*};
let mut conds = 0;
let mut begin = arena.vec_with_capacity(self.begin.len() * 2);
let mut main_loop = None;
let mut end = None;
// Desugar -F flag
if let Some(sep) = self.field_sep {
begin.push(arena.alloc(Expr(arena.alloc(Assign(
arena.alloc(Var("FS".into())),
arena.alloc(StrLit(sep)),
)))));
}
// for -H
if self.parse_header {
parse_header(arena, &mut begin);
}
// Support "output csv/tsv" mode
if let Some(sep) = self.output_sep {
begin.push(arena.alloc(Expr(arena.alloc(Assign(
arena.alloc(Var("OFS".into())),
arena.alloc(StrLit(sep)),
)))));
}
if let Some(sep) = self.output_record_sep {
begin.push(arena.alloc(Expr(arena.alloc(Assign(
arena.alloc(Var("ORS".into())),
arena.alloc(StrLit(sep)),
)))));
}
// Assign SUBSEP, which we treat as a normal variable
begin.push(arena.alloc(Expr(arena.alloc(Assign(
arena.alloc(Var("SUBSEP".into())),
arena.alloc(StrLit(&[0o034u8])),
)))));
// Desugar -v flags
for (ident, exp) in self.prelude_vardecs.iter() {
begin.push(arena.alloc(Expr(
arena.alloc(Assign(arena.alloc(Var(ident.clone())), exp)),
)));
}
// Set argc, argv
if self.argv.len() > 0 {
begin.push(arena.alloc(Expr(arena.alloc(Assign(
arena.alloc(Var("ARGC".into())),
arena.alloc(ILit(self.argv.len() as i64)),
)))));
let argv = arena.alloc(Var("ARGV".into()));
for (ix, arg) in self.argv.iter().enumerate() {
let arg = arena.alloc(StrLit(arg.as_bytes()));
let ix = arena.alloc(ILit(ix as i64));
let arr_exp = arena.alloc(Index(argv, ix));
begin.push(arena.alloc(Expr(arena.alloc(Assign(arr_exp, arg)))));
}
}
begin.extend(self.begin.iter().cloned());
// Desugar patterns into if statements, with the usual desugaring for an empty action.
let mut inner = arena.vec_with_capacity(10);
inner.push(arena.alloc(Expr(arena.alloc(Inc {
is_inc: true,
is_post: false,
x: arena.alloc(Var("NR".into())),
}))));
inner.push(arena.alloc(Expr(arena.alloc(Inc {
is_inc: true,
is_post: false,
x: arena.alloc(Var("FNR".into())),
}))));
let init_len = inner.len();
for (pat, body) in self.pats.iter() {
let body = if let Some(body) = body {
body
} else {
arena.alloc(Print(&[], None))
};
match pat {
Pattern::Null => inner.push(body),
Pattern::Bool(pat) => inner.push(arena.alloc(If(pat, body, None))),
Pattern::Comma(l, r) => {
let mut block = arena.vec_with_capacity(2);
// Comma patterns run the corresponding action between pairs of lines matching
// patterns `l` and `r`, inclusive. One common example is the patterh
// /\/*/,/*\//
// Matching block comments in several propular languages. We desugar these with
// special statements StartCond, LastCond, EndCond, as well as the Cond
// expression. Each of these is tagged with an identifier indicating which
// comma pattern the statement or expression is referencing. In the cfg module,
// these are compiled to simple assignments and reads on a pattern-specific
// local variable:
//
// StartCond sets the variable to 1
// EndCond sets the variable to 0
// LastCond stes the variable to 2
// Cond reads the variable.
//
// Why do you need LastCond? We can mostly make due without it. Consider the
// fragment:
// /\/*/,/*\// { i++ }
// We can desugar this quite easily as:
// /\/*/ { StartCond(0); } # _cond_0 = 1
// Cond(0) { i++; } # if _cond_0
// /*\// { EndCond(0); } # _cond_0 = 0
// We get into trouble, however, if control flow is more complex. If we wanted
// to strip comments we might write:
// /\/*/,/*\// { next; }
// { print; }
// But applying the above desugaring rules leads us to running `next` before we
// can set EndCond. No output will be printed after we encounter our first
// comment, regardless of what comes after.
//
// To fix this, we introduce LastCond and use it to signal that the pattern
// should not match in the next iteration.
// /\/*/ { StartCond(0); } # _cond_0 = 1
// /*\// { LastCond(0); } # _cond_0 = 2
// Cond(0) {
// # We matched the end of a comment. End the condition before `next`;
// if (Cond(0) == 2) EndCond(0); # _cond_0 = 0;
// next;
// }
inner.push(arena.alloc(If(l, arena.alloc(StartCond(conds)), None)));
inner.push(arena.alloc(If(r, arena.alloc(LastCond(conds)), None)));
block.push(arena.alloc(If(
arena.alloc(Binop(EQ, arena.alloc(Cond(conds)), arena.alloc(ILit(2)))),
arena.alloc(EndCond(conds)),
None,
)));
block.push(body);
inner.push(arena.alloc(If(
arena.alloc(Cond(conds)),
arena.alloc(Block(block)),
None,
)));
conds += 1;
}
}
}
if self.end.len() > 0 || self.prepare.len() > 0 || inner.len() > init_len {
// Wrap the whole thing in a while((getline) > 0) { } statement.
let main_portion = arena.alloc(While(
/*is_toplevel=*/ true,
arena.alloc(Binop(GT, arena.alloc(ReadStdin), arena.alloc(ILit(0)))),
arena.alloc(Block(inner)),
));
main_loop = Some(if self.prepare.len() > 0 {
let mut block = arena.vec_with_capacity(self.prepare.len() + 1);
block.push(main_portion);
block.extend(self.prepare.iter().cloned());
arena.alloc(Stmt::Block(block))
} else {
main_portion
});
}
if self.end.len() > 0 {
end = Some(arena.alloc(Stmt::Block(self.end.clone())));
}
match self.stage {
Stage::Main(_) => {
begin.extend(main_loop.into_iter().chain(end));
Stage::Main(arena.alloc(Stmt::Block(begin)))
}
Stage::Par { .. } => Stage::Par {
begin: if begin.len() > 0 {
Some(arena.alloc(Stmt::Block(begin)))
} else {
None
},
main_loop,
end,
},
}
}
}
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub enum Binop {
Plus,
Minus,
Mult,
Div,
Mod,
Concat,
IsMatch,
Pow,
LT,
GT,
LTE,
GTE,
EQ,
}
static_map!(
BINOPS<&'static str, Binop>,
["+", Binop::Plus],
["-", Binop::Minus],
["*", Binop::Mult],
["/", Binop::Div],
["%", Binop::Mod],
["", Binop::Concat], // we may have to handle this one specially
["~", Binop::IsMatch],
["<", Binop::LT],
[">", Binop::GT],
["<=", Binop::LTE],
[">=", Binop::GTE],
["==", Binop::EQ],
["^", Binop::Pow]
);
#[derive(Debug, Clone)]
pub enum Expr<'a, 'b, I> {
ILit(i64),
FLit(f64),
StrLit(&'b [u8]),
PatLit(&'b [u8]),
Unop(Unop, &'a Expr<'a, 'b, I>),
Binop(Binop, &'a Expr<'a, 'b, I>, &'a Expr<'a, 'b, I>),
Call(Either<I, Function>, &'a [&'a Expr<'a, 'b, I>]),
Var(I),
Index(&'a Expr<'a, 'b, I>, &'a Expr<'a, 'b, I>),
Assign(
&'a Expr<'a, 'b, I>, /*var or index expression*/
&'a Expr<'a, 'b, I>,
),
AssignOp(&'a Expr<'a, 'b, I>, Binop, &'a Expr<'a, 'b, I>),
And(&'a Expr<'a, 'b, I>, &'a Expr<'a, 'b, I>),
Or(&'a Expr<'a, 'b, I>, &'a Expr<'a, 'b, I>),
ITE(
&'a Expr<'a, 'b, I>,
&'a Expr<'a, 'b, I>,
&'a Expr<'a, 'b, I>,
),
Inc {
is_inc: bool,
is_post: bool,
x: &'a Expr<'a, 'b, I>,
},
Getline {
into: Option<&'a Expr<'a, 'b, I>>,
from: Option<&'a Expr<'a, 'b, I>>,
is_file: bool,
},
ReadStdin,
// Used for comma patterns
Cond(usize),
}
#[derive(Debug, Clone)]
pub enum Stmt<'a, 'b, I> {
StartCond(usize),
EndCond(usize),
LastCond(usize),
Expr(&'a Expr<'a, 'b, I>),
Block(arena::Vec<'a, &'a Stmt<'a, 'b, I>>),
Print(
&'a [&'a Expr<'a, 'b, I>],
Option<(&'a Expr<'a, 'b, I>, FileSpec)>,
),
// Unlike print, printf must have at least one argument.
Printf(
&'a Expr<'a, 'b, I>,
&'a [&'a Expr<'a, 'b, I>],
Option<(&'a Expr<'a, 'b, I>, FileSpec)>,
),
If(
&'a Expr<'a, 'b, I>,
&'a Stmt<'a, 'b, I>,
Option<&'a Stmt<'a, 'b, I>>,
),
For(
Option<&'a Stmt<'a, 'b, I>>,
Option<&'a Expr<'a, 'b, I>>,
Option<&'a Stmt<'a, 'b, I>>,
&'a Stmt<'a, 'b, I>,
),
DoWhile(&'a Expr<'a, 'b, I>, &'a Stmt<'a, 'b, I>),
// We mark some while loops as "special" because of the special "next" and "nextfile" commands,
// that work as a special "labelled continue" for the toplevel loop.
While(
/*is_toplevel*/ bool,
&'a Expr<'a, 'b, I>,
&'a Stmt<'a, 'b, I>,
),
ForEach(I, &'a Expr<'a, 'b, I>, &'a Stmt<'a, 'b, I>),
Break,
Continue,
Next,
NextFile,
Return(Option<&'a Expr<'a, 'b, I>>),
}
|
use actix_web::web::block;
use diesel::pg::PgConnection;
use diesel::r2d2::{ConnectionManager, PooledConnection};
use serde::{Deserialize, Serialize};
use db::models::{Round, UserAnswer, UserQuestion};
use errors::Error;
#[derive(Deserialize, PartialEq, Serialize)]
pub struct GetRoundPicksResponse {
pub data: Vec<UserAnswer>,
pub locked: bool,
}
pub async fn get_round_picks(
connection: PooledConnection<ConnectionManager<PgConnection>>,
game_id: i32,
) -> Result<GetRoundPicksResponse, Error> {
let data: Result<(Vec<UserAnswer>, bool), Error> = block(move || {
let round = Round::get_active_round_by_game_id(&connection, game_id)?;
let user_questions = UserQuestion::find_by_round(&connection, round.id)?;
Ok((user_questions, round.locked))
})
.await?;
let (user_questions, locked) = data?;
Ok(GetRoundPicksResponse {
data: user_questions,
locked,
})
}
|
use P80::graph_converters::unlabeled;
use P87::*;
pub fn main() {
let g = unlabeled::from_string("[a-b, b-c, e, a-c, a-d]");
println!("{:?}", nodes_by_depth_from(&g, 'd'));
}
|
//! Maps literals and hashes of clause steps between the solver and the checker.
use varisat_formula::{Lit, Var};
use super::{ClauseHash, ProofStep};
/// Maps literals and hashes of clause steps between the solver and the checker.
#[derive(Default)]
pub struct MapStep {
lit_buf: Vec<Lit>,
hash_buf: Vec<ClauseHash>,
unit_buf: Vec<(Lit, ClauseHash)>,
}
impl MapStep {
pub fn map_lits(&mut self, lits: &[Lit], map_var: impl Fn(Var) -> Var) -> &[Lit] {
let map_var_ref = &map_var;
self.lit_buf.clear();
self.lit_buf
.extend(lits.iter().map(|lit| lit.map_var(map_var_ref)));
&self.lit_buf
}
pub fn map<'s, 'a, 'b>(
&'a mut self,
step: &ProofStep<'b>,
map_var: impl Fn(Var) -> Var,
map_hash: impl Fn(ClauseHash) -> ClauseHash,
) -> ProofStep<'s>
where
'a: 's,
'b: 's,
{
let map_var_ref = &map_var;
let map_lit = |lit: Lit| lit.map_var(map_var_ref);
match *step {
ProofStep::AddClause { clause } => {
self.lit_buf.clear();
self.lit_buf.extend(clause.iter().cloned().map(map_lit));
ProofStep::AddClause {
clause: &self.lit_buf,
}
}
ProofStep::AtClause {
redundant,
clause,
propagation_hashes,
} => {
self.lit_buf.clear();
self.lit_buf.extend(clause.iter().cloned().map(map_lit));
self.hash_buf.clear();
self.hash_buf
.extend(propagation_hashes.iter().cloned().map(map_hash));
ProofStep::AtClause {
redundant,
clause: &self.lit_buf,
propagation_hashes: &self.hash_buf,
}
}
ProofStep::UnitClauses { units } => {
self.unit_buf.clear();
self.unit_buf.extend(
units
.iter()
.map(|&(lit, hash)| (map_lit(lit), map_hash(hash))),
);
ProofStep::UnitClauses {
units: &self.unit_buf,
}
}
ProofStep::DeleteClause { clause, proof } => {
self.lit_buf.clear();
self.lit_buf.extend(clause.iter().cloned().map(map_lit));
ProofStep::DeleteClause {
clause: &self.lit_buf,
proof,
}
}
ProofStep::Model { assignment } => {
self.lit_buf.clear();
self.lit_buf.extend(assignment.iter().cloned().map(map_lit));
ProofStep::Model {
assignment: &self.lit_buf,
}
}
ProofStep::Assumptions { assumptions } => {
self.lit_buf.clear();
self.lit_buf
.extend(assumptions.iter().cloned().map(map_lit));
ProofStep::Assumptions {
assumptions: &self.lit_buf,
}
}
ProofStep::FailedAssumptions {
failed_core,
propagation_hashes,
} => {
self.lit_buf.clear();
self.lit_buf
.extend(failed_core.iter().cloned().map(map_lit));
self.hash_buf.clear();
self.hash_buf
.extend(propagation_hashes.iter().cloned().map(map_hash));
ProofStep::FailedAssumptions {
failed_core: &self.lit_buf,
propagation_hashes: &self.hash_buf,
}
}
ProofStep::ChangeHashBits { .. } | ProofStep::End => *step,
ProofStep::SolverVarName { .. }
| ProofStep::UserVarName { .. }
| ProofStep::DeleteVar { .. }
| ProofStep::ChangeSamplingMode { .. } => {
// while these steps do contain variables, they are used to update the mapping, so
// they shouldn't be mapped themselves.
*step
}
}
}
}
|
mod sorted;
pub use sorted::{AssumeSorted, AssumingSortedIter, Sorted};
|
#[doc = "Reader of register RXDLADDR"]
pub type R = crate::R<u32, super::RXDLADDR>;
#[doc = "Writer for register RXDLADDR"]
pub type W = crate::W<u32, super::RXDLADDR>;
#[doc = "Register RXDLADDR `reset()`'s with value 0"]
impl crate::ResetValue for super::RXDLADDR {
type Type = u32;
#[inline(always)]
fn reset_value() -> Self::Type {
0
}
}
#[doc = "Reader of field `STRXLIST`"]
pub type STRXLIST_R = crate::R<u32, u32>;
#[doc = "Write proxy for field `STRXLIST`"]
pub struct STRXLIST_W<'a> {
w: &'a mut W,
}
impl<'a> STRXLIST_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u32) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x3fff_ffff << 2)) | (((value as u32) & 0x3fff_ffff) << 2);
self.w
}
}
impl R {
#[doc = "Bits 2:31 - Start of Receive List"]
#[inline(always)]
pub fn strxlist(&self) -> STRXLIST_R {
STRXLIST_R::new(((self.bits >> 2) & 0x3fff_ffff) as u32)
}
}
impl W {
#[doc = "Bits 2:31 - Start of Receive List"]
#[inline(always)]
pub fn strxlist(&mut self) -> STRXLIST_W {
STRXLIST_W { w: self }
}
}
|
mod logger;
mod command;
mod cli;
pub use self::cli::CLI;
pub use self::command::Command;
|
/*
* Copyright 2020 Fluence Labs 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.
*/
use super::builtin_service::BuiltinService;
//use super::router::Service::Delegated;
use super::FunctionRouter;
use crate::function::waiting_queues::Enqueued;
use faas_api::{Address, FunctionCall, Protocol};
use libp2p::PeerId;
use std::collections::HashSet;
impl FunctionRouter {
// ####
// ## Service routing
// ###
pub(super) fn service_available_locally(&self, service: &Protocol) -> bool {
BuiltinService::is_builtin(service) || self.provided_names.contains_key(&service.into())
}
/// Execute call locally: on builtin service or forward to provided name
/// `ttl` – time to live (akin to ICMP ttl), if `0`, execute and drop, don't forward
pub(super) fn pass_to_local_service(
&mut self,
service: Protocol,
mut call: FunctionCall,
ttl: usize,
) {
if BuiltinService::is_builtin(&service) {
match BuiltinService::from(&service, call.arguments.clone()) {
Ok(builtin) => self.execute_builtin(builtin, call, ttl),
Err(err) => {
self.send_error_on_call(call, format!("builtin service error: {}", err))
}
}
return;
}
if let Some(provider) = self.provided_names.get(&Address::from(&service)).cloned() {
log::info!(
"Service {} was found locally. uuid {}",
&service,
&call.uuid
);
log::info!("Forwarding service call {} to {}", call.uuid, provider);
call.target = Some(
call.target
.map_or(provider.clone(), |target| provider.extend(&target)),
);
self.call(call);
return;
}
let err_msg = "unroutable message: no local provider found for target".to_string();
log::warn!("Error on {}: {}", &call.uuid, err_msg);
self.send_error_on_call(call, err_msg);
}
// Look for service providers, enqueue call to wait for providers
pub(super) fn find_service_provider(&mut self, name: Address, call: FunctionCall) {
log::info!("Finding service provider for {}, call: {:?}", name, call);
if let Enqueued::New = self.wait_name_resolved.enqueue(name.clone(), call) {
// won't call get_providers if there are already calls waiting for it
self.resolve_name(&name)
} else {
log::debug!(
"won't call resolve_name because there are already promises waiting for {}",
name
)
}
}
// Advance execution for calls waiting for this service: send them to first provider
pub fn providers_found(&mut self, name: &Address, providers: HashSet<Address>) {
if providers.is_empty() {
self.provider_search_failed(name, "zero providers found");
} else {
self.provider_search_succeeded(name, providers)
}
}
fn provider_search_succeeded(&mut self, name: &Address, providers: HashSet<Address>) {
log::info!(
"Found {} providers for name {}: {:?}",
providers.len(),
name,
providers
);
let mut calls = self.wait_name_resolved.remove(&name).peekable();
// Check if calls are empty without actually advancing iterator
if calls.peek().is_none() && !providers.is_empty() {
log::warn!(
"Providers found for {}, but there are no calls waiting for it",
name
);
}
// TODO: Sending call to all providers here,
// implement and use ProviderSelector::All, ProviderSelector::Latest, ProviderSelector::MaxWeight
// TODO: weight providers according to TrustGraph
for call in calls {
for provider in providers.iter() {
let mut call = call.clone();
call.target = Some(
call.target
.map_or(provider.clone(), |target| provider.clone().extend(target)),
);
// TODO: write tests on that, it's a very complex decision
// call.target = Some(provider.clone());
log::debug!("Sending call to provider {:?}", call);
self.call(call);
}
}
}
pub(super) fn provider_search_failed(&mut self, name: &Address, reason: &str) {
let mut calls = self.wait_name_resolved.remove(name).peekable();
// Check if calls are empty without actually advancing iterator
if calls.peek().is_none() {
log::warn!("Failed to find providers for {}: {}; 0 calls", name, reason);
return;
} else {
log::warn!("Failed to find providers for {}: {}", name, reason);
}
for call in calls {
self.send_error_on_call(
call,
format!("Failed to find providers for {}: {}", name, reason),
);
}
}
// Removes all names that resolve to an address containing `resolvee`
pub(super) fn remove_halted_names(&mut self, resolvee: &PeerId) {
use Protocol::*;
self.provided_names.retain(|k, v| {
let protocols = v.protocols();
let halted = protocols.iter().any(|p| match p {
Peer(id) if id == resolvee => true,
Client(id) if id == resolvee => true,
_ => false,
});
if halted {
log::info!(
"Removing halted name {}. forward_to: {} due to peer {} disconnection",
k,
v,
resolvee
);
}
!halted
});
}
}
|
mod utils;
use wasm_bindgen::prelude::*;
use rand::{Rng, SeedableRng};
use rand::rngs::SmallRng;
extern crate web_sys;
extern crate js_sys;
extern crate rand;
// A macro to provide `println!(..)`-style syntax for `console.log` logging.
macro_rules! log {
( $( $t:tt )* ) => {
web_sys::console::log_1(&format!( $( $t )* ).into());
}
}
// When the `wee_alloc` feature is enabled, use `wee_alloc` as the global
// allocator.
#[cfg(feature = "wee_alloc")]
#[global_allocator]
static ALLOC: wee_alloc::WeeAlloc = wee_alloc::WeeAlloc::INIT;
#[wasm_bindgen]
extern {
fn alert(s: &str);
}
#[wasm_bindgen]
pub fn greet() {
alert("Hello, wasm-graph-analyzer!");
}
#[wasm_bindgen]
pub struct Graph {
nb_nodes: usize,
nb_neighbors_by_node: usize,
neighbors: Vec<usize>
}
impl Graph {
fn get_random_neighbor(&self, node_id: usize) -> usize {
20
}
}
#[wasm_bindgen]
impl Graph {
pub fn new(nb_nodes: usize, nb_neighbors_by_node: usize, neighbors: Vec<usize>) -> Graph {
Graph {
nb_nodes,
nb_neighbors_by_node,
neighbors,
}
}
pub fn random_walk(&self, nb_iterations: usize) -> Vec<u32> {
let mut rng = SmallRng::from_entropy();
let mut nb_times_visited_nodes: Vec<u32> = Vec::new();
for _node in 0..self.nb_nodes {
nb_times_visited_nodes.push(0);
}
for init_node in 0..self.nb_nodes {
for _tmp in 1..10 {
let mut current_node = init_node;
// let mut current_node: usize = (js_sys::Math::random()*self.nb_nodes as f64) as usize;
nb_times_visited_nodes[current_node] += 1;
// let mut rng = rand::thread_rng();
for _iteration in 0..nb_iterations {
let selected_neighbor_index = rng.gen_range(0, self.nb_neighbors_by_node);
let node_row: usize = current_node*self.nb_neighbors_by_node;
current_node = self.neighbors[node_row + selected_neighbor_index];
nb_times_visited_nodes[current_node] += 1;
}
}
}
nb_times_visited_nodes
}
}
|
// auto generated, do not modify.
// created: Mon Feb 22 23:57:02 2016
// src-file: /QtGui/qtextformat.h
// dst-file: /src/gui/qtextformat.rs
//
// header block begin =>
#![feature(libc)]
#![feature(core)]
#![feature(collections)]
extern crate libc;
use self::libc::*;
// <= header block end
// main block begin =>
// <= main block end
// use block begin =>
use std::ops::Deref;
// use super::qtextformat::QTextCharFormat; // 773
use super::super::core::qstring::*; // 771
// use super::qtextformat::QTextBlockFormat; // 773
// use super::qvector::*; // 775
// use super::qtextformat::QTextLength; // 773
use super::qcolor::*; // 773
use super::qbrush::*; // 773
// use super::qtextformat::QTextFrameFormat; // 773
use super::qpen::*; // 773
use super::super::core::qvariant::*; // 771
// use super::qtextformat::QTextImageFormat; // 773
// use super::qtextformat::QTextTableFormat; // 773
// use super::qtextformat::QTextTableCellFormat; // 773
// use super::qtextformat::QTextListFormat; // 773
// use super::qmap::*; // 775
// use super::qtextformat::QTextFormat; // 773
use super::qfont::*; // 773
use super::super::core::qstringlist::*; // 771
// <= use block end
// ext block begin =>
// #[link(name = "Qt5Core")]
// #[link(name = "Qt5Gui")]
// #[link(name = "Qt5Widgets")]
// #[link(name = "QtInline")]
extern {
fn QTextLength_Class_Size() -> c_int;
// proto: qreal QTextLength::value(qreal maximumLength);
fn C_ZNK11QTextLength5valueEd(qthis: u64 /* *mut c_void*/, arg0: c_double) -> c_double;
// proto: void QTextLength::QTextLength();
fn C_ZN11QTextLengthC2Ev() -> u64;
// proto: qreal QTextLength::rawValue();
fn C_ZNK11QTextLength8rawValueEv(qthis: u64 /* *mut c_void*/) -> c_double;
fn QTextImageFormat_Class_Size() -> c_int;
// proto: void QTextImageFormat::QTextImageFormat();
fn C_ZN16QTextImageFormatC2Ev() -> u64;
// proto: bool QTextImageFormat::isValid();
fn C_ZNK16QTextImageFormat7isValidEv(qthis: u64 /* *mut c_void*/) -> c_char;
// proto: qreal QTextImageFormat::width();
fn C_ZNK16QTextImageFormat5widthEv(qthis: u64 /* *mut c_void*/) -> c_double;
// proto: void QTextImageFormat::setHeight(qreal height);
fn C_ZN16QTextImageFormat9setHeightEd(qthis: u64 /* *mut c_void*/, arg0: c_double);
// proto: void QTextImageFormat::setWidth(qreal width);
fn C_ZN16QTextImageFormat8setWidthEd(qthis: u64 /* *mut c_void*/, arg0: c_double);
// proto: void QTextImageFormat::setName(const QString & name);
fn C_ZN16QTextImageFormat7setNameERK7QString(qthis: u64 /* *mut c_void*/, arg0: *mut c_void);
// proto: QString QTextImageFormat::name();
fn C_ZNK16QTextImageFormat4nameEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
// proto: qreal QTextImageFormat::height();
fn C_ZNK16QTextImageFormat6heightEv(qthis: u64 /* *mut c_void*/) -> c_double;
fn QTextFormat_Class_Size() -> c_int;
// proto: QTextBlockFormat QTextFormat::toBlockFormat();
fn C_ZNK11QTextFormat13toBlockFormatEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
// proto: QString QTextFormat::stringProperty(int propertyId);
fn C_ZNK11QTextFormat14stringPropertyEi(qthis: u64 /* *mut c_void*/, arg0: c_int) -> *mut c_void;
// proto: QVector<QTextLength> QTextFormat::lengthVectorProperty(int propertyId);
fn C_ZNK11QTextFormat20lengthVectorPropertyEi(qthis: u64 /* *mut c_void*/, arg0: c_int) -> *mut c_void;
// proto: int QTextFormat::objectIndex();
fn C_ZNK11QTextFormat11objectIndexEv(qthis: u64 /* *mut c_void*/) -> c_int;
// proto: void QTextFormat::setObjectIndex(int object);
fn C_ZN11QTextFormat14setObjectIndexEi(qthis: u64 /* *mut c_void*/, arg0: c_int);
// proto: void QTextFormat::clearForeground();
fn C_ZN11QTextFormat15clearForegroundEv(qthis: u64 /* *mut c_void*/);
// proto: bool QTextFormat::isTableCellFormat();
fn C_ZNK11QTextFormat17isTableCellFormatEv(qthis: u64 /* *mut c_void*/) -> c_char;
// proto: void QTextFormat::~QTextFormat();
fn C_ZN11QTextFormatD2Ev(qthis: u64 /* *mut c_void*/);
// proto: bool QTextFormat::isValid();
fn C_ZNK11QTextFormat7isValidEv(qthis: u64 /* *mut c_void*/) -> c_char;
// proto: void QTextFormat::QTextFormat(const QTextFormat & rhs);
fn C_ZN11QTextFormatC2ERKS_(arg0: *mut c_void) -> u64;
// proto: QTextLength QTextFormat::lengthProperty(int propertyId);
fn C_ZNK11QTextFormat14lengthPropertyEi(qthis: u64 /* *mut c_void*/, arg0: c_int) -> *mut c_void;
// proto: void QTextFormat::merge(const QTextFormat & other);
fn C_ZN11QTextFormat5mergeERKS_(qthis: u64 /* *mut c_void*/, arg0: *mut c_void);
// proto: QColor QTextFormat::colorProperty(int propertyId);
fn C_ZNK11QTextFormat13colorPropertyEi(qthis: u64 /* *mut c_void*/, arg0: c_int) -> *mut c_void;
// proto: void QTextFormat::QTextFormat();
fn C_ZN11QTextFormatC2Ev() -> u64;
// proto: void QTextFormat::setForeground(const QBrush & brush);
fn C_ZN11QTextFormat13setForegroundERK6QBrush(qthis: u64 /* *mut c_void*/, arg0: *mut c_void);
// proto: bool QTextFormat::boolProperty(int propertyId);
fn C_ZNK11QTextFormat12boolPropertyEi(qthis: u64 /* *mut c_void*/, arg0: c_int) -> c_char;
// proto: bool QTextFormat::isListFormat();
fn C_ZNK11QTextFormat12isListFormatEv(qthis: u64 /* *mut c_void*/) -> c_char;
// proto: void QTextFormat::QTextFormat(int type);
fn C_ZN11QTextFormatC2Ei(arg0: c_int) -> u64;
// proto: bool QTextFormat::isImageFormat();
fn C_ZNK11QTextFormat13isImageFormatEv(qthis: u64 /* *mut c_void*/) -> c_char;
// proto: void QTextFormat::clearProperty(int propertyId);
fn C_ZN11QTextFormat13clearPropertyEi(qthis: u64 /* *mut c_void*/, arg0: c_int);
// proto: QTextFrameFormat QTextFormat::toFrameFormat();
fn C_ZNK11QTextFormat13toFrameFormatEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
// proto: QBrush QTextFormat::brushProperty(int propertyId);
fn C_ZNK11QTextFormat13brushPropertyEi(qthis: u64 /* *mut c_void*/, arg0: c_int) -> *mut c_void;
// proto: int QTextFormat::propertyCount();
fn C_ZNK11QTextFormat13propertyCountEv(qthis: u64 /* *mut c_void*/) -> c_int;
// proto: QPen QTextFormat::penProperty(int propertyId);
fn C_ZNK11QTextFormat11penPropertyEi(qthis: u64 /* *mut c_void*/, arg0: c_int) -> *mut c_void;
// proto: QVariant QTextFormat::property(int propertyId);
fn C_ZNK11QTextFormat8propertyEi(qthis: u64 /* *mut c_void*/, arg0: c_int) -> *mut c_void;
// proto: bool QTextFormat::isTableFormat();
fn C_ZNK11QTextFormat13isTableFormatEv(qthis: u64 /* *mut c_void*/) -> c_char;
// proto: void QTextFormat::setProperty(int propertyId, const QVariant & value);
fn C_ZN11QTextFormat11setPropertyEiRK8QVariant(qthis: u64 /* *mut c_void*/, arg0: c_int, arg1: *mut c_void);
// proto: int QTextFormat::type();
fn C_ZNK11QTextFormat4typeEv(qthis: u64 /* *mut c_void*/) -> c_int;
// proto: bool QTextFormat::isCharFormat();
fn C_ZNK11QTextFormat12isCharFormatEv(qthis: u64 /* *mut c_void*/) -> c_char;
// proto: void QTextFormat::clearBackground();
fn C_ZN11QTextFormat15clearBackgroundEv(qthis: u64 /* *mut c_void*/);
// proto: bool QTextFormat::isBlockFormat();
fn C_ZNK11QTextFormat13isBlockFormatEv(qthis: u64 /* *mut c_void*/) -> c_char;
// proto: QBrush QTextFormat::background();
fn C_ZNK11QTextFormat10backgroundEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
// proto: qreal QTextFormat::doubleProperty(int propertyId);
fn C_ZNK11QTextFormat14doublePropertyEi(qthis: u64 /* *mut c_void*/, arg0: c_int) -> c_double;
// proto: void QTextFormat::swap(QTextFormat & other);
fn C_ZN11QTextFormat4swapERS_(qthis: u64 /* *mut c_void*/, arg0: *mut c_void);
// proto: QTextImageFormat QTextFormat::toImageFormat();
fn C_ZNK11QTextFormat13toImageFormatEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
// proto: bool QTextFormat::hasProperty(int propertyId);
fn C_ZNK11QTextFormat11hasPropertyEi(qthis: u64 /* *mut c_void*/, arg0: c_int) -> c_char;
// proto: QBrush QTextFormat::foreground();
fn C_ZNK11QTextFormat10foregroundEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
// proto: void QTextFormat::setObjectType(int type);
fn C_ZN11QTextFormat13setObjectTypeEi(qthis: u64 /* *mut c_void*/, arg0: c_int);
// proto: void QTextFormat::setBackground(const QBrush & brush);
fn C_ZN11QTextFormat13setBackgroundERK6QBrush(qthis: u64 /* *mut c_void*/, arg0: *mut c_void);
// proto: QTextTableFormat QTextFormat::toTableFormat();
fn C_ZNK11QTextFormat13toTableFormatEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
// proto: bool QTextFormat::isFrameFormat();
fn C_ZNK11QTextFormat13isFrameFormatEv(qthis: u64 /* *mut c_void*/) -> c_char;
// proto: int QTextFormat::intProperty(int propertyId);
fn C_ZNK11QTextFormat11intPropertyEi(qthis: u64 /* *mut c_void*/, arg0: c_int) -> c_int;
// proto: QTextCharFormat QTextFormat::toCharFormat();
fn C_ZNK11QTextFormat12toCharFormatEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
// proto: bool QTextFormat::isEmpty();
fn C_ZNK11QTextFormat7isEmptyEv(qthis: u64 /* *mut c_void*/) -> c_char;
// proto: QTextTableCellFormat QTextFormat::toTableCellFormat();
fn C_ZNK11QTextFormat17toTableCellFormatEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
// proto: int QTextFormat::objectType();
fn C_ZNK11QTextFormat10objectTypeEv(qthis: u64 /* *mut c_void*/) -> c_int;
// proto: QTextListFormat QTextFormat::toListFormat();
fn C_ZNK11QTextFormat12toListFormatEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
// proto: QMap<int, QVariant> QTextFormat::properties();
fn C_ZNK11QTextFormat10propertiesEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
fn QTextBlockFormat_Class_Size() -> c_int;
// proto: int QTextBlockFormat::indent();
fn C_ZNK16QTextBlockFormat6indentEv(qthis: u64 /* *mut c_void*/) -> c_int;
// proto: void QTextBlockFormat::setTextIndent(qreal aindent);
fn C_ZN16QTextBlockFormat13setTextIndentEd(qthis: u64 /* *mut c_void*/, arg0: c_double);
// proto: void QTextBlockFormat::setNonBreakableLines(bool b);
fn C_ZN16QTextBlockFormat20setNonBreakableLinesEb(qthis: u64 /* *mut c_void*/, arg0: c_char);
// proto: void QTextBlockFormat::setIndent(int indent);
fn C_ZN16QTextBlockFormat9setIndentEi(qthis: u64 /* *mut c_void*/, arg0: c_int);
// proto: qreal QTextBlockFormat::textIndent();
fn C_ZNK16QTextBlockFormat10textIndentEv(qthis: u64 /* *mut c_void*/) -> c_double;
// proto: qreal QTextBlockFormat::lineHeight();
fn C_ZNK16QTextBlockFormat10lineHeightEv(qthis: u64 /* *mut c_void*/) -> c_double;
// proto: qreal QTextBlockFormat::lineHeight(qreal scriptLineHeight, qreal scaling);
fn C_ZNK16QTextBlockFormat10lineHeightEdd(qthis: u64 /* *mut c_void*/, arg0: c_double, arg1: c_double) -> c_double;
// proto: void QTextBlockFormat::setRightMargin(qreal margin);
fn C_ZN16QTextBlockFormat14setRightMarginEd(qthis: u64 /* *mut c_void*/, arg0: c_double);
// proto: qreal QTextBlockFormat::topMargin();
fn C_ZNK16QTextBlockFormat9topMarginEv(qthis: u64 /* *mut c_void*/) -> c_double;
// proto: void QTextBlockFormat::QTextBlockFormat();
fn C_ZN16QTextBlockFormatC2Ev() -> u64;
// proto: qreal QTextBlockFormat::rightMargin();
fn C_ZNK16QTextBlockFormat11rightMarginEv(qthis: u64 /* *mut c_void*/) -> c_double;
// proto: qreal QTextBlockFormat::bottomMargin();
fn C_ZNK16QTextBlockFormat12bottomMarginEv(qthis: u64 /* *mut c_void*/) -> c_double;
// proto: void QTextBlockFormat::setTopMargin(qreal margin);
fn C_ZN16QTextBlockFormat12setTopMarginEd(qthis: u64 /* *mut c_void*/, arg0: c_double);
// proto: qreal QTextBlockFormat::leftMargin();
fn C_ZNK16QTextBlockFormat10leftMarginEv(qthis: u64 /* *mut c_void*/) -> c_double;
// proto: void QTextBlockFormat::setLineHeight(qreal height, int heightType);
fn C_ZN16QTextBlockFormat13setLineHeightEdi(qthis: u64 /* *mut c_void*/, arg0: c_double, arg1: c_int);
// proto: void QTextBlockFormat::setBottomMargin(qreal margin);
fn C_ZN16QTextBlockFormat15setBottomMarginEd(qthis: u64 /* *mut c_void*/, arg0: c_double);
// proto: int QTextBlockFormat::lineHeightType();
fn C_ZNK16QTextBlockFormat14lineHeightTypeEv(qthis: u64 /* *mut c_void*/) -> c_int;
// proto: void QTextBlockFormat::setLeftMargin(qreal margin);
fn C_ZN16QTextBlockFormat13setLeftMarginEd(qthis: u64 /* *mut c_void*/, arg0: c_double);
// proto: bool QTextBlockFormat::isValid();
fn C_ZNK16QTextBlockFormat7isValidEv(qthis: u64 /* *mut c_void*/) -> c_char;
// proto: bool QTextBlockFormat::nonBreakableLines();
fn C_ZNK16QTextBlockFormat17nonBreakableLinesEv(qthis: u64 /* *mut c_void*/) -> c_char;
fn QTextCharFormat_Class_Size() -> c_int;
// proto: void QTextCharFormat::setFontLetterSpacing(qreal spacing);
fn C_ZN15QTextCharFormat20setFontLetterSpacingEd(qthis: u64 /* *mut c_void*/, arg0: c_double);
// proto: bool QTextCharFormat::isAnchor();
fn C_ZNK15QTextCharFormat8isAnchorEv(qthis: u64 /* *mut c_void*/) -> c_char;
// proto: void QTextCharFormat::setFont(const QFont & font);
fn C_ZN15QTextCharFormat7setFontERK5QFont(qthis: u64 /* *mut c_void*/, arg0: *mut c_void);
// proto: bool QTextCharFormat::fontOverline();
fn C_ZNK15QTextCharFormat12fontOverlineEv(qthis: u64 /* *mut c_void*/) -> c_char;
// proto: QFont QTextCharFormat::font();
fn C_ZNK15QTextCharFormat4fontEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
// proto: QString QTextCharFormat::fontFamily();
fn C_ZNK15QTextCharFormat10fontFamilyEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
// proto: bool QTextCharFormat::fontStrikeOut();
fn C_ZNK15QTextCharFormat13fontStrikeOutEv(qthis: u64 /* *mut c_void*/) -> c_char;
// proto: void QTextCharFormat::setFontPointSize(qreal size);
fn C_ZN15QTextCharFormat16setFontPointSizeEd(qthis: u64 /* *mut c_void*/, arg0: c_double);
// proto: void QTextCharFormat::setUnderlineColor(const QColor & color);
fn C_ZN15QTextCharFormat17setUnderlineColorERK6QColor(qthis: u64 /* *mut c_void*/, arg0: *mut c_void);
// proto: int QTextCharFormat::tableCellRowSpan();
fn C_ZNK15QTextCharFormat16tableCellRowSpanEv(qthis: u64 /* *mut c_void*/) -> c_int;
// proto: void QTextCharFormat::setFontUnderline(bool underline);
fn C_ZN15QTextCharFormat16setFontUnderlineEb(qthis: u64 /* *mut c_void*/, arg0: c_char);
// proto: bool QTextCharFormat::isValid();
fn C_ZNK15QTextCharFormat7isValidEv(qthis: u64 /* *mut c_void*/) -> c_char;
// proto: bool QTextCharFormat::fontItalic();
fn C_ZNK15QTextCharFormat10fontItalicEv(qthis: u64 /* *mut c_void*/) -> c_char;
// proto: void QTextCharFormat::setToolTip(const QString & tip);
fn C_ZN15QTextCharFormat10setToolTipERK7QString(qthis: u64 /* *mut c_void*/, arg0: *mut c_void);
// proto: void QTextCharFormat::setTextOutline(const QPen & pen);
fn C_ZN15QTextCharFormat14setTextOutlineERK4QPen(qthis: u64 /* *mut c_void*/, arg0: *mut c_void);
// proto: void QTextCharFormat::setTableCellRowSpan(int tableCellRowSpan);
fn C_ZN15QTextCharFormat19setTableCellRowSpanEi(qthis: u64 /* *mut c_void*/, arg0: c_int);
// proto: void QTextCharFormat::setAnchor(bool anchor);
fn C_ZN15QTextCharFormat9setAnchorEb(qthis: u64 /* *mut c_void*/, arg0: c_char);
// proto: qreal QTextCharFormat::fontPointSize();
fn C_ZNK15QTextCharFormat13fontPointSizeEv(qthis: u64 /* *mut c_void*/) -> c_double;
// proto: void QTextCharFormat::setFontStrikeOut(bool strikeOut);
fn C_ZN15QTextCharFormat16setFontStrikeOutEb(qthis: u64 /* *mut c_void*/, arg0: c_char);
// proto: qreal QTextCharFormat::fontWordSpacing();
fn C_ZNK15QTextCharFormat15fontWordSpacingEv(qthis: u64 /* *mut c_void*/) -> c_double;
// proto: QString QTextCharFormat::toolTip();
fn C_ZNK15QTextCharFormat7toolTipEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
// proto: void QTextCharFormat::setAnchorNames(const QStringList & names);
fn C_ZN15QTextCharFormat14setAnchorNamesERK11QStringList(qthis: u64 /* *mut c_void*/, arg0: *mut c_void);
// proto: QStringList QTextCharFormat::anchorNames();
fn C_ZNK15QTextCharFormat11anchorNamesEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
// proto: void QTextCharFormat::setFontFixedPitch(bool fixedPitch);
fn C_ZN15QTextCharFormat17setFontFixedPitchEb(qthis: u64 /* *mut c_void*/, arg0: c_char);
// proto: void QTextCharFormat::setFontItalic(bool italic);
fn C_ZN15QTextCharFormat13setFontItalicEb(qthis: u64 /* *mut c_void*/, arg0: c_char);
// proto: void QTextCharFormat::setFontFamily(const QString & family);
fn C_ZN15QTextCharFormat13setFontFamilyERK7QString(qthis: u64 /* *mut c_void*/, arg0: *mut c_void);
// proto: bool QTextCharFormat::fontFixedPitch();
fn C_ZNK15QTextCharFormat14fontFixedPitchEv(qthis: u64 /* *mut c_void*/) -> c_char;
// proto: void QTextCharFormat::setAnchorHref(const QString & value);
fn C_ZN15QTextCharFormat13setAnchorHrefERK7QString(qthis: u64 /* *mut c_void*/, arg0: *mut c_void);
// proto: int QTextCharFormat::fontStretch();
fn C_ZNK15QTextCharFormat11fontStretchEv(qthis: u64 /* *mut c_void*/) -> c_int;
// proto: void QTextCharFormat::setFontKerning(bool enable);
fn C_ZN15QTextCharFormat14setFontKerningEb(qthis: u64 /* *mut c_void*/, arg0: c_char);
// proto: int QTextCharFormat::tableCellColumnSpan();
fn C_ZNK15QTextCharFormat19tableCellColumnSpanEv(qthis: u64 /* *mut c_void*/) -> c_int;
// proto: void QTextCharFormat::QTextCharFormat();
fn C_ZN15QTextCharFormatC2Ev() -> u64;
// proto: qreal QTextCharFormat::fontLetterSpacing();
fn C_ZNK15QTextCharFormat17fontLetterSpacingEv(qthis: u64 /* *mut c_void*/) -> c_double;
// proto: QString QTextCharFormat::anchorHref();
fn C_ZNK15QTextCharFormat10anchorHrefEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
// proto: QString QTextCharFormat::anchorName();
fn C_ZNK15QTextCharFormat10anchorNameEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
// proto: void QTextCharFormat::setFontStretch(int factor);
fn C_ZN15QTextCharFormat14setFontStretchEi(qthis: u64 /* *mut c_void*/, arg0: c_int);
// proto: void QTextCharFormat::setAnchorName(const QString & name);
fn C_ZN15QTextCharFormat13setAnchorNameERK7QString(qthis: u64 /* *mut c_void*/, arg0: *mut c_void);
// proto: bool QTextCharFormat::fontKerning();
fn C_ZNK15QTextCharFormat11fontKerningEv(qthis: u64 /* *mut c_void*/) -> c_char;
// proto: void QTextCharFormat::setFontWeight(int weight);
fn C_ZN15QTextCharFormat13setFontWeightEi(qthis: u64 /* *mut c_void*/, arg0: c_int);
// proto: bool QTextCharFormat::fontUnderline();
fn C_ZNK15QTextCharFormat13fontUnderlineEv(qthis: u64 /* *mut c_void*/) -> c_char;
// proto: void QTextCharFormat::setFontWordSpacing(qreal spacing);
fn C_ZN15QTextCharFormat18setFontWordSpacingEd(qthis: u64 /* *mut c_void*/, arg0: c_double);
// proto: QColor QTextCharFormat::underlineColor();
fn C_ZNK15QTextCharFormat14underlineColorEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
// proto: int QTextCharFormat::fontWeight();
fn C_ZNK15QTextCharFormat10fontWeightEv(qthis: u64 /* *mut c_void*/) -> c_int;
// proto: void QTextCharFormat::setFontOverline(bool overline);
fn C_ZN15QTextCharFormat15setFontOverlineEb(qthis: u64 /* *mut c_void*/, arg0: c_char);
// proto: void QTextCharFormat::setTableCellColumnSpan(int tableCellColumnSpan);
fn C_ZN15QTextCharFormat22setTableCellColumnSpanEi(qthis: u64 /* *mut c_void*/, arg0: c_int);
// proto: QPen QTextCharFormat::textOutline();
fn C_ZNK15QTextCharFormat11textOutlineEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
fn QTextTableFormat_Class_Size() -> c_int;
// proto: void QTextTableFormat::QTextTableFormat();
fn C_ZN16QTextTableFormatC2Ev() -> u64;
// proto: bool QTextTableFormat::isValid();
fn C_ZNK16QTextTableFormat7isValidEv(qthis: u64 /* *mut c_void*/) -> c_char;
// proto: int QTextTableFormat::headerRowCount();
fn C_ZNK16QTextTableFormat14headerRowCountEv(qthis: u64 /* *mut c_void*/) -> c_int;
// proto: int QTextTableFormat::columns();
fn C_ZNK16QTextTableFormat7columnsEv(qthis: u64 /* *mut c_void*/) -> c_int;
// proto: QVector<QTextLength> QTextTableFormat::columnWidthConstraints();
fn C_ZNK16QTextTableFormat22columnWidthConstraintsEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
// proto: void QTextTableFormat::setCellPadding(qreal padding);
fn C_ZN16QTextTableFormat14setCellPaddingEd(qthis: u64 /* *mut c_void*/, arg0: c_double);
// proto: qreal QTextTableFormat::cellPadding();
fn C_ZNK16QTextTableFormat11cellPaddingEv(qthis: u64 /* *mut c_void*/) -> c_double;
// proto: void QTextTableFormat::setCellSpacing(qreal spacing);
fn C_ZN16QTextTableFormat14setCellSpacingEd(qthis: u64 /* *mut c_void*/, arg0: c_double);
// proto: void QTextTableFormat::setColumns(int columns);
fn C_ZN16QTextTableFormat10setColumnsEi(qthis: u64 /* *mut c_void*/, arg0: c_int);
// proto: void QTextTableFormat::clearColumnWidthConstraints();
fn C_ZN16QTextTableFormat27clearColumnWidthConstraintsEv(qthis: u64 /* *mut c_void*/);
// proto: void QTextTableFormat::setHeaderRowCount(int count);
fn C_ZN16QTextTableFormat17setHeaderRowCountEi(qthis: u64 /* *mut c_void*/, arg0: c_int);
// proto: qreal QTextTableFormat::cellSpacing();
fn C_ZNK16QTextTableFormat11cellSpacingEv(qthis: u64 /* *mut c_void*/) -> c_double;
fn QTextTableCellFormat_Class_Size() -> c_int;
// proto: void QTextTableCellFormat::QTextTableCellFormat();
fn C_ZN20QTextTableCellFormatC2Ev() -> u64;
// proto: void QTextTableCellFormat::setLeftPadding(qreal padding);
fn C_ZN20QTextTableCellFormat14setLeftPaddingEd(qthis: u64 /* *mut c_void*/, arg0: c_double);
// proto: bool QTextTableCellFormat::isValid();
fn C_ZNK20QTextTableCellFormat7isValidEv(qthis: u64 /* *mut c_void*/) -> c_char;
// proto: void QTextTableCellFormat::setTopPadding(qreal padding);
fn C_ZN20QTextTableCellFormat13setTopPaddingEd(qthis: u64 /* *mut c_void*/, arg0: c_double);
// proto: qreal QTextTableCellFormat::leftPadding();
fn C_ZNK20QTextTableCellFormat11leftPaddingEv(qthis: u64 /* *mut c_void*/) -> c_double;
// proto: void QTextTableCellFormat::setPadding(qreal padding);
fn C_ZN20QTextTableCellFormat10setPaddingEd(qthis: u64 /* *mut c_void*/, arg0: c_double);
// proto: qreal QTextTableCellFormat::topPadding();
fn C_ZNK20QTextTableCellFormat10topPaddingEv(qthis: u64 /* *mut c_void*/) -> c_double;
// proto: qreal QTextTableCellFormat::rightPadding();
fn C_ZNK20QTextTableCellFormat12rightPaddingEv(qthis: u64 /* *mut c_void*/) -> c_double;
// proto: qreal QTextTableCellFormat::bottomPadding();
fn C_ZNK20QTextTableCellFormat13bottomPaddingEv(qthis: u64 /* *mut c_void*/) -> c_double;
// proto: void QTextTableCellFormat::setRightPadding(qreal padding);
fn C_ZN20QTextTableCellFormat15setRightPaddingEd(qthis: u64 /* *mut c_void*/, arg0: c_double);
// proto: void QTextTableCellFormat::setBottomPadding(qreal padding);
fn C_ZN20QTextTableCellFormat16setBottomPaddingEd(qthis: u64 /* *mut c_void*/, arg0: c_double);
fn QTextListFormat_Class_Size() -> c_int;
// proto: int QTextListFormat::indent();
fn C_ZNK15QTextListFormat6indentEv(qthis: u64 /* *mut c_void*/) -> c_int;
// proto: void QTextListFormat::setIndent(int indent);
fn C_ZN15QTextListFormat9setIndentEi(qthis: u64 /* *mut c_void*/, arg0: c_int);
// proto: QString QTextListFormat::numberSuffix();
fn C_ZNK15QTextListFormat12numberSuffixEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
// proto: void QTextListFormat::QTextListFormat();
fn C_ZN15QTextListFormatC2Ev() -> u64;
// proto: QString QTextListFormat::numberPrefix();
fn C_ZNK15QTextListFormat12numberPrefixEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
// proto: bool QTextListFormat::isValid();
fn C_ZNK15QTextListFormat7isValidEv(qthis: u64 /* *mut c_void*/) -> c_char;
// proto: void QTextListFormat::setNumberSuffix(const QString & numberSuffix);
fn C_ZN15QTextListFormat15setNumberSuffixERK7QString(qthis: u64 /* *mut c_void*/, arg0: *mut c_void);
// proto: void QTextListFormat::setNumberPrefix(const QString & numberPrefix);
fn C_ZN15QTextListFormat15setNumberPrefixERK7QString(qthis: u64 /* *mut c_void*/, arg0: *mut c_void);
fn QTextFrameFormat_Class_Size() -> c_int;
// proto: bool QTextFrameFormat::isValid();
fn C_ZNK16QTextFrameFormat7isValidEv(qthis: u64 /* *mut c_void*/) -> c_char;
// proto: void QTextFrameFormat::setHeight(qreal height);
fn C_ZN16QTextFrameFormat9setHeightEd(qthis: u64 /* *mut c_void*/, arg0: c_double);
// proto: void QTextFrameFormat::setBorderBrush(const QBrush & brush);
fn C_ZN16QTextFrameFormat14setBorderBrushERK6QBrush(qthis: u64 /* *mut c_void*/, arg0: *mut c_void);
// proto: qreal QTextFrameFormat::margin();
fn C_ZNK16QTextFrameFormat6marginEv(qthis: u64 /* *mut c_void*/) -> c_double;
// proto: QBrush QTextFrameFormat::borderBrush();
fn C_ZNK16QTextFrameFormat11borderBrushEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
// proto: void QTextFrameFormat::setRightMargin(qreal margin);
fn C_ZN16QTextFrameFormat14setRightMarginEd(qthis: u64 /* *mut c_void*/, arg0: c_double);
// proto: void QTextFrameFormat::setMargin(qreal margin);
fn C_ZN16QTextFrameFormat9setMarginEd(qthis: u64 /* *mut c_void*/, arg0: c_double);
// proto: void QTextFrameFormat::setBorder(qreal border);
fn C_ZN16QTextFrameFormat9setBorderEd(qthis: u64 /* *mut c_void*/, arg0: c_double);
// proto: void QTextFrameFormat::setHeight(const QTextLength & height);
fn C_ZN16QTextFrameFormat9setHeightERK11QTextLength(qthis: u64 /* *mut c_void*/, arg0: *mut c_void);
// proto: void QTextFrameFormat::setWidth(const QTextLength & length);
fn C_ZN16QTextFrameFormat8setWidthERK11QTextLength(qthis: u64 /* *mut c_void*/, arg0: *mut c_void);
// proto: qreal QTextFrameFormat::bottomMargin();
fn C_ZNK16QTextFrameFormat12bottomMarginEv(qthis: u64 /* *mut c_void*/) -> c_double;
// proto: void QTextFrameFormat::setBottomMargin(qreal margin);
fn C_ZN16QTextFrameFormat15setBottomMarginEd(qthis: u64 /* *mut c_void*/, arg0: c_double);
// proto: QTextLength QTextFrameFormat::height();
fn C_ZNK16QTextFrameFormat6heightEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
// proto: void QTextFrameFormat::setWidth(qreal width);
fn C_ZN16QTextFrameFormat8setWidthEd(qthis: u64 /* *mut c_void*/, arg0: c_double);
// proto: qreal QTextFrameFormat::rightMargin();
fn C_ZNK16QTextFrameFormat11rightMarginEv(qthis: u64 /* *mut c_void*/) -> c_double;
// proto: void QTextFrameFormat::setPadding(qreal padding);
fn C_ZN16QTextFrameFormat10setPaddingEd(qthis: u64 /* *mut c_void*/, arg0: c_double);
// proto: void QTextFrameFormat::setTopMargin(qreal margin);
fn C_ZN16QTextFrameFormat12setTopMarginEd(qthis: u64 /* *mut c_void*/, arg0: c_double);
// proto: qreal QTextFrameFormat::topMargin();
fn C_ZNK16QTextFrameFormat9topMarginEv(qthis: u64 /* *mut c_void*/) -> c_double;
// proto: QTextLength QTextFrameFormat::width();
fn C_ZNK16QTextFrameFormat5widthEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
// proto: qreal QTextFrameFormat::padding();
fn C_ZNK16QTextFrameFormat7paddingEv(qthis: u64 /* *mut c_void*/) -> c_double;
// proto: void QTextFrameFormat::setLeftMargin(qreal margin);
fn C_ZN16QTextFrameFormat13setLeftMarginEd(qthis: u64 /* *mut c_void*/, arg0: c_double);
// proto: qreal QTextFrameFormat::border();
fn C_ZNK16QTextFrameFormat6borderEv(qthis: u64 /* *mut c_void*/) -> c_double;
// proto: void QTextFrameFormat::QTextFrameFormat();
fn C_ZN16QTextFrameFormatC2Ev() -> u64;
// proto: qreal QTextFrameFormat::leftMargin();
fn C_ZNK16QTextFrameFormat10leftMarginEv(qthis: u64 /* *mut c_void*/) -> c_double;
} // <= ext block end
// body block begin =>
// class sizeof(QTextLength)=16
#[derive(Default)]
pub struct QTextLength {
// qbase: None,
pub qclsinst: u64 /* *mut c_void*/,
}
// class sizeof(QTextImageFormat)=1
#[derive(Default)]
pub struct QTextImageFormat {
qbase: QTextCharFormat,
pub qclsinst: u64 /* *mut c_void*/,
}
// class sizeof(QTextFormat)=1
#[derive(Default)]
pub struct QTextFormat {
// qbase: None,
pub qclsinst: u64 /* *mut c_void*/,
}
// class sizeof(QTextBlockFormat)=1
#[derive(Default)]
pub struct QTextBlockFormat {
qbase: QTextFormat,
pub qclsinst: u64 /* *mut c_void*/,
}
// class sizeof(QTextCharFormat)=1
#[derive(Default)]
pub struct QTextCharFormat {
qbase: QTextFormat,
pub qclsinst: u64 /* *mut c_void*/,
}
// class sizeof(QTextTableFormat)=1
#[derive(Default)]
pub struct QTextTableFormat {
qbase: QTextFrameFormat,
pub qclsinst: u64 /* *mut c_void*/,
}
// class sizeof(QTextTableCellFormat)=1
#[derive(Default)]
pub struct QTextTableCellFormat {
qbase: QTextCharFormat,
pub qclsinst: u64 /* *mut c_void*/,
}
// class sizeof(QTextListFormat)=1
#[derive(Default)]
pub struct QTextListFormat {
qbase: QTextFormat,
pub qclsinst: u64 /* *mut c_void*/,
}
// class sizeof(QTextFrameFormat)=1
#[derive(Default)]
pub struct QTextFrameFormat {
qbase: QTextFormat,
pub qclsinst: u64 /* *mut c_void*/,
}
impl /*struct*/ QTextLength {
pub fn inheritFrom(qthis: u64 /* *mut c_void*/) -> QTextLength {
return QTextLength{qclsinst: qthis, ..Default::default()};
}
}
// proto: qreal QTextLength::value(qreal maximumLength);
impl /*struct*/ QTextLength {
pub fn value<RetType, T: QTextLength_value<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.value(self);
// return 1;
}
}
pub trait QTextLength_value<RetType> {
fn value(self , rsthis: & QTextLength) -> RetType;
}
// proto: qreal QTextLength::value(qreal maximumLength);
impl<'a> /*trait*/ QTextLength_value<f64> for (f64) {
fn value(self , rsthis: & QTextLength) -> f64 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK11QTextLength5valueEd()};
let arg0 = self as c_double;
let mut ret = unsafe {C_ZNK11QTextLength5valueEd(rsthis.qclsinst, arg0)};
return ret as f64; // 1
// return 1;
}
}
// proto: void QTextLength::QTextLength();
impl /*struct*/ QTextLength {
pub fn new<T: QTextLength_new>(value: T) -> QTextLength {
let rsthis = value.new();
return rsthis;
// return 1;
}
}
pub trait QTextLength_new {
fn new(self) -> QTextLength;
}
// proto: void QTextLength::QTextLength();
impl<'a> /*trait*/ QTextLength_new for () {
fn new(self) -> QTextLength {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN11QTextLengthC2Ev()};
let ctysz: c_int = unsafe{QTextLength_Class_Size()};
let qthis_ph: u64 = unsafe{calloc(1, ctysz as usize)} as u64;
let qthis: u64 = unsafe {C_ZN11QTextLengthC2Ev()};
let rsthis = QTextLength{qclsinst: qthis, ..Default::default()};
return rsthis;
// return 1;
}
}
// proto: qreal QTextLength::rawValue();
impl /*struct*/ QTextLength {
pub fn rawValue<RetType, T: QTextLength_rawValue<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.rawValue(self);
// return 1;
}
}
pub trait QTextLength_rawValue<RetType> {
fn rawValue(self , rsthis: & QTextLength) -> RetType;
}
// proto: qreal QTextLength::rawValue();
impl<'a> /*trait*/ QTextLength_rawValue<f64> for () {
fn rawValue(self , rsthis: & QTextLength) -> f64 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK11QTextLength8rawValueEv()};
let mut ret = unsafe {C_ZNK11QTextLength8rawValueEv(rsthis.qclsinst)};
return ret as f64; // 1
// return 1;
}
}
impl /*struct*/ QTextImageFormat {
pub fn inheritFrom(qthis: u64 /* *mut c_void*/) -> QTextImageFormat {
return QTextImageFormat{qbase: QTextCharFormat::inheritFrom(qthis), qclsinst: qthis, ..Default::default()};
}
}
impl Deref for QTextImageFormat {
type Target = QTextCharFormat;
fn deref(&self) -> &QTextCharFormat {
return & self.qbase;
}
}
impl AsRef<QTextCharFormat> for QTextImageFormat {
fn as_ref(& self) -> & QTextCharFormat {
return & self.qbase;
}
}
// proto: void QTextImageFormat::QTextImageFormat();
impl /*struct*/ QTextImageFormat {
pub fn new<T: QTextImageFormat_new>(value: T) -> QTextImageFormat {
let rsthis = value.new();
return rsthis;
// return 1;
}
}
pub trait QTextImageFormat_new {
fn new(self) -> QTextImageFormat;
}
// proto: void QTextImageFormat::QTextImageFormat();
impl<'a> /*trait*/ QTextImageFormat_new for () {
fn new(self) -> QTextImageFormat {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN16QTextImageFormatC2Ev()};
let ctysz: c_int = unsafe{QTextImageFormat_Class_Size()};
let qthis_ph: u64 = unsafe{calloc(1, ctysz as usize)} as u64;
let qthis: u64 = unsafe {C_ZN16QTextImageFormatC2Ev()};
let rsthis = QTextImageFormat{qbase: QTextCharFormat::inheritFrom(qthis), qclsinst: qthis, ..Default::default()};
return rsthis;
// return 1;
}
}
// proto: bool QTextImageFormat::isValid();
impl /*struct*/ QTextImageFormat {
pub fn isValid<RetType, T: QTextImageFormat_isValid<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.isValid(self);
// return 1;
}
}
pub trait QTextImageFormat_isValid<RetType> {
fn isValid(self , rsthis: & QTextImageFormat) -> RetType;
}
// proto: bool QTextImageFormat::isValid();
impl<'a> /*trait*/ QTextImageFormat_isValid<i8> for () {
fn isValid(self , rsthis: & QTextImageFormat) -> i8 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK16QTextImageFormat7isValidEv()};
let mut ret = unsafe {C_ZNK16QTextImageFormat7isValidEv(rsthis.qclsinst)};
return ret as i8; // 1
// return 1;
}
}
// proto: qreal QTextImageFormat::width();
impl /*struct*/ QTextImageFormat {
pub fn width<RetType, T: QTextImageFormat_width<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.width(self);
// return 1;
}
}
pub trait QTextImageFormat_width<RetType> {
fn width(self , rsthis: & QTextImageFormat) -> RetType;
}
// proto: qreal QTextImageFormat::width();
impl<'a> /*trait*/ QTextImageFormat_width<f64> for () {
fn width(self , rsthis: & QTextImageFormat) -> f64 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK16QTextImageFormat5widthEv()};
let mut ret = unsafe {C_ZNK16QTextImageFormat5widthEv(rsthis.qclsinst)};
return ret as f64; // 1
// return 1;
}
}
// proto: void QTextImageFormat::setHeight(qreal height);
impl /*struct*/ QTextImageFormat {
pub fn setHeight<RetType, T: QTextImageFormat_setHeight<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setHeight(self);
// return 1;
}
}
pub trait QTextImageFormat_setHeight<RetType> {
fn setHeight(self , rsthis: & QTextImageFormat) -> RetType;
}
// proto: void QTextImageFormat::setHeight(qreal height);
impl<'a> /*trait*/ QTextImageFormat_setHeight<()> for (f64) {
fn setHeight(self , rsthis: & QTextImageFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN16QTextImageFormat9setHeightEd()};
let arg0 = self as c_double;
unsafe {C_ZN16QTextImageFormat9setHeightEd(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: void QTextImageFormat::setWidth(qreal width);
impl /*struct*/ QTextImageFormat {
pub fn setWidth<RetType, T: QTextImageFormat_setWidth<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setWidth(self);
// return 1;
}
}
pub trait QTextImageFormat_setWidth<RetType> {
fn setWidth(self , rsthis: & QTextImageFormat) -> RetType;
}
// proto: void QTextImageFormat::setWidth(qreal width);
impl<'a> /*trait*/ QTextImageFormat_setWidth<()> for (f64) {
fn setWidth(self , rsthis: & QTextImageFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN16QTextImageFormat8setWidthEd()};
let arg0 = self as c_double;
unsafe {C_ZN16QTextImageFormat8setWidthEd(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: void QTextImageFormat::setName(const QString & name);
impl /*struct*/ QTextImageFormat {
pub fn setName<RetType, T: QTextImageFormat_setName<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setName(self);
// return 1;
}
}
pub trait QTextImageFormat_setName<RetType> {
fn setName(self , rsthis: & QTextImageFormat) -> RetType;
}
// proto: void QTextImageFormat::setName(const QString & name);
impl<'a> /*trait*/ QTextImageFormat_setName<()> for (&'a QString) {
fn setName(self , rsthis: & QTextImageFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN16QTextImageFormat7setNameERK7QString()};
let arg0 = self.qclsinst as *mut c_void;
unsafe {C_ZN16QTextImageFormat7setNameERK7QString(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: QString QTextImageFormat::name();
impl /*struct*/ QTextImageFormat {
pub fn name<RetType, T: QTextImageFormat_name<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.name(self);
// return 1;
}
}
pub trait QTextImageFormat_name<RetType> {
fn name(self , rsthis: & QTextImageFormat) -> RetType;
}
// proto: QString QTextImageFormat::name();
impl<'a> /*trait*/ QTextImageFormat_name<QString> for () {
fn name(self , rsthis: & QTextImageFormat) -> QString {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK16QTextImageFormat4nameEv()};
let mut ret = unsafe {C_ZNK16QTextImageFormat4nameEv(rsthis.qclsinst)};
let mut ret1 = QString::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: qreal QTextImageFormat::height();
impl /*struct*/ QTextImageFormat {
pub fn height<RetType, T: QTextImageFormat_height<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.height(self);
// return 1;
}
}
pub trait QTextImageFormat_height<RetType> {
fn height(self , rsthis: & QTextImageFormat) -> RetType;
}
// proto: qreal QTextImageFormat::height();
impl<'a> /*trait*/ QTextImageFormat_height<f64> for () {
fn height(self , rsthis: & QTextImageFormat) -> f64 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK16QTextImageFormat6heightEv()};
let mut ret = unsafe {C_ZNK16QTextImageFormat6heightEv(rsthis.qclsinst)};
return ret as f64; // 1
// return 1;
}
}
impl /*struct*/ QTextFormat {
pub fn inheritFrom(qthis: u64 /* *mut c_void*/) -> QTextFormat {
return QTextFormat{qclsinst: qthis, ..Default::default()};
}
}
// proto: QTextBlockFormat QTextFormat::toBlockFormat();
impl /*struct*/ QTextFormat {
pub fn toBlockFormat<RetType, T: QTextFormat_toBlockFormat<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.toBlockFormat(self);
// return 1;
}
}
pub trait QTextFormat_toBlockFormat<RetType> {
fn toBlockFormat(self , rsthis: & QTextFormat) -> RetType;
}
// proto: QTextBlockFormat QTextFormat::toBlockFormat();
impl<'a> /*trait*/ QTextFormat_toBlockFormat<QTextBlockFormat> for () {
fn toBlockFormat(self , rsthis: & QTextFormat) -> QTextBlockFormat {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK11QTextFormat13toBlockFormatEv()};
let mut ret = unsafe {C_ZNK11QTextFormat13toBlockFormatEv(rsthis.qclsinst)};
let mut ret1 = QTextBlockFormat::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: QString QTextFormat::stringProperty(int propertyId);
impl /*struct*/ QTextFormat {
pub fn stringProperty<RetType, T: QTextFormat_stringProperty<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.stringProperty(self);
// return 1;
}
}
pub trait QTextFormat_stringProperty<RetType> {
fn stringProperty(self , rsthis: & QTextFormat) -> RetType;
}
// proto: QString QTextFormat::stringProperty(int propertyId);
impl<'a> /*trait*/ QTextFormat_stringProperty<QString> for (i32) {
fn stringProperty(self , rsthis: & QTextFormat) -> QString {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK11QTextFormat14stringPropertyEi()};
let arg0 = self as c_int;
let mut ret = unsafe {C_ZNK11QTextFormat14stringPropertyEi(rsthis.qclsinst, arg0)};
let mut ret1 = QString::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: QVector<QTextLength> QTextFormat::lengthVectorProperty(int propertyId);
impl /*struct*/ QTextFormat {
pub fn lengthVectorProperty<RetType, T: QTextFormat_lengthVectorProperty<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.lengthVectorProperty(self);
// return 1;
}
}
pub trait QTextFormat_lengthVectorProperty<RetType> {
fn lengthVectorProperty(self , rsthis: & QTextFormat) -> RetType;
}
// proto: QVector<QTextLength> QTextFormat::lengthVectorProperty(int propertyId);
impl<'a> /*trait*/ QTextFormat_lengthVectorProperty<u64> for (i32) {
fn lengthVectorProperty(self , rsthis: & QTextFormat) -> u64 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK11QTextFormat20lengthVectorPropertyEi()};
let arg0 = self as c_int;
let mut ret = unsafe {C_ZNK11QTextFormat20lengthVectorPropertyEi(rsthis.qclsinst, arg0)};
return ret as u64; // 5
// return 1;
}
}
// proto: int QTextFormat::objectIndex();
impl /*struct*/ QTextFormat {
pub fn objectIndex<RetType, T: QTextFormat_objectIndex<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.objectIndex(self);
// return 1;
}
}
pub trait QTextFormat_objectIndex<RetType> {
fn objectIndex(self , rsthis: & QTextFormat) -> RetType;
}
// proto: int QTextFormat::objectIndex();
impl<'a> /*trait*/ QTextFormat_objectIndex<i32> for () {
fn objectIndex(self , rsthis: & QTextFormat) -> i32 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK11QTextFormat11objectIndexEv()};
let mut ret = unsafe {C_ZNK11QTextFormat11objectIndexEv(rsthis.qclsinst)};
return ret as i32; // 1
// return 1;
}
}
// proto: void QTextFormat::setObjectIndex(int object);
impl /*struct*/ QTextFormat {
pub fn setObjectIndex<RetType, T: QTextFormat_setObjectIndex<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setObjectIndex(self);
// return 1;
}
}
pub trait QTextFormat_setObjectIndex<RetType> {
fn setObjectIndex(self , rsthis: & QTextFormat) -> RetType;
}
// proto: void QTextFormat::setObjectIndex(int object);
impl<'a> /*trait*/ QTextFormat_setObjectIndex<()> for (i32) {
fn setObjectIndex(self , rsthis: & QTextFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN11QTextFormat14setObjectIndexEi()};
let arg0 = self as c_int;
unsafe {C_ZN11QTextFormat14setObjectIndexEi(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: void QTextFormat::clearForeground();
impl /*struct*/ QTextFormat {
pub fn clearForeground<RetType, T: QTextFormat_clearForeground<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.clearForeground(self);
// return 1;
}
}
pub trait QTextFormat_clearForeground<RetType> {
fn clearForeground(self , rsthis: & QTextFormat) -> RetType;
}
// proto: void QTextFormat::clearForeground();
impl<'a> /*trait*/ QTextFormat_clearForeground<()> for () {
fn clearForeground(self , rsthis: & QTextFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN11QTextFormat15clearForegroundEv()};
unsafe {C_ZN11QTextFormat15clearForegroundEv(rsthis.qclsinst)};
// return 1;
}
}
// proto: bool QTextFormat::isTableCellFormat();
impl /*struct*/ QTextFormat {
pub fn isTableCellFormat<RetType, T: QTextFormat_isTableCellFormat<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.isTableCellFormat(self);
// return 1;
}
}
pub trait QTextFormat_isTableCellFormat<RetType> {
fn isTableCellFormat(self , rsthis: & QTextFormat) -> RetType;
}
// proto: bool QTextFormat::isTableCellFormat();
impl<'a> /*trait*/ QTextFormat_isTableCellFormat<i8> for () {
fn isTableCellFormat(self , rsthis: & QTextFormat) -> i8 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK11QTextFormat17isTableCellFormatEv()};
let mut ret = unsafe {C_ZNK11QTextFormat17isTableCellFormatEv(rsthis.qclsinst)};
return ret as i8; // 1
// return 1;
}
}
// proto: void QTextFormat::~QTextFormat();
impl /*struct*/ QTextFormat {
pub fn free<RetType, T: QTextFormat_free<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.free(self);
// return 1;
}
}
pub trait QTextFormat_free<RetType> {
fn free(self , rsthis: & QTextFormat) -> RetType;
}
// proto: void QTextFormat::~QTextFormat();
impl<'a> /*trait*/ QTextFormat_free<()> for () {
fn free(self , rsthis: & QTextFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN11QTextFormatD2Ev()};
unsafe {C_ZN11QTextFormatD2Ev(rsthis.qclsinst)};
// return 1;
}
}
// proto: bool QTextFormat::isValid();
impl /*struct*/ QTextFormat {
pub fn isValid<RetType, T: QTextFormat_isValid<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.isValid(self);
// return 1;
}
}
pub trait QTextFormat_isValid<RetType> {
fn isValid(self , rsthis: & QTextFormat) -> RetType;
}
// proto: bool QTextFormat::isValid();
impl<'a> /*trait*/ QTextFormat_isValid<i8> for () {
fn isValid(self , rsthis: & QTextFormat) -> i8 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK11QTextFormat7isValidEv()};
let mut ret = unsafe {C_ZNK11QTextFormat7isValidEv(rsthis.qclsinst)};
return ret as i8; // 1
// return 1;
}
}
// proto: void QTextFormat::QTextFormat(const QTextFormat & rhs);
impl /*struct*/ QTextFormat {
pub fn new<T: QTextFormat_new>(value: T) -> QTextFormat {
let rsthis = value.new();
return rsthis;
// return 1;
}
}
pub trait QTextFormat_new {
fn new(self) -> QTextFormat;
}
// proto: void QTextFormat::QTextFormat(const QTextFormat & rhs);
impl<'a> /*trait*/ QTextFormat_new for (&'a QTextFormat) {
fn new(self) -> QTextFormat {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN11QTextFormatC2ERKS_()};
let ctysz: c_int = unsafe{QTextFormat_Class_Size()};
let qthis_ph: u64 = unsafe{calloc(1, ctysz as usize)} as u64;
let arg0 = self.qclsinst as *mut c_void;
let qthis: u64 = unsafe {C_ZN11QTextFormatC2ERKS_(arg0)};
let rsthis = QTextFormat{qclsinst: qthis, ..Default::default()};
return rsthis;
// return 1;
}
}
// proto: QTextLength QTextFormat::lengthProperty(int propertyId);
impl /*struct*/ QTextFormat {
pub fn lengthProperty<RetType, T: QTextFormat_lengthProperty<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.lengthProperty(self);
// return 1;
}
}
pub trait QTextFormat_lengthProperty<RetType> {
fn lengthProperty(self , rsthis: & QTextFormat) -> RetType;
}
// proto: QTextLength QTextFormat::lengthProperty(int propertyId);
impl<'a> /*trait*/ QTextFormat_lengthProperty<QTextLength> for (i32) {
fn lengthProperty(self , rsthis: & QTextFormat) -> QTextLength {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK11QTextFormat14lengthPropertyEi()};
let arg0 = self as c_int;
let mut ret = unsafe {C_ZNK11QTextFormat14lengthPropertyEi(rsthis.qclsinst, arg0)};
let mut ret1 = QTextLength::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: void QTextFormat::merge(const QTextFormat & other);
impl /*struct*/ QTextFormat {
pub fn merge<RetType, T: QTextFormat_merge<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.merge(self);
// return 1;
}
}
pub trait QTextFormat_merge<RetType> {
fn merge(self , rsthis: & QTextFormat) -> RetType;
}
// proto: void QTextFormat::merge(const QTextFormat & other);
impl<'a> /*trait*/ QTextFormat_merge<()> for (&'a QTextFormat) {
fn merge(self , rsthis: & QTextFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN11QTextFormat5mergeERKS_()};
let arg0 = self.qclsinst as *mut c_void;
unsafe {C_ZN11QTextFormat5mergeERKS_(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: QColor QTextFormat::colorProperty(int propertyId);
impl /*struct*/ QTextFormat {
pub fn colorProperty<RetType, T: QTextFormat_colorProperty<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.colorProperty(self);
// return 1;
}
}
pub trait QTextFormat_colorProperty<RetType> {
fn colorProperty(self , rsthis: & QTextFormat) -> RetType;
}
// proto: QColor QTextFormat::colorProperty(int propertyId);
impl<'a> /*trait*/ QTextFormat_colorProperty<QColor> for (i32) {
fn colorProperty(self , rsthis: & QTextFormat) -> QColor {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK11QTextFormat13colorPropertyEi()};
let arg0 = self as c_int;
let mut ret = unsafe {C_ZNK11QTextFormat13colorPropertyEi(rsthis.qclsinst, arg0)};
let mut ret1 = QColor::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: void QTextFormat::QTextFormat();
impl<'a> /*trait*/ QTextFormat_new for () {
fn new(self) -> QTextFormat {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN11QTextFormatC2Ev()};
let ctysz: c_int = unsafe{QTextFormat_Class_Size()};
let qthis_ph: u64 = unsafe{calloc(1, ctysz as usize)} as u64;
let qthis: u64 = unsafe {C_ZN11QTextFormatC2Ev()};
let rsthis = QTextFormat{qclsinst: qthis, ..Default::default()};
return rsthis;
// return 1;
}
}
// proto: void QTextFormat::setForeground(const QBrush & brush);
impl /*struct*/ QTextFormat {
pub fn setForeground<RetType, T: QTextFormat_setForeground<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setForeground(self);
// return 1;
}
}
pub trait QTextFormat_setForeground<RetType> {
fn setForeground(self , rsthis: & QTextFormat) -> RetType;
}
// proto: void QTextFormat::setForeground(const QBrush & brush);
impl<'a> /*trait*/ QTextFormat_setForeground<()> for (&'a QBrush) {
fn setForeground(self , rsthis: & QTextFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN11QTextFormat13setForegroundERK6QBrush()};
let arg0 = self.qclsinst as *mut c_void;
unsafe {C_ZN11QTextFormat13setForegroundERK6QBrush(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: bool QTextFormat::boolProperty(int propertyId);
impl /*struct*/ QTextFormat {
pub fn boolProperty<RetType, T: QTextFormat_boolProperty<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.boolProperty(self);
// return 1;
}
}
pub trait QTextFormat_boolProperty<RetType> {
fn boolProperty(self , rsthis: & QTextFormat) -> RetType;
}
// proto: bool QTextFormat::boolProperty(int propertyId);
impl<'a> /*trait*/ QTextFormat_boolProperty<i8> for (i32) {
fn boolProperty(self , rsthis: & QTextFormat) -> i8 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK11QTextFormat12boolPropertyEi()};
let arg0 = self as c_int;
let mut ret = unsafe {C_ZNK11QTextFormat12boolPropertyEi(rsthis.qclsinst, arg0)};
return ret as i8; // 1
// return 1;
}
}
// proto: bool QTextFormat::isListFormat();
impl /*struct*/ QTextFormat {
pub fn isListFormat<RetType, T: QTextFormat_isListFormat<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.isListFormat(self);
// return 1;
}
}
pub trait QTextFormat_isListFormat<RetType> {
fn isListFormat(self , rsthis: & QTextFormat) -> RetType;
}
// proto: bool QTextFormat::isListFormat();
impl<'a> /*trait*/ QTextFormat_isListFormat<i8> for () {
fn isListFormat(self , rsthis: & QTextFormat) -> i8 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK11QTextFormat12isListFormatEv()};
let mut ret = unsafe {C_ZNK11QTextFormat12isListFormatEv(rsthis.qclsinst)};
return ret as i8; // 1
// return 1;
}
}
// proto: void QTextFormat::QTextFormat(int type);
impl<'a> /*trait*/ QTextFormat_new for (i32) {
fn new(self) -> QTextFormat {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN11QTextFormatC2Ei()};
let ctysz: c_int = unsafe{QTextFormat_Class_Size()};
let qthis_ph: u64 = unsafe{calloc(1, ctysz as usize)} as u64;
let arg0 = self as c_int;
let qthis: u64 = unsafe {C_ZN11QTextFormatC2Ei(arg0)};
let rsthis = QTextFormat{qclsinst: qthis, ..Default::default()};
return rsthis;
// return 1;
}
}
// proto: bool QTextFormat::isImageFormat();
impl /*struct*/ QTextFormat {
pub fn isImageFormat<RetType, T: QTextFormat_isImageFormat<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.isImageFormat(self);
// return 1;
}
}
pub trait QTextFormat_isImageFormat<RetType> {
fn isImageFormat(self , rsthis: & QTextFormat) -> RetType;
}
// proto: bool QTextFormat::isImageFormat();
impl<'a> /*trait*/ QTextFormat_isImageFormat<i8> for () {
fn isImageFormat(self , rsthis: & QTextFormat) -> i8 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK11QTextFormat13isImageFormatEv()};
let mut ret = unsafe {C_ZNK11QTextFormat13isImageFormatEv(rsthis.qclsinst)};
return ret as i8; // 1
// return 1;
}
}
// proto: void QTextFormat::clearProperty(int propertyId);
impl /*struct*/ QTextFormat {
pub fn clearProperty<RetType, T: QTextFormat_clearProperty<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.clearProperty(self);
// return 1;
}
}
pub trait QTextFormat_clearProperty<RetType> {
fn clearProperty(self , rsthis: & QTextFormat) -> RetType;
}
// proto: void QTextFormat::clearProperty(int propertyId);
impl<'a> /*trait*/ QTextFormat_clearProperty<()> for (i32) {
fn clearProperty(self , rsthis: & QTextFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN11QTextFormat13clearPropertyEi()};
let arg0 = self as c_int;
unsafe {C_ZN11QTextFormat13clearPropertyEi(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: QTextFrameFormat QTextFormat::toFrameFormat();
impl /*struct*/ QTextFormat {
pub fn toFrameFormat<RetType, T: QTextFormat_toFrameFormat<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.toFrameFormat(self);
// return 1;
}
}
pub trait QTextFormat_toFrameFormat<RetType> {
fn toFrameFormat(self , rsthis: & QTextFormat) -> RetType;
}
// proto: QTextFrameFormat QTextFormat::toFrameFormat();
impl<'a> /*trait*/ QTextFormat_toFrameFormat<QTextFrameFormat> for () {
fn toFrameFormat(self , rsthis: & QTextFormat) -> QTextFrameFormat {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK11QTextFormat13toFrameFormatEv()};
let mut ret = unsafe {C_ZNK11QTextFormat13toFrameFormatEv(rsthis.qclsinst)};
let mut ret1 = QTextFrameFormat::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: QBrush QTextFormat::brushProperty(int propertyId);
impl /*struct*/ QTextFormat {
pub fn brushProperty<RetType, T: QTextFormat_brushProperty<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.brushProperty(self);
// return 1;
}
}
pub trait QTextFormat_brushProperty<RetType> {
fn brushProperty(self , rsthis: & QTextFormat) -> RetType;
}
// proto: QBrush QTextFormat::brushProperty(int propertyId);
impl<'a> /*trait*/ QTextFormat_brushProperty<QBrush> for (i32) {
fn brushProperty(self , rsthis: & QTextFormat) -> QBrush {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK11QTextFormat13brushPropertyEi()};
let arg0 = self as c_int;
let mut ret = unsafe {C_ZNK11QTextFormat13brushPropertyEi(rsthis.qclsinst, arg0)};
let mut ret1 = QBrush::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: int QTextFormat::propertyCount();
impl /*struct*/ QTextFormat {
pub fn propertyCount<RetType, T: QTextFormat_propertyCount<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.propertyCount(self);
// return 1;
}
}
pub trait QTextFormat_propertyCount<RetType> {
fn propertyCount(self , rsthis: & QTextFormat) -> RetType;
}
// proto: int QTextFormat::propertyCount();
impl<'a> /*trait*/ QTextFormat_propertyCount<i32> for () {
fn propertyCount(self , rsthis: & QTextFormat) -> i32 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK11QTextFormat13propertyCountEv()};
let mut ret = unsafe {C_ZNK11QTextFormat13propertyCountEv(rsthis.qclsinst)};
return ret as i32; // 1
// return 1;
}
}
// proto: QPen QTextFormat::penProperty(int propertyId);
impl /*struct*/ QTextFormat {
pub fn penProperty<RetType, T: QTextFormat_penProperty<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.penProperty(self);
// return 1;
}
}
pub trait QTextFormat_penProperty<RetType> {
fn penProperty(self , rsthis: & QTextFormat) -> RetType;
}
// proto: QPen QTextFormat::penProperty(int propertyId);
impl<'a> /*trait*/ QTextFormat_penProperty<QPen> for (i32) {
fn penProperty(self , rsthis: & QTextFormat) -> QPen {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK11QTextFormat11penPropertyEi()};
let arg0 = self as c_int;
let mut ret = unsafe {C_ZNK11QTextFormat11penPropertyEi(rsthis.qclsinst, arg0)};
let mut ret1 = QPen::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: QVariant QTextFormat::property(int propertyId);
impl /*struct*/ QTextFormat {
pub fn property<RetType, T: QTextFormat_property<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.property(self);
// return 1;
}
}
pub trait QTextFormat_property<RetType> {
fn property(self , rsthis: & QTextFormat) -> RetType;
}
// proto: QVariant QTextFormat::property(int propertyId);
impl<'a> /*trait*/ QTextFormat_property<QVariant> for (i32) {
fn property(self , rsthis: & QTextFormat) -> QVariant {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK11QTextFormat8propertyEi()};
let arg0 = self as c_int;
let mut ret = unsafe {C_ZNK11QTextFormat8propertyEi(rsthis.qclsinst, arg0)};
let mut ret1 = QVariant::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: bool QTextFormat::isTableFormat();
impl /*struct*/ QTextFormat {
pub fn isTableFormat<RetType, T: QTextFormat_isTableFormat<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.isTableFormat(self);
// return 1;
}
}
pub trait QTextFormat_isTableFormat<RetType> {
fn isTableFormat(self , rsthis: & QTextFormat) -> RetType;
}
// proto: bool QTextFormat::isTableFormat();
impl<'a> /*trait*/ QTextFormat_isTableFormat<i8> for () {
fn isTableFormat(self , rsthis: & QTextFormat) -> i8 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK11QTextFormat13isTableFormatEv()};
let mut ret = unsafe {C_ZNK11QTextFormat13isTableFormatEv(rsthis.qclsinst)};
return ret as i8; // 1
// return 1;
}
}
// proto: void QTextFormat::setProperty(int propertyId, const QVariant & value);
impl /*struct*/ QTextFormat {
pub fn setProperty<RetType, T: QTextFormat_setProperty<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setProperty(self);
// return 1;
}
}
pub trait QTextFormat_setProperty<RetType> {
fn setProperty(self , rsthis: & QTextFormat) -> RetType;
}
// proto: void QTextFormat::setProperty(int propertyId, const QVariant & value);
impl<'a> /*trait*/ QTextFormat_setProperty<()> for (i32, &'a QVariant) {
fn setProperty(self , rsthis: & QTextFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN11QTextFormat11setPropertyEiRK8QVariant()};
let arg0 = self.0 as c_int;
let arg1 = self.1.qclsinst as *mut c_void;
unsafe {C_ZN11QTextFormat11setPropertyEiRK8QVariant(rsthis.qclsinst, arg0, arg1)};
// return 1;
}
}
// proto: int QTextFormat::type();
impl /*struct*/ QTextFormat {
pub fn type_<RetType, T: QTextFormat_type_<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.type_(self);
// return 1;
}
}
pub trait QTextFormat_type_<RetType> {
fn type_(self , rsthis: & QTextFormat) -> RetType;
}
// proto: int QTextFormat::type();
impl<'a> /*trait*/ QTextFormat_type_<i32> for () {
fn type_(self , rsthis: & QTextFormat) -> i32 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK11QTextFormat4typeEv()};
let mut ret = unsafe {C_ZNK11QTextFormat4typeEv(rsthis.qclsinst)};
return ret as i32; // 1
// return 1;
}
}
// proto: bool QTextFormat::isCharFormat();
impl /*struct*/ QTextFormat {
pub fn isCharFormat<RetType, T: QTextFormat_isCharFormat<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.isCharFormat(self);
// return 1;
}
}
pub trait QTextFormat_isCharFormat<RetType> {
fn isCharFormat(self , rsthis: & QTextFormat) -> RetType;
}
// proto: bool QTextFormat::isCharFormat();
impl<'a> /*trait*/ QTextFormat_isCharFormat<i8> for () {
fn isCharFormat(self , rsthis: & QTextFormat) -> i8 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK11QTextFormat12isCharFormatEv()};
let mut ret = unsafe {C_ZNK11QTextFormat12isCharFormatEv(rsthis.qclsinst)};
return ret as i8; // 1
// return 1;
}
}
// proto: void QTextFormat::clearBackground();
impl /*struct*/ QTextFormat {
pub fn clearBackground<RetType, T: QTextFormat_clearBackground<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.clearBackground(self);
// return 1;
}
}
pub trait QTextFormat_clearBackground<RetType> {
fn clearBackground(self , rsthis: & QTextFormat) -> RetType;
}
// proto: void QTextFormat::clearBackground();
impl<'a> /*trait*/ QTextFormat_clearBackground<()> for () {
fn clearBackground(self , rsthis: & QTextFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN11QTextFormat15clearBackgroundEv()};
unsafe {C_ZN11QTextFormat15clearBackgroundEv(rsthis.qclsinst)};
// return 1;
}
}
// proto: bool QTextFormat::isBlockFormat();
impl /*struct*/ QTextFormat {
pub fn isBlockFormat<RetType, T: QTextFormat_isBlockFormat<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.isBlockFormat(self);
// return 1;
}
}
pub trait QTextFormat_isBlockFormat<RetType> {
fn isBlockFormat(self , rsthis: & QTextFormat) -> RetType;
}
// proto: bool QTextFormat::isBlockFormat();
impl<'a> /*trait*/ QTextFormat_isBlockFormat<i8> for () {
fn isBlockFormat(self , rsthis: & QTextFormat) -> i8 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK11QTextFormat13isBlockFormatEv()};
let mut ret = unsafe {C_ZNK11QTextFormat13isBlockFormatEv(rsthis.qclsinst)};
return ret as i8; // 1
// return 1;
}
}
// proto: QBrush QTextFormat::background();
impl /*struct*/ QTextFormat {
pub fn background<RetType, T: QTextFormat_background<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.background(self);
// return 1;
}
}
pub trait QTextFormat_background<RetType> {
fn background(self , rsthis: & QTextFormat) -> RetType;
}
// proto: QBrush QTextFormat::background();
impl<'a> /*trait*/ QTextFormat_background<QBrush> for () {
fn background(self , rsthis: & QTextFormat) -> QBrush {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK11QTextFormat10backgroundEv()};
let mut ret = unsafe {C_ZNK11QTextFormat10backgroundEv(rsthis.qclsinst)};
let mut ret1 = QBrush::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: qreal QTextFormat::doubleProperty(int propertyId);
impl /*struct*/ QTextFormat {
pub fn doubleProperty<RetType, T: QTextFormat_doubleProperty<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.doubleProperty(self);
// return 1;
}
}
pub trait QTextFormat_doubleProperty<RetType> {
fn doubleProperty(self , rsthis: & QTextFormat) -> RetType;
}
// proto: qreal QTextFormat::doubleProperty(int propertyId);
impl<'a> /*trait*/ QTextFormat_doubleProperty<f64> for (i32) {
fn doubleProperty(self , rsthis: & QTextFormat) -> f64 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK11QTextFormat14doublePropertyEi()};
let arg0 = self as c_int;
let mut ret = unsafe {C_ZNK11QTextFormat14doublePropertyEi(rsthis.qclsinst, arg0)};
return ret as f64; // 1
// return 1;
}
}
// proto: void QTextFormat::swap(QTextFormat & other);
impl /*struct*/ QTextFormat {
pub fn swap<RetType, T: QTextFormat_swap<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.swap(self);
// return 1;
}
}
pub trait QTextFormat_swap<RetType> {
fn swap(self , rsthis: & QTextFormat) -> RetType;
}
// proto: void QTextFormat::swap(QTextFormat & other);
impl<'a> /*trait*/ QTextFormat_swap<()> for (&'a QTextFormat) {
fn swap(self , rsthis: & QTextFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN11QTextFormat4swapERS_()};
let arg0 = self.qclsinst as *mut c_void;
unsafe {C_ZN11QTextFormat4swapERS_(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: QTextImageFormat QTextFormat::toImageFormat();
impl /*struct*/ QTextFormat {
pub fn toImageFormat<RetType, T: QTextFormat_toImageFormat<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.toImageFormat(self);
// return 1;
}
}
pub trait QTextFormat_toImageFormat<RetType> {
fn toImageFormat(self , rsthis: & QTextFormat) -> RetType;
}
// proto: QTextImageFormat QTextFormat::toImageFormat();
impl<'a> /*trait*/ QTextFormat_toImageFormat<QTextImageFormat> for () {
fn toImageFormat(self , rsthis: & QTextFormat) -> QTextImageFormat {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK11QTextFormat13toImageFormatEv()};
let mut ret = unsafe {C_ZNK11QTextFormat13toImageFormatEv(rsthis.qclsinst)};
let mut ret1 = QTextImageFormat::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: bool QTextFormat::hasProperty(int propertyId);
impl /*struct*/ QTextFormat {
pub fn hasProperty<RetType, T: QTextFormat_hasProperty<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.hasProperty(self);
// return 1;
}
}
pub trait QTextFormat_hasProperty<RetType> {
fn hasProperty(self , rsthis: & QTextFormat) -> RetType;
}
// proto: bool QTextFormat::hasProperty(int propertyId);
impl<'a> /*trait*/ QTextFormat_hasProperty<i8> for (i32) {
fn hasProperty(self , rsthis: & QTextFormat) -> i8 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK11QTextFormat11hasPropertyEi()};
let arg0 = self as c_int;
let mut ret = unsafe {C_ZNK11QTextFormat11hasPropertyEi(rsthis.qclsinst, arg0)};
return ret as i8; // 1
// return 1;
}
}
// proto: QBrush QTextFormat::foreground();
impl /*struct*/ QTextFormat {
pub fn foreground<RetType, T: QTextFormat_foreground<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.foreground(self);
// return 1;
}
}
pub trait QTextFormat_foreground<RetType> {
fn foreground(self , rsthis: & QTextFormat) -> RetType;
}
// proto: QBrush QTextFormat::foreground();
impl<'a> /*trait*/ QTextFormat_foreground<QBrush> for () {
fn foreground(self , rsthis: & QTextFormat) -> QBrush {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK11QTextFormat10foregroundEv()};
let mut ret = unsafe {C_ZNK11QTextFormat10foregroundEv(rsthis.qclsinst)};
let mut ret1 = QBrush::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: void QTextFormat::setObjectType(int type);
impl /*struct*/ QTextFormat {
pub fn setObjectType<RetType, T: QTextFormat_setObjectType<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setObjectType(self);
// return 1;
}
}
pub trait QTextFormat_setObjectType<RetType> {
fn setObjectType(self , rsthis: & QTextFormat) -> RetType;
}
// proto: void QTextFormat::setObjectType(int type);
impl<'a> /*trait*/ QTextFormat_setObjectType<()> for (i32) {
fn setObjectType(self , rsthis: & QTextFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN11QTextFormat13setObjectTypeEi()};
let arg0 = self as c_int;
unsafe {C_ZN11QTextFormat13setObjectTypeEi(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: void QTextFormat::setBackground(const QBrush & brush);
impl /*struct*/ QTextFormat {
pub fn setBackground<RetType, T: QTextFormat_setBackground<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setBackground(self);
// return 1;
}
}
pub trait QTextFormat_setBackground<RetType> {
fn setBackground(self , rsthis: & QTextFormat) -> RetType;
}
// proto: void QTextFormat::setBackground(const QBrush & brush);
impl<'a> /*trait*/ QTextFormat_setBackground<()> for (&'a QBrush) {
fn setBackground(self , rsthis: & QTextFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN11QTextFormat13setBackgroundERK6QBrush()};
let arg0 = self.qclsinst as *mut c_void;
unsafe {C_ZN11QTextFormat13setBackgroundERK6QBrush(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: QTextTableFormat QTextFormat::toTableFormat();
impl /*struct*/ QTextFormat {
pub fn toTableFormat<RetType, T: QTextFormat_toTableFormat<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.toTableFormat(self);
// return 1;
}
}
pub trait QTextFormat_toTableFormat<RetType> {
fn toTableFormat(self , rsthis: & QTextFormat) -> RetType;
}
// proto: QTextTableFormat QTextFormat::toTableFormat();
impl<'a> /*trait*/ QTextFormat_toTableFormat<QTextTableFormat> for () {
fn toTableFormat(self , rsthis: & QTextFormat) -> QTextTableFormat {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK11QTextFormat13toTableFormatEv()};
let mut ret = unsafe {C_ZNK11QTextFormat13toTableFormatEv(rsthis.qclsinst)};
let mut ret1 = QTextTableFormat::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: bool QTextFormat::isFrameFormat();
impl /*struct*/ QTextFormat {
pub fn isFrameFormat<RetType, T: QTextFormat_isFrameFormat<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.isFrameFormat(self);
// return 1;
}
}
pub trait QTextFormat_isFrameFormat<RetType> {
fn isFrameFormat(self , rsthis: & QTextFormat) -> RetType;
}
// proto: bool QTextFormat::isFrameFormat();
impl<'a> /*trait*/ QTextFormat_isFrameFormat<i8> for () {
fn isFrameFormat(self , rsthis: & QTextFormat) -> i8 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK11QTextFormat13isFrameFormatEv()};
let mut ret = unsafe {C_ZNK11QTextFormat13isFrameFormatEv(rsthis.qclsinst)};
return ret as i8; // 1
// return 1;
}
}
// proto: int QTextFormat::intProperty(int propertyId);
impl /*struct*/ QTextFormat {
pub fn intProperty<RetType, T: QTextFormat_intProperty<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.intProperty(self);
// return 1;
}
}
pub trait QTextFormat_intProperty<RetType> {
fn intProperty(self , rsthis: & QTextFormat) -> RetType;
}
// proto: int QTextFormat::intProperty(int propertyId);
impl<'a> /*trait*/ QTextFormat_intProperty<i32> for (i32) {
fn intProperty(self , rsthis: & QTextFormat) -> i32 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK11QTextFormat11intPropertyEi()};
let arg0 = self as c_int;
let mut ret = unsafe {C_ZNK11QTextFormat11intPropertyEi(rsthis.qclsinst, arg0)};
return ret as i32; // 1
// return 1;
}
}
// proto: QTextCharFormat QTextFormat::toCharFormat();
impl /*struct*/ QTextFormat {
pub fn toCharFormat<RetType, T: QTextFormat_toCharFormat<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.toCharFormat(self);
// return 1;
}
}
pub trait QTextFormat_toCharFormat<RetType> {
fn toCharFormat(self , rsthis: & QTextFormat) -> RetType;
}
// proto: QTextCharFormat QTextFormat::toCharFormat();
impl<'a> /*trait*/ QTextFormat_toCharFormat<QTextCharFormat> for () {
fn toCharFormat(self , rsthis: & QTextFormat) -> QTextCharFormat {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK11QTextFormat12toCharFormatEv()};
let mut ret = unsafe {C_ZNK11QTextFormat12toCharFormatEv(rsthis.qclsinst)};
let mut ret1 = QTextCharFormat::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: bool QTextFormat::isEmpty();
impl /*struct*/ QTextFormat {
pub fn isEmpty<RetType, T: QTextFormat_isEmpty<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.isEmpty(self);
// return 1;
}
}
pub trait QTextFormat_isEmpty<RetType> {
fn isEmpty(self , rsthis: & QTextFormat) -> RetType;
}
// proto: bool QTextFormat::isEmpty();
impl<'a> /*trait*/ QTextFormat_isEmpty<i8> for () {
fn isEmpty(self , rsthis: & QTextFormat) -> i8 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK11QTextFormat7isEmptyEv()};
let mut ret = unsafe {C_ZNK11QTextFormat7isEmptyEv(rsthis.qclsinst)};
return ret as i8; // 1
// return 1;
}
}
// proto: QTextTableCellFormat QTextFormat::toTableCellFormat();
impl /*struct*/ QTextFormat {
pub fn toTableCellFormat<RetType, T: QTextFormat_toTableCellFormat<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.toTableCellFormat(self);
// return 1;
}
}
pub trait QTextFormat_toTableCellFormat<RetType> {
fn toTableCellFormat(self , rsthis: & QTextFormat) -> RetType;
}
// proto: QTextTableCellFormat QTextFormat::toTableCellFormat();
impl<'a> /*trait*/ QTextFormat_toTableCellFormat<QTextTableCellFormat> for () {
fn toTableCellFormat(self , rsthis: & QTextFormat) -> QTextTableCellFormat {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK11QTextFormat17toTableCellFormatEv()};
let mut ret = unsafe {C_ZNK11QTextFormat17toTableCellFormatEv(rsthis.qclsinst)};
let mut ret1 = QTextTableCellFormat::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: int QTextFormat::objectType();
impl /*struct*/ QTextFormat {
pub fn objectType<RetType, T: QTextFormat_objectType<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.objectType(self);
// return 1;
}
}
pub trait QTextFormat_objectType<RetType> {
fn objectType(self , rsthis: & QTextFormat) -> RetType;
}
// proto: int QTextFormat::objectType();
impl<'a> /*trait*/ QTextFormat_objectType<i32> for () {
fn objectType(self , rsthis: & QTextFormat) -> i32 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK11QTextFormat10objectTypeEv()};
let mut ret = unsafe {C_ZNK11QTextFormat10objectTypeEv(rsthis.qclsinst)};
return ret as i32; // 1
// return 1;
}
}
// proto: QTextListFormat QTextFormat::toListFormat();
impl /*struct*/ QTextFormat {
pub fn toListFormat<RetType, T: QTextFormat_toListFormat<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.toListFormat(self);
// return 1;
}
}
pub trait QTextFormat_toListFormat<RetType> {
fn toListFormat(self , rsthis: & QTextFormat) -> RetType;
}
// proto: QTextListFormat QTextFormat::toListFormat();
impl<'a> /*trait*/ QTextFormat_toListFormat<QTextListFormat> for () {
fn toListFormat(self , rsthis: & QTextFormat) -> QTextListFormat {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK11QTextFormat12toListFormatEv()};
let mut ret = unsafe {C_ZNK11QTextFormat12toListFormatEv(rsthis.qclsinst)};
let mut ret1 = QTextListFormat::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: QMap<int, QVariant> QTextFormat::properties();
impl /*struct*/ QTextFormat {
pub fn properties<RetType, T: QTextFormat_properties<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.properties(self);
// return 1;
}
}
pub trait QTextFormat_properties<RetType> {
fn properties(self , rsthis: & QTextFormat) -> RetType;
}
// proto: QMap<int, QVariant> QTextFormat::properties();
impl<'a> /*trait*/ QTextFormat_properties<u64> for () {
fn properties(self , rsthis: & QTextFormat) -> u64 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK11QTextFormat10propertiesEv()};
let mut ret = unsafe {C_ZNK11QTextFormat10propertiesEv(rsthis.qclsinst)};
return ret as u64; // 5
// return 1;
}
}
impl /*struct*/ QTextBlockFormat {
pub fn inheritFrom(qthis: u64 /* *mut c_void*/) -> QTextBlockFormat {
return QTextBlockFormat{qbase: QTextFormat::inheritFrom(qthis), qclsinst: qthis, ..Default::default()};
}
}
impl Deref for QTextBlockFormat {
type Target = QTextFormat;
fn deref(&self) -> &QTextFormat {
return & self.qbase;
}
}
impl AsRef<QTextFormat> for QTextBlockFormat {
fn as_ref(& self) -> & QTextFormat {
return & self.qbase;
}
}
// proto: int QTextBlockFormat::indent();
impl /*struct*/ QTextBlockFormat {
pub fn indent<RetType, T: QTextBlockFormat_indent<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.indent(self);
// return 1;
}
}
pub trait QTextBlockFormat_indent<RetType> {
fn indent(self , rsthis: & QTextBlockFormat) -> RetType;
}
// proto: int QTextBlockFormat::indent();
impl<'a> /*trait*/ QTextBlockFormat_indent<i32> for () {
fn indent(self , rsthis: & QTextBlockFormat) -> i32 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK16QTextBlockFormat6indentEv()};
let mut ret = unsafe {C_ZNK16QTextBlockFormat6indentEv(rsthis.qclsinst)};
return ret as i32; // 1
// return 1;
}
}
// proto: void QTextBlockFormat::setTextIndent(qreal aindent);
impl /*struct*/ QTextBlockFormat {
pub fn setTextIndent<RetType, T: QTextBlockFormat_setTextIndent<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setTextIndent(self);
// return 1;
}
}
pub trait QTextBlockFormat_setTextIndent<RetType> {
fn setTextIndent(self , rsthis: & QTextBlockFormat) -> RetType;
}
// proto: void QTextBlockFormat::setTextIndent(qreal aindent);
impl<'a> /*trait*/ QTextBlockFormat_setTextIndent<()> for (f64) {
fn setTextIndent(self , rsthis: & QTextBlockFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN16QTextBlockFormat13setTextIndentEd()};
let arg0 = self as c_double;
unsafe {C_ZN16QTextBlockFormat13setTextIndentEd(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: void QTextBlockFormat::setNonBreakableLines(bool b);
impl /*struct*/ QTextBlockFormat {
pub fn setNonBreakableLines<RetType, T: QTextBlockFormat_setNonBreakableLines<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setNonBreakableLines(self);
// return 1;
}
}
pub trait QTextBlockFormat_setNonBreakableLines<RetType> {
fn setNonBreakableLines(self , rsthis: & QTextBlockFormat) -> RetType;
}
// proto: void QTextBlockFormat::setNonBreakableLines(bool b);
impl<'a> /*trait*/ QTextBlockFormat_setNonBreakableLines<()> for (i8) {
fn setNonBreakableLines(self , rsthis: & QTextBlockFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN16QTextBlockFormat20setNonBreakableLinesEb()};
let arg0 = self as c_char;
unsafe {C_ZN16QTextBlockFormat20setNonBreakableLinesEb(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: void QTextBlockFormat::setIndent(int indent);
impl /*struct*/ QTextBlockFormat {
pub fn setIndent<RetType, T: QTextBlockFormat_setIndent<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setIndent(self);
// return 1;
}
}
pub trait QTextBlockFormat_setIndent<RetType> {
fn setIndent(self , rsthis: & QTextBlockFormat) -> RetType;
}
// proto: void QTextBlockFormat::setIndent(int indent);
impl<'a> /*trait*/ QTextBlockFormat_setIndent<()> for (i32) {
fn setIndent(self , rsthis: & QTextBlockFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN16QTextBlockFormat9setIndentEi()};
let arg0 = self as c_int;
unsafe {C_ZN16QTextBlockFormat9setIndentEi(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: qreal QTextBlockFormat::textIndent();
impl /*struct*/ QTextBlockFormat {
pub fn textIndent<RetType, T: QTextBlockFormat_textIndent<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.textIndent(self);
// return 1;
}
}
pub trait QTextBlockFormat_textIndent<RetType> {
fn textIndent(self , rsthis: & QTextBlockFormat) -> RetType;
}
// proto: qreal QTextBlockFormat::textIndent();
impl<'a> /*trait*/ QTextBlockFormat_textIndent<f64> for () {
fn textIndent(self , rsthis: & QTextBlockFormat) -> f64 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK16QTextBlockFormat10textIndentEv()};
let mut ret = unsafe {C_ZNK16QTextBlockFormat10textIndentEv(rsthis.qclsinst)};
return ret as f64; // 1
// return 1;
}
}
// proto: qreal QTextBlockFormat::lineHeight();
impl /*struct*/ QTextBlockFormat {
pub fn lineHeight<RetType, T: QTextBlockFormat_lineHeight<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.lineHeight(self);
// return 1;
}
}
pub trait QTextBlockFormat_lineHeight<RetType> {
fn lineHeight(self , rsthis: & QTextBlockFormat) -> RetType;
}
// proto: qreal QTextBlockFormat::lineHeight();
impl<'a> /*trait*/ QTextBlockFormat_lineHeight<f64> for () {
fn lineHeight(self , rsthis: & QTextBlockFormat) -> f64 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK16QTextBlockFormat10lineHeightEv()};
let mut ret = unsafe {C_ZNK16QTextBlockFormat10lineHeightEv(rsthis.qclsinst)};
return ret as f64; // 1
// return 1;
}
}
// proto: qreal QTextBlockFormat::lineHeight(qreal scriptLineHeight, qreal scaling);
impl<'a> /*trait*/ QTextBlockFormat_lineHeight<f64> for (f64, f64) {
fn lineHeight(self , rsthis: & QTextBlockFormat) -> f64 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK16QTextBlockFormat10lineHeightEdd()};
let arg0 = self.0 as c_double;
let arg1 = self.1 as c_double;
let mut ret = unsafe {C_ZNK16QTextBlockFormat10lineHeightEdd(rsthis.qclsinst, arg0, arg1)};
return ret as f64; // 1
// return 1;
}
}
// proto: void QTextBlockFormat::setRightMargin(qreal margin);
impl /*struct*/ QTextBlockFormat {
pub fn setRightMargin<RetType, T: QTextBlockFormat_setRightMargin<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setRightMargin(self);
// return 1;
}
}
pub trait QTextBlockFormat_setRightMargin<RetType> {
fn setRightMargin(self , rsthis: & QTextBlockFormat) -> RetType;
}
// proto: void QTextBlockFormat::setRightMargin(qreal margin);
impl<'a> /*trait*/ QTextBlockFormat_setRightMargin<()> for (f64) {
fn setRightMargin(self , rsthis: & QTextBlockFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN16QTextBlockFormat14setRightMarginEd()};
let arg0 = self as c_double;
unsafe {C_ZN16QTextBlockFormat14setRightMarginEd(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: qreal QTextBlockFormat::topMargin();
impl /*struct*/ QTextBlockFormat {
pub fn topMargin<RetType, T: QTextBlockFormat_topMargin<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.topMargin(self);
// return 1;
}
}
pub trait QTextBlockFormat_topMargin<RetType> {
fn topMargin(self , rsthis: & QTextBlockFormat) -> RetType;
}
// proto: qreal QTextBlockFormat::topMargin();
impl<'a> /*trait*/ QTextBlockFormat_topMargin<f64> for () {
fn topMargin(self , rsthis: & QTextBlockFormat) -> f64 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK16QTextBlockFormat9topMarginEv()};
let mut ret = unsafe {C_ZNK16QTextBlockFormat9topMarginEv(rsthis.qclsinst)};
return ret as f64; // 1
// return 1;
}
}
// proto: void QTextBlockFormat::QTextBlockFormat();
impl /*struct*/ QTextBlockFormat {
pub fn new<T: QTextBlockFormat_new>(value: T) -> QTextBlockFormat {
let rsthis = value.new();
return rsthis;
// return 1;
}
}
pub trait QTextBlockFormat_new {
fn new(self) -> QTextBlockFormat;
}
// proto: void QTextBlockFormat::QTextBlockFormat();
impl<'a> /*trait*/ QTextBlockFormat_new for () {
fn new(self) -> QTextBlockFormat {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN16QTextBlockFormatC2Ev()};
let ctysz: c_int = unsafe{QTextBlockFormat_Class_Size()};
let qthis_ph: u64 = unsafe{calloc(1, ctysz as usize)} as u64;
let qthis: u64 = unsafe {C_ZN16QTextBlockFormatC2Ev()};
let rsthis = QTextBlockFormat{qbase: QTextFormat::inheritFrom(qthis), qclsinst: qthis, ..Default::default()};
return rsthis;
// return 1;
}
}
// proto: qreal QTextBlockFormat::rightMargin();
impl /*struct*/ QTextBlockFormat {
pub fn rightMargin<RetType, T: QTextBlockFormat_rightMargin<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.rightMargin(self);
// return 1;
}
}
pub trait QTextBlockFormat_rightMargin<RetType> {
fn rightMargin(self , rsthis: & QTextBlockFormat) -> RetType;
}
// proto: qreal QTextBlockFormat::rightMargin();
impl<'a> /*trait*/ QTextBlockFormat_rightMargin<f64> for () {
fn rightMargin(self , rsthis: & QTextBlockFormat) -> f64 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK16QTextBlockFormat11rightMarginEv()};
let mut ret = unsafe {C_ZNK16QTextBlockFormat11rightMarginEv(rsthis.qclsinst)};
return ret as f64; // 1
// return 1;
}
}
// proto: qreal QTextBlockFormat::bottomMargin();
impl /*struct*/ QTextBlockFormat {
pub fn bottomMargin<RetType, T: QTextBlockFormat_bottomMargin<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.bottomMargin(self);
// return 1;
}
}
pub trait QTextBlockFormat_bottomMargin<RetType> {
fn bottomMargin(self , rsthis: & QTextBlockFormat) -> RetType;
}
// proto: qreal QTextBlockFormat::bottomMargin();
impl<'a> /*trait*/ QTextBlockFormat_bottomMargin<f64> for () {
fn bottomMargin(self , rsthis: & QTextBlockFormat) -> f64 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK16QTextBlockFormat12bottomMarginEv()};
let mut ret = unsafe {C_ZNK16QTextBlockFormat12bottomMarginEv(rsthis.qclsinst)};
return ret as f64; // 1
// return 1;
}
}
// proto: void QTextBlockFormat::setTopMargin(qreal margin);
impl /*struct*/ QTextBlockFormat {
pub fn setTopMargin<RetType, T: QTextBlockFormat_setTopMargin<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setTopMargin(self);
// return 1;
}
}
pub trait QTextBlockFormat_setTopMargin<RetType> {
fn setTopMargin(self , rsthis: & QTextBlockFormat) -> RetType;
}
// proto: void QTextBlockFormat::setTopMargin(qreal margin);
impl<'a> /*trait*/ QTextBlockFormat_setTopMargin<()> for (f64) {
fn setTopMargin(self , rsthis: & QTextBlockFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN16QTextBlockFormat12setTopMarginEd()};
let arg0 = self as c_double;
unsafe {C_ZN16QTextBlockFormat12setTopMarginEd(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: qreal QTextBlockFormat::leftMargin();
impl /*struct*/ QTextBlockFormat {
pub fn leftMargin<RetType, T: QTextBlockFormat_leftMargin<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.leftMargin(self);
// return 1;
}
}
pub trait QTextBlockFormat_leftMargin<RetType> {
fn leftMargin(self , rsthis: & QTextBlockFormat) -> RetType;
}
// proto: qreal QTextBlockFormat::leftMargin();
impl<'a> /*trait*/ QTextBlockFormat_leftMargin<f64> for () {
fn leftMargin(self , rsthis: & QTextBlockFormat) -> f64 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK16QTextBlockFormat10leftMarginEv()};
let mut ret = unsafe {C_ZNK16QTextBlockFormat10leftMarginEv(rsthis.qclsinst)};
return ret as f64; // 1
// return 1;
}
}
// proto: void QTextBlockFormat::setLineHeight(qreal height, int heightType);
impl /*struct*/ QTextBlockFormat {
pub fn setLineHeight<RetType, T: QTextBlockFormat_setLineHeight<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setLineHeight(self);
// return 1;
}
}
pub trait QTextBlockFormat_setLineHeight<RetType> {
fn setLineHeight(self , rsthis: & QTextBlockFormat) -> RetType;
}
// proto: void QTextBlockFormat::setLineHeight(qreal height, int heightType);
impl<'a> /*trait*/ QTextBlockFormat_setLineHeight<()> for (f64, i32) {
fn setLineHeight(self , rsthis: & QTextBlockFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN16QTextBlockFormat13setLineHeightEdi()};
let arg0 = self.0 as c_double;
let arg1 = self.1 as c_int;
unsafe {C_ZN16QTextBlockFormat13setLineHeightEdi(rsthis.qclsinst, arg0, arg1)};
// return 1;
}
}
// proto: void QTextBlockFormat::setBottomMargin(qreal margin);
impl /*struct*/ QTextBlockFormat {
pub fn setBottomMargin<RetType, T: QTextBlockFormat_setBottomMargin<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setBottomMargin(self);
// return 1;
}
}
pub trait QTextBlockFormat_setBottomMargin<RetType> {
fn setBottomMargin(self , rsthis: & QTextBlockFormat) -> RetType;
}
// proto: void QTextBlockFormat::setBottomMargin(qreal margin);
impl<'a> /*trait*/ QTextBlockFormat_setBottomMargin<()> for (f64) {
fn setBottomMargin(self , rsthis: & QTextBlockFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN16QTextBlockFormat15setBottomMarginEd()};
let arg0 = self as c_double;
unsafe {C_ZN16QTextBlockFormat15setBottomMarginEd(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: int QTextBlockFormat::lineHeightType();
impl /*struct*/ QTextBlockFormat {
pub fn lineHeightType<RetType, T: QTextBlockFormat_lineHeightType<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.lineHeightType(self);
// return 1;
}
}
pub trait QTextBlockFormat_lineHeightType<RetType> {
fn lineHeightType(self , rsthis: & QTextBlockFormat) -> RetType;
}
// proto: int QTextBlockFormat::lineHeightType();
impl<'a> /*trait*/ QTextBlockFormat_lineHeightType<i32> for () {
fn lineHeightType(self , rsthis: & QTextBlockFormat) -> i32 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK16QTextBlockFormat14lineHeightTypeEv()};
let mut ret = unsafe {C_ZNK16QTextBlockFormat14lineHeightTypeEv(rsthis.qclsinst)};
return ret as i32; // 1
// return 1;
}
}
// proto: void QTextBlockFormat::setLeftMargin(qreal margin);
impl /*struct*/ QTextBlockFormat {
pub fn setLeftMargin<RetType, T: QTextBlockFormat_setLeftMargin<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setLeftMargin(self);
// return 1;
}
}
pub trait QTextBlockFormat_setLeftMargin<RetType> {
fn setLeftMargin(self , rsthis: & QTextBlockFormat) -> RetType;
}
// proto: void QTextBlockFormat::setLeftMargin(qreal margin);
impl<'a> /*trait*/ QTextBlockFormat_setLeftMargin<()> for (f64) {
fn setLeftMargin(self , rsthis: & QTextBlockFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN16QTextBlockFormat13setLeftMarginEd()};
let arg0 = self as c_double;
unsafe {C_ZN16QTextBlockFormat13setLeftMarginEd(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: bool QTextBlockFormat::isValid();
impl /*struct*/ QTextBlockFormat {
pub fn isValid<RetType, T: QTextBlockFormat_isValid<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.isValid(self);
// return 1;
}
}
pub trait QTextBlockFormat_isValid<RetType> {
fn isValid(self , rsthis: & QTextBlockFormat) -> RetType;
}
// proto: bool QTextBlockFormat::isValid();
impl<'a> /*trait*/ QTextBlockFormat_isValid<i8> for () {
fn isValid(self , rsthis: & QTextBlockFormat) -> i8 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK16QTextBlockFormat7isValidEv()};
let mut ret = unsafe {C_ZNK16QTextBlockFormat7isValidEv(rsthis.qclsinst)};
return ret as i8; // 1
// return 1;
}
}
// proto: bool QTextBlockFormat::nonBreakableLines();
impl /*struct*/ QTextBlockFormat {
pub fn nonBreakableLines<RetType, T: QTextBlockFormat_nonBreakableLines<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.nonBreakableLines(self);
// return 1;
}
}
pub trait QTextBlockFormat_nonBreakableLines<RetType> {
fn nonBreakableLines(self , rsthis: & QTextBlockFormat) -> RetType;
}
// proto: bool QTextBlockFormat::nonBreakableLines();
impl<'a> /*trait*/ QTextBlockFormat_nonBreakableLines<i8> for () {
fn nonBreakableLines(self , rsthis: & QTextBlockFormat) -> i8 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK16QTextBlockFormat17nonBreakableLinesEv()};
let mut ret = unsafe {C_ZNK16QTextBlockFormat17nonBreakableLinesEv(rsthis.qclsinst)};
return ret as i8; // 1
// return 1;
}
}
impl /*struct*/ QTextCharFormat {
pub fn inheritFrom(qthis: u64 /* *mut c_void*/) -> QTextCharFormat {
return QTextCharFormat{qbase: QTextFormat::inheritFrom(qthis), qclsinst: qthis, ..Default::default()};
}
}
impl Deref for QTextCharFormat {
type Target = QTextFormat;
fn deref(&self) -> &QTextFormat {
return & self.qbase;
}
}
impl AsRef<QTextFormat> for QTextCharFormat {
fn as_ref(& self) -> & QTextFormat {
return & self.qbase;
}
}
// proto: void QTextCharFormat::setFontLetterSpacing(qreal spacing);
impl /*struct*/ QTextCharFormat {
pub fn setFontLetterSpacing<RetType, T: QTextCharFormat_setFontLetterSpacing<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setFontLetterSpacing(self);
// return 1;
}
}
pub trait QTextCharFormat_setFontLetterSpacing<RetType> {
fn setFontLetterSpacing(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: void QTextCharFormat::setFontLetterSpacing(qreal spacing);
impl<'a> /*trait*/ QTextCharFormat_setFontLetterSpacing<()> for (f64) {
fn setFontLetterSpacing(self , rsthis: & QTextCharFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN15QTextCharFormat20setFontLetterSpacingEd()};
let arg0 = self as c_double;
unsafe {C_ZN15QTextCharFormat20setFontLetterSpacingEd(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: bool QTextCharFormat::isAnchor();
impl /*struct*/ QTextCharFormat {
pub fn isAnchor<RetType, T: QTextCharFormat_isAnchor<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.isAnchor(self);
// return 1;
}
}
pub trait QTextCharFormat_isAnchor<RetType> {
fn isAnchor(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: bool QTextCharFormat::isAnchor();
impl<'a> /*trait*/ QTextCharFormat_isAnchor<i8> for () {
fn isAnchor(self , rsthis: & QTextCharFormat) -> i8 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK15QTextCharFormat8isAnchorEv()};
let mut ret = unsafe {C_ZNK15QTextCharFormat8isAnchorEv(rsthis.qclsinst)};
return ret as i8; // 1
// return 1;
}
}
// proto: void QTextCharFormat::setFont(const QFont & font);
impl /*struct*/ QTextCharFormat {
pub fn setFont<RetType, T: QTextCharFormat_setFont<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setFont(self);
// return 1;
}
}
pub trait QTextCharFormat_setFont<RetType> {
fn setFont(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: void QTextCharFormat::setFont(const QFont & font);
impl<'a> /*trait*/ QTextCharFormat_setFont<()> for (&'a QFont) {
fn setFont(self , rsthis: & QTextCharFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN15QTextCharFormat7setFontERK5QFont()};
let arg0 = self.qclsinst as *mut c_void;
unsafe {C_ZN15QTextCharFormat7setFontERK5QFont(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: bool QTextCharFormat::fontOverline();
impl /*struct*/ QTextCharFormat {
pub fn fontOverline<RetType, T: QTextCharFormat_fontOverline<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.fontOverline(self);
// return 1;
}
}
pub trait QTextCharFormat_fontOverline<RetType> {
fn fontOverline(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: bool QTextCharFormat::fontOverline();
impl<'a> /*trait*/ QTextCharFormat_fontOverline<i8> for () {
fn fontOverline(self , rsthis: & QTextCharFormat) -> i8 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK15QTextCharFormat12fontOverlineEv()};
let mut ret = unsafe {C_ZNK15QTextCharFormat12fontOverlineEv(rsthis.qclsinst)};
return ret as i8; // 1
// return 1;
}
}
// proto: QFont QTextCharFormat::font();
impl /*struct*/ QTextCharFormat {
pub fn font<RetType, T: QTextCharFormat_font<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.font(self);
// return 1;
}
}
pub trait QTextCharFormat_font<RetType> {
fn font(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: QFont QTextCharFormat::font();
impl<'a> /*trait*/ QTextCharFormat_font<QFont> for () {
fn font(self , rsthis: & QTextCharFormat) -> QFont {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK15QTextCharFormat4fontEv()};
let mut ret = unsafe {C_ZNK15QTextCharFormat4fontEv(rsthis.qclsinst)};
let mut ret1 = QFont::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: QString QTextCharFormat::fontFamily();
impl /*struct*/ QTextCharFormat {
pub fn fontFamily<RetType, T: QTextCharFormat_fontFamily<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.fontFamily(self);
// return 1;
}
}
pub trait QTextCharFormat_fontFamily<RetType> {
fn fontFamily(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: QString QTextCharFormat::fontFamily();
impl<'a> /*trait*/ QTextCharFormat_fontFamily<QString> for () {
fn fontFamily(self , rsthis: & QTextCharFormat) -> QString {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK15QTextCharFormat10fontFamilyEv()};
let mut ret = unsafe {C_ZNK15QTextCharFormat10fontFamilyEv(rsthis.qclsinst)};
let mut ret1 = QString::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: bool QTextCharFormat::fontStrikeOut();
impl /*struct*/ QTextCharFormat {
pub fn fontStrikeOut<RetType, T: QTextCharFormat_fontStrikeOut<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.fontStrikeOut(self);
// return 1;
}
}
pub trait QTextCharFormat_fontStrikeOut<RetType> {
fn fontStrikeOut(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: bool QTextCharFormat::fontStrikeOut();
impl<'a> /*trait*/ QTextCharFormat_fontStrikeOut<i8> for () {
fn fontStrikeOut(self , rsthis: & QTextCharFormat) -> i8 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK15QTextCharFormat13fontStrikeOutEv()};
let mut ret = unsafe {C_ZNK15QTextCharFormat13fontStrikeOutEv(rsthis.qclsinst)};
return ret as i8; // 1
// return 1;
}
}
// proto: void QTextCharFormat::setFontPointSize(qreal size);
impl /*struct*/ QTextCharFormat {
pub fn setFontPointSize<RetType, T: QTextCharFormat_setFontPointSize<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setFontPointSize(self);
// return 1;
}
}
pub trait QTextCharFormat_setFontPointSize<RetType> {
fn setFontPointSize(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: void QTextCharFormat::setFontPointSize(qreal size);
impl<'a> /*trait*/ QTextCharFormat_setFontPointSize<()> for (f64) {
fn setFontPointSize(self , rsthis: & QTextCharFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN15QTextCharFormat16setFontPointSizeEd()};
let arg0 = self as c_double;
unsafe {C_ZN15QTextCharFormat16setFontPointSizeEd(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: void QTextCharFormat::setUnderlineColor(const QColor & color);
impl /*struct*/ QTextCharFormat {
pub fn setUnderlineColor<RetType, T: QTextCharFormat_setUnderlineColor<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setUnderlineColor(self);
// return 1;
}
}
pub trait QTextCharFormat_setUnderlineColor<RetType> {
fn setUnderlineColor(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: void QTextCharFormat::setUnderlineColor(const QColor & color);
impl<'a> /*trait*/ QTextCharFormat_setUnderlineColor<()> for (&'a QColor) {
fn setUnderlineColor(self , rsthis: & QTextCharFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN15QTextCharFormat17setUnderlineColorERK6QColor()};
let arg0 = self.qclsinst as *mut c_void;
unsafe {C_ZN15QTextCharFormat17setUnderlineColorERK6QColor(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: int QTextCharFormat::tableCellRowSpan();
impl /*struct*/ QTextCharFormat {
pub fn tableCellRowSpan<RetType, T: QTextCharFormat_tableCellRowSpan<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.tableCellRowSpan(self);
// return 1;
}
}
pub trait QTextCharFormat_tableCellRowSpan<RetType> {
fn tableCellRowSpan(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: int QTextCharFormat::tableCellRowSpan();
impl<'a> /*trait*/ QTextCharFormat_tableCellRowSpan<i32> for () {
fn tableCellRowSpan(self , rsthis: & QTextCharFormat) -> i32 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK15QTextCharFormat16tableCellRowSpanEv()};
let mut ret = unsafe {C_ZNK15QTextCharFormat16tableCellRowSpanEv(rsthis.qclsinst)};
return ret as i32; // 1
// return 1;
}
}
// proto: void QTextCharFormat::setFontUnderline(bool underline);
impl /*struct*/ QTextCharFormat {
pub fn setFontUnderline<RetType, T: QTextCharFormat_setFontUnderline<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setFontUnderline(self);
// return 1;
}
}
pub trait QTextCharFormat_setFontUnderline<RetType> {
fn setFontUnderline(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: void QTextCharFormat::setFontUnderline(bool underline);
impl<'a> /*trait*/ QTextCharFormat_setFontUnderline<()> for (i8) {
fn setFontUnderline(self , rsthis: & QTextCharFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN15QTextCharFormat16setFontUnderlineEb()};
let arg0 = self as c_char;
unsafe {C_ZN15QTextCharFormat16setFontUnderlineEb(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: bool QTextCharFormat::isValid();
impl /*struct*/ QTextCharFormat {
pub fn isValid<RetType, T: QTextCharFormat_isValid<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.isValid(self);
// return 1;
}
}
pub trait QTextCharFormat_isValid<RetType> {
fn isValid(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: bool QTextCharFormat::isValid();
impl<'a> /*trait*/ QTextCharFormat_isValid<i8> for () {
fn isValid(self , rsthis: & QTextCharFormat) -> i8 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK15QTextCharFormat7isValidEv()};
let mut ret = unsafe {C_ZNK15QTextCharFormat7isValidEv(rsthis.qclsinst)};
return ret as i8; // 1
// return 1;
}
}
// proto: bool QTextCharFormat::fontItalic();
impl /*struct*/ QTextCharFormat {
pub fn fontItalic<RetType, T: QTextCharFormat_fontItalic<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.fontItalic(self);
// return 1;
}
}
pub trait QTextCharFormat_fontItalic<RetType> {
fn fontItalic(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: bool QTextCharFormat::fontItalic();
impl<'a> /*trait*/ QTextCharFormat_fontItalic<i8> for () {
fn fontItalic(self , rsthis: & QTextCharFormat) -> i8 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK15QTextCharFormat10fontItalicEv()};
let mut ret = unsafe {C_ZNK15QTextCharFormat10fontItalicEv(rsthis.qclsinst)};
return ret as i8; // 1
// return 1;
}
}
// proto: void QTextCharFormat::setToolTip(const QString & tip);
impl /*struct*/ QTextCharFormat {
pub fn setToolTip<RetType, T: QTextCharFormat_setToolTip<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setToolTip(self);
// return 1;
}
}
pub trait QTextCharFormat_setToolTip<RetType> {
fn setToolTip(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: void QTextCharFormat::setToolTip(const QString & tip);
impl<'a> /*trait*/ QTextCharFormat_setToolTip<()> for (&'a QString) {
fn setToolTip(self , rsthis: & QTextCharFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN15QTextCharFormat10setToolTipERK7QString()};
let arg0 = self.qclsinst as *mut c_void;
unsafe {C_ZN15QTextCharFormat10setToolTipERK7QString(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: void QTextCharFormat::setTextOutline(const QPen & pen);
impl /*struct*/ QTextCharFormat {
pub fn setTextOutline<RetType, T: QTextCharFormat_setTextOutline<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setTextOutline(self);
// return 1;
}
}
pub trait QTextCharFormat_setTextOutline<RetType> {
fn setTextOutline(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: void QTextCharFormat::setTextOutline(const QPen & pen);
impl<'a> /*trait*/ QTextCharFormat_setTextOutline<()> for (&'a QPen) {
fn setTextOutline(self , rsthis: & QTextCharFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN15QTextCharFormat14setTextOutlineERK4QPen()};
let arg0 = self.qclsinst as *mut c_void;
unsafe {C_ZN15QTextCharFormat14setTextOutlineERK4QPen(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: void QTextCharFormat::setTableCellRowSpan(int tableCellRowSpan);
impl /*struct*/ QTextCharFormat {
pub fn setTableCellRowSpan<RetType, T: QTextCharFormat_setTableCellRowSpan<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setTableCellRowSpan(self);
// return 1;
}
}
pub trait QTextCharFormat_setTableCellRowSpan<RetType> {
fn setTableCellRowSpan(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: void QTextCharFormat::setTableCellRowSpan(int tableCellRowSpan);
impl<'a> /*trait*/ QTextCharFormat_setTableCellRowSpan<()> for (i32) {
fn setTableCellRowSpan(self , rsthis: & QTextCharFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN15QTextCharFormat19setTableCellRowSpanEi()};
let arg0 = self as c_int;
unsafe {C_ZN15QTextCharFormat19setTableCellRowSpanEi(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: void QTextCharFormat::setAnchor(bool anchor);
impl /*struct*/ QTextCharFormat {
pub fn setAnchor<RetType, T: QTextCharFormat_setAnchor<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setAnchor(self);
// return 1;
}
}
pub trait QTextCharFormat_setAnchor<RetType> {
fn setAnchor(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: void QTextCharFormat::setAnchor(bool anchor);
impl<'a> /*trait*/ QTextCharFormat_setAnchor<()> for (i8) {
fn setAnchor(self , rsthis: & QTextCharFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN15QTextCharFormat9setAnchorEb()};
let arg0 = self as c_char;
unsafe {C_ZN15QTextCharFormat9setAnchorEb(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: qreal QTextCharFormat::fontPointSize();
impl /*struct*/ QTextCharFormat {
pub fn fontPointSize<RetType, T: QTextCharFormat_fontPointSize<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.fontPointSize(self);
// return 1;
}
}
pub trait QTextCharFormat_fontPointSize<RetType> {
fn fontPointSize(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: qreal QTextCharFormat::fontPointSize();
impl<'a> /*trait*/ QTextCharFormat_fontPointSize<f64> for () {
fn fontPointSize(self , rsthis: & QTextCharFormat) -> f64 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK15QTextCharFormat13fontPointSizeEv()};
let mut ret = unsafe {C_ZNK15QTextCharFormat13fontPointSizeEv(rsthis.qclsinst)};
return ret as f64; // 1
// return 1;
}
}
// proto: void QTextCharFormat::setFontStrikeOut(bool strikeOut);
impl /*struct*/ QTextCharFormat {
pub fn setFontStrikeOut<RetType, T: QTextCharFormat_setFontStrikeOut<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setFontStrikeOut(self);
// return 1;
}
}
pub trait QTextCharFormat_setFontStrikeOut<RetType> {
fn setFontStrikeOut(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: void QTextCharFormat::setFontStrikeOut(bool strikeOut);
impl<'a> /*trait*/ QTextCharFormat_setFontStrikeOut<()> for (i8) {
fn setFontStrikeOut(self , rsthis: & QTextCharFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN15QTextCharFormat16setFontStrikeOutEb()};
let arg0 = self as c_char;
unsafe {C_ZN15QTextCharFormat16setFontStrikeOutEb(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: qreal QTextCharFormat::fontWordSpacing();
impl /*struct*/ QTextCharFormat {
pub fn fontWordSpacing<RetType, T: QTextCharFormat_fontWordSpacing<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.fontWordSpacing(self);
// return 1;
}
}
pub trait QTextCharFormat_fontWordSpacing<RetType> {
fn fontWordSpacing(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: qreal QTextCharFormat::fontWordSpacing();
impl<'a> /*trait*/ QTextCharFormat_fontWordSpacing<f64> for () {
fn fontWordSpacing(self , rsthis: & QTextCharFormat) -> f64 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK15QTextCharFormat15fontWordSpacingEv()};
let mut ret = unsafe {C_ZNK15QTextCharFormat15fontWordSpacingEv(rsthis.qclsinst)};
return ret as f64; // 1
// return 1;
}
}
// proto: QString QTextCharFormat::toolTip();
impl /*struct*/ QTextCharFormat {
pub fn toolTip<RetType, T: QTextCharFormat_toolTip<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.toolTip(self);
// return 1;
}
}
pub trait QTextCharFormat_toolTip<RetType> {
fn toolTip(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: QString QTextCharFormat::toolTip();
impl<'a> /*trait*/ QTextCharFormat_toolTip<QString> for () {
fn toolTip(self , rsthis: & QTextCharFormat) -> QString {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK15QTextCharFormat7toolTipEv()};
let mut ret = unsafe {C_ZNK15QTextCharFormat7toolTipEv(rsthis.qclsinst)};
let mut ret1 = QString::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: void QTextCharFormat::setAnchorNames(const QStringList & names);
impl /*struct*/ QTextCharFormat {
pub fn setAnchorNames<RetType, T: QTextCharFormat_setAnchorNames<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setAnchorNames(self);
// return 1;
}
}
pub trait QTextCharFormat_setAnchorNames<RetType> {
fn setAnchorNames(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: void QTextCharFormat::setAnchorNames(const QStringList & names);
impl<'a> /*trait*/ QTextCharFormat_setAnchorNames<()> for (&'a QStringList) {
fn setAnchorNames(self , rsthis: & QTextCharFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN15QTextCharFormat14setAnchorNamesERK11QStringList()};
let arg0 = self.qclsinst as *mut c_void;
unsafe {C_ZN15QTextCharFormat14setAnchorNamesERK11QStringList(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: QStringList QTextCharFormat::anchorNames();
impl /*struct*/ QTextCharFormat {
pub fn anchorNames<RetType, T: QTextCharFormat_anchorNames<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.anchorNames(self);
// return 1;
}
}
pub trait QTextCharFormat_anchorNames<RetType> {
fn anchorNames(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: QStringList QTextCharFormat::anchorNames();
impl<'a> /*trait*/ QTextCharFormat_anchorNames<QStringList> for () {
fn anchorNames(self , rsthis: & QTextCharFormat) -> QStringList {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK15QTextCharFormat11anchorNamesEv()};
let mut ret = unsafe {C_ZNK15QTextCharFormat11anchorNamesEv(rsthis.qclsinst)};
let mut ret1 = QStringList::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: void QTextCharFormat::setFontFixedPitch(bool fixedPitch);
impl /*struct*/ QTextCharFormat {
pub fn setFontFixedPitch<RetType, T: QTextCharFormat_setFontFixedPitch<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setFontFixedPitch(self);
// return 1;
}
}
pub trait QTextCharFormat_setFontFixedPitch<RetType> {
fn setFontFixedPitch(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: void QTextCharFormat::setFontFixedPitch(bool fixedPitch);
impl<'a> /*trait*/ QTextCharFormat_setFontFixedPitch<()> for (i8) {
fn setFontFixedPitch(self , rsthis: & QTextCharFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN15QTextCharFormat17setFontFixedPitchEb()};
let arg0 = self as c_char;
unsafe {C_ZN15QTextCharFormat17setFontFixedPitchEb(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: void QTextCharFormat::setFontItalic(bool italic);
impl /*struct*/ QTextCharFormat {
pub fn setFontItalic<RetType, T: QTextCharFormat_setFontItalic<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setFontItalic(self);
// return 1;
}
}
pub trait QTextCharFormat_setFontItalic<RetType> {
fn setFontItalic(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: void QTextCharFormat::setFontItalic(bool italic);
impl<'a> /*trait*/ QTextCharFormat_setFontItalic<()> for (i8) {
fn setFontItalic(self , rsthis: & QTextCharFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN15QTextCharFormat13setFontItalicEb()};
let arg0 = self as c_char;
unsafe {C_ZN15QTextCharFormat13setFontItalicEb(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: void QTextCharFormat::setFontFamily(const QString & family);
impl /*struct*/ QTextCharFormat {
pub fn setFontFamily<RetType, T: QTextCharFormat_setFontFamily<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setFontFamily(self);
// return 1;
}
}
pub trait QTextCharFormat_setFontFamily<RetType> {
fn setFontFamily(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: void QTextCharFormat::setFontFamily(const QString & family);
impl<'a> /*trait*/ QTextCharFormat_setFontFamily<()> for (&'a QString) {
fn setFontFamily(self , rsthis: & QTextCharFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN15QTextCharFormat13setFontFamilyERK7QString()};
let arg0 = self.qclsinst as *mut c_void;
unsafe {C_ZN15QTextCharFormat13setFontFamilyERK7QString(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: bool QTextCharFormat::fontFixedPitch();
impl /*struct*/ QTextCharFormat {
pub fn fontFixedPitch<RetType, T: QTextCharFormat_fontFixedPitch<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.fontFixedPitch(self);
// return 1;
}
}
pub trait QTextCharFormat_fontFixedPitch<RetType> {
fn fontFixedPitch(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: bool QTextCharFormat::fontFixedPitch();
impl<'a> /*trait*/ QTextCharFormat_fontFixedPitch<i8> for () {
fn fontFixedPitch(self , rsthis: & QTextCharFormat) -> i8 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK15QTextCharFormat14fontFixedPitchEv()};
let mut ret = unsafe {C_ZNK15QTextCharFormat14fontFixedPitchEv(rsthis.qclsinst)};
return ret as i8; // 1
// return 1;
}
}
// proto: void QTextCharFormat::setAnchorHref(const QString & value);
impl /*struct*/ QTextCharFormat {
pub fn setAnchorHref<RetType, T: QTextCharFormat_setAnchorHref<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setAnchorHref(self);
// return 1;
}
}
pub trait QTextCharFormat_setAnchorHref<RetType> {
fn setAnchorHref(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: void QTextCharFormat::setAnchorHref(const QString & value);
impl<'a> /*trait*/ QTextCharFormat_setAnchorHref<()> for (&'a QString) {
fn setAnchorHref(self , rsthis: & QTextCharFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN15QTextCharFormat13setAnchorHrefERK7QString()};
let arg0 = self.qclsinst as *mut c_void;
unsafe {C_ZN15QTextCharFormat13setAnchorHrefERK7QString(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: int QTextCharFormat::fontStretch();
impl /*struct*/ QTextCharFormat {
pub fn fontStretch<RetType, T: QTextCharFormat_fontStretch<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.fontStretch(self);
// return 1;
}
}
pub trait QTextCharFormat_fontStretch<RetType> {
fn fontStretch(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: int QTextCharFormat::fontStretch();
impl<'a> /*trait*/ QTextCharFormat_fontStretch<i32> for () {
fn fontStretch(self , rsthis: & QTextCharFormat) -> i32 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK15QTextCharFormat11fontStretchEv()};
let mut ret = unsafe {C_ZNK15QTextCharFormat11fontStretchEv(rsthis.qclsinst)};
return ret as i32; // 1
// return 1;
}
}
// proto: void QTextCharFormat::setFontKerning(bool enable);
impl /*struct*/ QTextCharFormat {
pub fn setFontKerning<RetType, T: QTextCharFormat_setFontKerning<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setFontKerning(self);
// return 1;
}
}
pub trait QTextCharFormat_setFontKerning<RetType> {
fn setFontKerning(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: void QTextCharFormat::setFontKerning(bool enable);
impl<'a> /*trait*/ QTextCharFormat_setFontKerning<()> for (i8) {
fn setFontKerning(self , rsthis: & QTextCharFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN15QTextCharFormat14setFontKerningEb()};
let arg0 = self as c_char;
unsafe {C_ZN15QTextCharFormat14setFontKerningEb(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: int QTextCharFormat::tableCellColumnSpan();
impl /*struct*/ QTextCharFormat {
pub fn tableCellColumnSpan<RetType, T: QTextCharFormat_tableCellColumnSpan<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.tableCellColumnSpan(self);
// return 1;
}
}
pub trait QTextCharFormat_tableCellColumnSpan<RetType> {
fn tableCellColumnSpan(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: int QTextCharFormat::tableCellColumnSpan();
impl<'a> /*trait*/ QTextCharFormat_tableCellColumnSpan<i32> for () {
fn tableCellColumnSpan(self , rsthis: & QTextCharFormat) -> i32 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK15QTextCharFormat19tableCellColumnSpanEv()};
let mut ret = unsafe {C_ZNK15QTextCharFormat19tableCellColumnSpanEv(rsthis.qclsinst)};
return ret as i32; // 1
// return 1;
}
}
// proto: void QTextCharFormat::QTextCharFormat();
impl /*struct*/ QTextCharFormat {
pub fn new<T: QTextCharFormat_new>(value: T) -> QTextCharFormat {
let rsthis = value.new();
return rsthis;
// return 1;
}
}
pub trait QTextCharFormat_new {
fn new(self) -> QTextCharFormat;
}
// proto: void QTextCharFormat::QTextCharFormat();
impl<'a> /*trait*/ QTextCharFormat_new for () {
fn new(self) -> QTextCharFormat {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN15QTextCharFormatC2Ev()};
let ctysz: c_int = unsafe{QTextCharFormat_Class_Size()};
let qthis_ph: u64 = unsafe{calloc(1, ctysz as usize)} as u64;
let qthis: u64 = unsafe {C_ZN15QTextCharFormatC2Ev()};
let rsthis = QTextCharFormat{qbase: QTextFormat::inheritFrom(qthis), qclsinst: qthis, ..Default::default()};
return rsthis;
// return 1;
}
}
// proto: qreal QTextCharFormat::fontLetterSpacing();
impl /*struct*/ QTextCharFormat {
pub fn fontLetterSpacing<RetType, T: QTextCharFormat_fontLetterSpacing<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.fontLetterSpacing(self);
// return 1;
}
}
pub trait QTextCharFormat_fontLetterSpacing<RetType> {
fn fontLetterSpacing(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: qreal QTextCharFormat::fontLetterSpacing();
impl<'a> /*trait*/ QTextCharFormat_fontLetterSpacing<f64> for () {
fn fontLetterSpacing(self , rsthis: & QTextCharFormat) -> f64 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK15QTextCharFormat17fontLetterSpacingEv()};
let mut ret = unsafe {C_ZNK15QTextCharFormat17fontLetterSpacingEv(rsthis.qclsinst)};
return ret as f64; // 1
// return 1;
}
}
// proto: QString QTextCharFormat::anchorHref();
impl /*struct*/ QTextCharFormat {
pub fn anchorHref<RetType, T: QTextCharFormat_anchorHref<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.anchorHref(self);
// return 1;
}
}
pub trait QTextCharFormat_anchorHref<RetType> {
fn anchorHref(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: QString QTextCharFormat::anchorHref();
impl<'a> /*trait*/ QTextCharFormat_anchorHref<QString> for () {
fn anchorHref(self , rsthis: & QTextCharFormat) -> QString {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK15QTextCharFormat10anchorHrefEv()};
let mut ret = unsafe {C_ZNK15QTextCharFormat10anchorHrefEv(rsthis.qclsinst)};
let mut ret1 = QString::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: QString QTextCharFormat::anchorName();
impl /*struct*/ QTextCharFormat {
pub fn anchorName<RetType, T: QTextCharFormat_anchorName<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.anchorName(self);
// return 1;
}
}
pub trait QTextCharFormat_anchorName<RetType> {
fn anchorName(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: QString QTextCharFormat::anchorName();
impl<'a> /*trait*/ QTextCharFormat_anchorName<QString> for () {
fn anchorName(self , rsthis: & QTextCharFormat) -> QString {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK15QTextCharFormat10anchorNameEv()};
let mut ret = unsafe {C_ZNK15QTextCharFormat10anchorNameEv(rsthis.qclsinst)};
let mut ret1 = QString::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: void QTextCharFormat::setFontStretch(int factor);
impl /*struct*/ QTextCharFormat {
pub fn setFontStretch<RetType, T: QTextCharFormat_setFontStretch<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setFontStretch(self);
// return 1;
}
}
pub trait QTextCharFormat_setFontStretch<RetType> {
fn setFontStretch(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: void QTextCharFormat::setFontStretch(int factor);
impl<'a> /*trait*/ QTextCharFormat_setFontStretch<()> for (i32) {
fn setFontStretch(self , rsthis: & QTextCharFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN15QTextCharFormat14setFontStretchEi()};
let arg0 = self as c_int;
unsafe {C_ZN15QTextCharFormat14setFontStretchEi(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: void QTextCharFormat::setAnchorName(const QString & name);
impl /*struct*/ QTextCharFormat {
pub fn setAnchorName<RetType, T: QTextCharFormat_setAnchorName<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setAnchorName(self);
// return 1;
}
}
pub trait QTextCharFormat_setAnchorName<RetType> {
fn setAnchorName(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: void QTextCharFormat::setAnchorName(const QString & name);
impl<'a> /*trait*/ QTextCharFormat_setAnchorName<()> for (&'a QString) {
fn setAnchorName(self , rsthis: & QTextCharFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN15QTextCharFormat13setAnchorNameERK7QString()};
let arg0 = self.qclsinst as *mut c_void;
unsafe {C_ZN15QTextCharFormat13setAnchorNameERK7QString(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: bool QTextCharFormat::fontKerning();
impl /*struct*/ QTextCharFormat {
pub fn fontKerning<RetType, T: QTextCharFormat_fontKerning<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.fontKerning(self);
// return 1;
}
}
pub trait QTextCharFormat_fontKerning<RetType> {
fn fontKerning(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: bool QTextCharFormat::fontKerning();
impl<'a> /*trait*/ QTextCharFormat_fontKerning<i8> for () {
fn fontKerning(self , rsthis: & QTextCharFormat) -> i8 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK15QTextCharFormat11fontKerningEv()};
let mut ret = unsafe {C_ZNK15QTextCharFormat11fontKerningEv(rsthis.qclsinst)};
return ret as i8; // 1
// return 1;
}
}
// proto: void QTextCharFormat::setFontWeight(int weight);
impl /*struct*/ QTextCharFormat {
pub fn setFontWeight<RetType, T: QTextCharFormat_setFontWeight<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setFontWeight(self);
// return 1;
}
}
pub trait QTextCharFormat_setFontWeight<RetType> {
fn setFontWeight(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: void QTextCharFormat::setFontWeight(int weight);
impl<'a> /*trait*/ QTextCharFormat_setFontWeight<()> for (i32) {
fn setFontWeight(self , rsthis: & QTextCharFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN15QTextCharFormat13setFontWeightEi()};
let arg0 = self as c_int;
unsafe {C_ZN15QTextCharFormat13setFontWeightEi(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: bool QTextCharFormat::fontUnderline();
impl /*struct*/ QTextCharFormat {
pub fn fontUnderline<RetType, T: QTextCharFormat_fontUnderline<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.fontUnderline(self);
// return 1;
}
}
pub trait QTextCharFormat_fontUnderline<RetType> {
fn fontUnderline(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: bool QTextCharFormat::fontUnderline();
impl<'a> /*trait*/ QTextCharFormat_fontUnderline<i8> for () {
fn fontUnderline(self , rsthis: & QTextCharFormat) -> i8 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK15QTextCharFormat13fontUnderlineEv()};
let mut ret = unsafe {C_ZNK15QTextCharFormat13fontUnderlineEv(rsthis.qclsinst)};
return ret as i8; // 1
// return 1;
}
}
// proto: void QTextCharFormat::setFontWordSpacing(qreal spacing);
impl /*struct*/ QTextCharFormat {
pub fn setFontWordSpacing<RetType, T: QTextCharFormat_setFontWordSpacing<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setFontWordSpacing(self);
// return 1;
}
}
pub trait QTextCharFormat_setFontWordSpacing<RetType> {
fn setFontWordSpacing(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: void QTextCharFormat::setFontWordSpacing(qreal spacing);
impl<'a> /*trait*/ QTextCharFormat_setFontWordSpacing<()> for (f64) {
fn setFontWordSpacing(self , rsthis: & QTextCharFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN15QTextCharFormat18setFontWordSpacingEd()};
let arg0 = self as c_double;
unsafe {C_ZN15QTextCharFormat18setFontWordSpacingEd(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: QColor QTextCharFormat::underlineColor();
impl /*struct*/ QTextCharFormat {
pub fn underlineColor<RetType, T: QTextCharFormat_underlineColor<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.underlineColor(self);
// return 1;
}
}
pub trait QTextCharFormat_underlineColor<RetType> {
fn underlineColor(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: QColor QTextCharFormat::underlineColor();
impl<'a> /*trait*/ QTextCharFormat_underlineColor<QColor> for () {
fn underlineColor(self , rsthis: & QTextCharFormat) -> QColor {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK15QTextCharFormat14underlineColorEv()};
let mut ret = unsafe {C_ZNK15QTextCharFormat14underlineColorEv(rsthis.qclsinst)};
let mut ret1 = QColor::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: int QTextCharFormat::fontWeight();
impl /*struct*/ QTextCharFormat {
pub fn fontWeight<RetType, T: QTextCharFormat_fontWeight<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.fontWeight(self);
// return 1;
}
}
pub trait QTextCharFormat_fontWeight<RetType> {
fn fontWeight(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: int QTextCharFormat::fontWeight();
impl<'a> /*trait*/ QTextCharFormat_fontWeight<i32> for () {
fn fontWeight(self , rsthis: & QTextCharFormat) -> i32 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK15QTextCharFormat10fontWeightEv()};
let mut ret = unsafe {C_ZNK15QTextCharFormat10fontWeightEv(rsthis.qclsinst)};
return ret as i32; // 1
// return 1;
}
}
// proto: void QTextCharFormat::setFontOverline(bool overline);
impl /*struct*/ QTextCharFormat {
pub fn setFontOverline<RetType, T: QTextCharFormat_setFontOverline<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setFontOverline(self);
// return 1;
}
}
pub trait QTextCharFormat_setFontOverline<RetType> {
fn setFontOverline(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: void QTextCharFormat::setFontOverline(bool overline);
impl<'a> /*trait*/ QTextCharFormat_setFontOverline<()> for (i8) {
fn setFontOverline(self , rsthis: & QTextCharFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN15QTextCharFormat15setFontOverlineEb()};
let arg0 = self as c_char;
unsafe {C_ZN15QTextCharFormat15setFontOverlineEb(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: void QTextCharFormat::setTableCellColumnSpan(int tableCellColumnSpan);
impl /*struct*/ QTextCharFormat {
pub fn setTableCellColumnSpan<RetType, T: QTextCharFormat_setTableCellColumnSpan<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setTableCellColumnSpan(self);
// return 1;
}
}
pub trait QTextCharFormat_setTableCellColumnSpan<RetType> {
fn setTableCellColumnSpan(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: void QTextCharFormat::setTableCellColumnSpan(int tableCellColumnSpan);
impl<'a> /*trait*/ QTextCharFormat_setTableCellColumnSpan<()> for (i32) {
fn setTableCellColumnSpan(self , rsthis: & QTextCharFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN15QTextCharFormat22setTableCellColumnSpanEi()};
let arg0 = self as c_int;
unsafe {C_ZN15QTextCharFormat22setTableCellColumnSpanEi(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: QPen QTextCharFormat::textOutline();
impl /*struct*/ QTextCharFormat {
pub fn textOutline<RetType, T: QTextCharFormat_textOutline<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.textOutline(self);
// return 1;
}
}
pub trait QTextCharFormat_textOutline<RetType> {
fn textOutline(self , rsthis: & QTextCharFormat) -> RetType;
}
// proto: QPen QTextCharFormat::textOutline();
impl<'a> /*trait*/ QTextCharFormat_textOutline<QPen> for () {
fn textOutline(self , rsthis: & QTextCharFormat) -> QPen {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK15QTextCharFormat11textOutlineEv()};
let mut ret = unsafe {C_ZNK15QTextCharFormat11textOutlineEv(rsthis.qclsinst)};
let mut ret1 = QPen::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
impl /*struct*/ QTextTableFormat {
pub fn inheritFrom(qthis: u64 /* *mut c_void*/) -> QTextTableFormat {
return QTextTableFormat{qbase: QTextFrameFormat::inheritFrom(qthis), qclsinst: qthis, ..Default::default()};
}
}
impl Deref for QTextTableFormat {
type Target = QTextFrameFormat;
fn deref(&self) -> &QTextFrameFormat {
return & self.qbase;
}
}
impl AsRef<QTextFrameFormat> for QTextTableFormat {
fn as_ref(& self) -> & QTextFrameFormat {
return & self.qbase;
}
}
// proto: void QTextTableFormat::QTextTableFormat();
impl /*struct*/ QTextTableFormat {
pub fn new<T: QTextTableFormat_new>(value: T) -> QTextTableFormat {
let rsthis = value.new();
return rsthis;
// return 1;
}
}
pub trait QTextTableFormat_new {
fn new(self) -> QTextTableFormat;
}
// proto: void QTextTableFormat::QTextTableFormat();
impl<'a> /*trait*/ QTextTableFormat_new for () {
fn new(self) -> QTextTableFormat {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN16QTextTableFormatC2Ev()};
let ctysz: c_int = unsafe{QTextTableFormat_Class_Size()};
let qthis_ph: u64 = unsafe{calloc(1, ctysz as usize)} as u64;
let qthis: u64 = unsafe {C_ZN16QTextTableFormatC2Ev()};
let rsthis = QTextTableFormat{qbase: QTextFrameFormat::inheritFrom(qthis), qclsinst: qthis, ..Default::default()};
return rsthis;
// return 1;
}
}
// proto: bool QTextTableFormat::isValid();
impl /*struct*/ QTextTableFormat {
pub fn isValid<RetType, T: QTextTableFormat_isValid<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.isValid(self);
// return 1;
}
}
pub trait QTextTableFormat_isValid<RetType> {
fn isValid(self , rsthis: & QTextTableFormat) -> RetType;
}
// proto: bool QTextTableFormat::isValid();
impl<'a> /*trait*/ QTextTableFormat_isValid<i8> for () {
fn isValid(self , rsthis: & QTextTableFormat) -> i8 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK16QTextTableFormat7isValidEv()};
let mut ret = unsafe {C_ZNK16QTextTableFormat7isValidEv(rsthis.qclsinst)};
return ret as i8; // 1
// return 1;
}
}
// proto: int QTextTableFormat::headerRowCount();
impl /*struct*/ QTextTableFormat {
pub fn headerRowCount<RetType, T: QTextTableFormat_headerRowCount<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.headerRowCount(self);
// return 1;
}
}
pub trait QTextTableFormat_headerRowCount<RetType> {
fn headerRowCount(self , rsthis: & QTextTableFormat) -> RetType;
}
// proto: int QTextTableFormat::headerRowCount();
impl<'a> /*trait*/ QTextTableFormat_headerRowCount<i32> for () {
fn headerRowCount(self , rsthis: & QTextTableFormat) -> i32 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK16QTextTableFormat14headerRowCountEv()};
let mut ret = unsafe {C_ZNK16QTextTableFormat14headerRowCountEv(rsthis.qclsinst)};
return ret as i32; // 1
// return 1;
}
}
// proto: int QTextTableFormat::columns();
impl /*struct*/ QTextTableFormat {
pub fn columns<RetType, T: QTextTableFormat_columns<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.columns(self);
// return 1;
}
}
pub trait QTextTableFormat_columns<RetType> {
fn columns(self , rsthis: & QTextTableFormat) -> RetType;
}
// proto: int QTextTableFormat::columns();
impl<'a> /*trait*/ QTextTableFormat_columns<i32> for () {
fn columns(self , rsthis: & QTextTableFormat) -> i32 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK16QTextTableFormat7columnsEv()};
let mut ret = unsafe {C_ZNK16QTextTableFormat7columnsEv(rsthis.qclsinst)};
return ret as i32; // 1
// return 1;
}
}
// proto: QVector<QTextLength> QTextTableFormat::columnWidthConstraints();
impl /*struct*/ QTextTableFormat {
pub fn columnWidthConstraints<RetType, T: QTextTableFormat_columnWidthConstraints<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.columnWidthConstraints(self);
// return 1;
}
}
pub trait QTextTableFormat_columnWidthConstraints<RetType> {
fn columnWidthConstraints(self , rsthis: & QTextTableFormat) -> RetType;
}
// proto: QVector<QTextLength> QTextTableFormat::columnWidthConstraints();
impl<'a> /*trait*/ QTextTableFormat_columnWidthConstraints<u64> for () {
fn columnWidthConstraints(self , rsthis: & QTextTableFormat) -> u64 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK16QTextTableFormat22columnWidthConstraintsEv()};
let mut ret = unsafe {C_ZNK16QTextTableFormat22columnWidthConstraintsEv(rsthis.qclsinst)};
return ret as u64; // 5
// return 1;
}
}
// proto: void QTextTableFormat::setCellPadding(qreal padding);
impl /*struct*/ QTextTableFormat {
pub fn setCellPadding<RetType, T: QTextTableFormat_setCellPadding<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setCellPadding(self);
// return 1;
}
}
pub trait QTextTableFormat_setCellPadding<RetType> {
fn setCellPadding(self , rsthis: & QTextTableFormat) -> RetType;
}
// proto: void QTextTableFormat::setCellPadding(qreal padding);
impl<'a> /*trait*/ QTextTableFormat_setCellPadding<()> for (f64) {
fn setCellPadding(self , rsthis: & QTextTableFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN16QTextTableFormat14setCellPaddingEd()};
let arg0 = self as c_double;
unsafe {C_ZN16QTextTableFormat14setCellPaddingEd(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: qreal QTextTableFormat::cellPadding();
impl /*struct*/ QTextTableFormat {
pub fn cellPadding<RetType, T: QTextTableFormat_cellPadding<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.cellPadding(self);
// return 1;
}
}
pub trait QTextTableFormat_cellPadding<RetType> {
fn cellPadding(self , rsthis: & QTextTableFormat) -> RetType;
}
// proto: qreal QTextTableFormat::cellPadding();
impl<'a> /*trait*/ QTextTableFormat_cellPadding<f64> for () {
fn cellPadding(self , rsthis: & QTextTableFormat) -> f64 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK16QTextTableFormat11cellPaddingEv()};
let mut ret = unsafe {C_ZNK16QTextTableFormat11cellPaddingEv(rsthis.qclsinst)};
return ret as f64; // 1
// return 1;
}
}
// proto: void QTextTableFormat::setCellSpacing(qreal spacing);
impl /*struct*/ QTextTableFormat {
pub fn setCellSpacing<RetType, T: QTextTableFormat_setCellSpacing<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setCellSpacing(self);
// return 1;
}
}
pub trait QTextTableFormat_setCellSpacing<RetType> {
fn setCellSpacing(self , rsthis: & QTextTableFormat) -> RetType;
}
// proto: void QTextTableFormat::setCellSpacing(qreal spacing);
impl<'a> /*trait*/ QTextTableFormat_setCellSpacing<()> for (f64) {
fn setCellSpacing(self , rsthis: & QTextTableFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN16QTextTableFormat14setCellSpacingEd()};
let arg0 = self as c_double;
unsafe {C_ZN16QTextTableFormat14setCellSpacingEd(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: void QTextTableFormat::setColumns(int columns);
impl /*struct*/ QTextTableFormat {
pub fn setColumns<RetType, T: QTextTableFormat_setColumns<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setColumns(self);
// return 1;
}
}
pub trait QTextTableFormat_setColumns<RetType> {
fn setColumns(self , rsthis: & QTextTableFormat) -> RetType;
}
// proto: void QTextTableFormat::setColumns(int columns);
impl<'a> /*trait*/ QTextTableFormat_setColumns<()> for (i32) {
fn setColumns(self , rsthis: & QTextTableFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN16QTextTableFormat10setColumnsEi()};
let arg0 = self as c_int;
unsafe {C_ZN16QTextTableFormat10setColumnsEi(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: void QTextTableFormat::clearColumnWidthConstraints();
impl /*struct*/ QTextTableFormat {
pub fn clearColumnWidthConstraints<RetType, T: QTextTableFormat_clearColumnWidthConstraints<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.clearColumnWidthConstraints(self);
// return 1;
}
}
pub trait QTextTableFormat_clearColumnWidthConstraints<RetType> {
fn clearColumnWidthConstraints(self , rsthis: & QTextTableFormat) -> RetType;
}
// proto: void QTextTableFormat::clearColumnWidthConstraints();
impl<'a> /*trait*/ QTextTableFormat_clearColumnWidthConstraints<()> for () {
fn clearColumnWidthConstraints(self , rsthis: & QTextTableFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN16QTextTableFormat27clearColumnWidthConstraintsEv()};
unsafe {C_ZN16QTextTableFormat27clearColumnWidthConstraintsEv(rsthis.qclsinst)};
// return 1;
}
}
// proto: void QTextTableFormat::setHeaderRowCount(int count);
impl /*struct*/ QTextTableFormat {
pub fn setHeaderRowCount<RetType, T: QTextTableFormat_setHeaderRowCount<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setHeaderRowCount(self);
// return 1;
}
}
pub trait QTextTableFormat_setHeaderRowCount<RetType> {
fn setHeaderRowCount(self , rsthis: & QTextTableFormat) -> RetType;
}
// proto: void QTextTableFormat::setHeaderRowCount(int count);
impl<'a> /*trait*/ QTextTableFormat_setHeaderRowCount<()> for (i32) {
fn setHeaderRowCount(self , rsthis: & QTextTableFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN16QTextTableFormat17setHeaderRowCountEi()};
let arg0 = self as c_int;
unsafe {C_ZN16QTextTableFormat17setHeaderRowCountEi(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: qreal QTextTableFormat::cellSpacing();
impl /*struct*/ QTextTableFormat {
pub fn cellSpacing<RetType, T: QTextTableFormat_cellSpacing<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.cellSpacing(self);
// return 1;
}
}
pub trait QTextTableFormat_cellSpacing<RetType> {
fn cellSpacing(self , rsthis: & QTextTableFormat) -> RetType;
}
// proto: qreal QTextTableFormat::cellSpacing();
impl<'a> /*trait*/ QTextTableFormat_cellSpacing<f64> for () {
fn cellSpacing(self , rsthis: & QTextTableFormat) -> f64 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK16QTextTableFormat11cellSpacingEv()};
let mut ret = unsafe {C_ZNK16QTextTableFormat11cellSpacingEv(rsthis.qclsinst)};
return ret as f64; // 1
// return 1;
}
}
impl /*struct*/ QTextTableCellFormat {
pub fn inheritFrom(qthis: u64 /* *mut c_void*/) -> QTextTableCellFormat {
return QTextTableCellFormat{qbase: QTextCharFormat::inheritFrom(qthis), qclsinst: qthis, ..Default::default()};
}
}
impl Deref for QTextTableCellFormat {
type Target = QTextCharFormat;
fn deref(&self) -> &QTextCharFormat {
return & self.qbase;
}
}
impl AsRef<QTextCharFormat> for QTextTableCellFormat {
fn as_ref(& self) -> & QTextCharFormat {
return & self.qbase;
}
}
// proto: void QTextTableCellFormat::QTextTableCellFormat();
impl /*struct*/ QTextTableCellFormat {
pub fn new<T: QTextTableCellFormat_new>(value: T) -> QTextTableCellFormat {
let rsthis = value.new();
return rsthis;
// return 1;
}
}
pub trait QTextTableCellFormat_new {
fn new(self) -> QTextTableCellFormat;
}
// proto: void QTextTableCellFormat::QTextTableCellFormat();
impl<'a> /*trait*/ QTextTableCellFormat_new for () {
fn new(self) -> QTextTableCellFormat {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN20QTextTableCellFormatC2Ev()};
let ctysz: c_int = unsafe{QTextTableCellFormat_Class_Size()};
let qthis_ph: u64 = unsafe{calloc(1, ctysz as usize)} as u64;
let qthis: u64 = unsafe {C_ZN20QTextTableCellFormatC2Ev()};
let rsthis = QTextTableCellFormat{qbase: QTextCharFormat::inheritFrom(qthis), qclsinst: qthis, ..Default::default()};
return rsthis;
// return 1;
}
}
// proto: void QTextTableCellFormat::setLeftPadding(qreal padding);
impl /*struct*/ QTextTableCellFormat {
pub fn setLeftPadding<RetType, T: QTextTableCellFormat_setLeftPadding<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setLeftPadding(self);
// return 1;
}
}
pub trait QTextTableCellFormat_setLeftPadding<RetType> {
fn setLeftPadding(self , rsthis: & QTextTableCellFormat) -> RetType;
}
// proto: void QTextTableCellFormat::setLeftPadding(qreal padding);
impl<'a> /*trait*/ QTextTableCellFormat_setLeftPadding<()> for (f64) {
fn setLeftPadding(self , rsthis: & QTextTableCellFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN20QTextTableCellFormat14setLeftPaddingEd()};
let arg0 = self as c_double;
unsafe {C_ZN20QTextTableCellFormat14setLeftPaddingEd(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: bool QTextTableCellFormat::isValid();
impl /*struct*/ QTextTableCellFormat {
pub fn isValid<RetType, T: QTextTableCellFormat_isValid<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.isValid(self);
// return 1;
}
}
pub trait QTextTableCellFormat_isValid<RetType> {
fn isValid(self , rsthis: & QTextTableCellFormat) -> RetType;
}
// proto: bool QTextTableCellFormat::isValid();
impl<'a> /*trait*/ QTextTableCellFormat_isValid<i8> for () {
fn isValid(self , rsthis: & QTextTableCellFormat) -> i8 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK20QTextTableCellFormat7isValidEv()};
let mut ret = unsafe {C_ZNK20QTextTableCellFormat7isValidEv(rsthis.qclsinst)};
return ret as i8; // 1
// return 1;
}
}
// proto: void QTextTableCellFormat::setTopPadding(qreal padding);
impl /*struct*/ QTextTableCellFormat {
pub fn setTopPadding<RetType, T: QTextTableCellFormat_setTopPadding<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setTopPadding(self);
// return 1;
}
}
pub trait QTextTableCellFormat_setTopPadding<RetType> {
fn setTopPadding(self , rsthis: & QTextTableCellFormat) -> RetType;
}
// proto: void QTextTableCellFormat::setTopPadding(qreal padding);
impl<'a> /*trait*/ QTextTableCellFormat_setTopPadding<()> for (f64) {
fn setTopPadding(self , rsthis: & QTextTableCellFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN20QTextTableCellFormat13setTopPaddingEd()};
let arg0 = self as c_double;
unsafe {C_ZN20QTextTableCellFormat13setTopPaddingEd(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: qreal QTextTableCellFormat::leftPadding();
impl /*struct*/ QTextTableCellFormat {
pub fn leftPadding<RetType, T: QTextTableCellFormat_leftPadding<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.leftPadding(self);
// return 1;
}
}
pub trait QTextTableCellFormat_leftPadding<RetType> {
fn leftPadding(self , rsthis: & QTextTableCellFormat) -> RetType;
}
// proto: qreal QTextTableCellFormat::leftPadding();
impl<'a> /*trait*/ QTextTableCellFormat_leftPadding<f64> for () {
fn leftPadding(self , rsthis: & QTextTableCellFormat) -> f64 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK20QTextTableCellFormat11leftPaddingEv()};
let mut ret = unsafe {C_ZNK20QTextTableCellFormat11leftPaddingEv(rsthis.qclsinst)};
return ret as f64; // 1
// return 1;
}
}
// proto: void QTextTableCellFormat::setPadding(qreal padding);
impl /*struct*/ QTextTableCellFormat {
pub fn setPadding<RetType, T: QTextTableCellFormat_setPadding<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setPadding(self);
// return 1;
}
}
pub trait QTextTableCellFormat_setPadding<RetType> {
fn setPadding(self , rsthis: & QTextTableCellFormat) -> RetType;
}
// proto: void QTextTableCellFormat::setPadding(qreal padding);
impl<'a> /*trait*/ QTextTableCellFormat_setPadding<()> for (f64) {
fn setPadding(self , rsthis: & QTextTableCellFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN20QTextTableCellFormat10setPaddingEd()};
let arg0 = self as c_double;
unsafe {C_ZN20QTextTableCellFormat10setPaddingEd(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: qreal QTextTableCellFormat::topPadding();
impl /*struct*/ QTextTableCellFormat {
pub fn topPadding<RetType, T: QTextTableCellFormat_topPadding<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.topPadding(self);
// return 1;
}
}
pub trait QTextTableCellFormat_topPadding<RetType> {
fn topPadding(self , rsthis: & QTextTableCellFormat) -> RetType;
}
// proto: qreal QTextTableCellFormat::topPadding();
impl<'a> /*trait*/ QTextTableCellFormat_topPadding<f64> for () {
fn topPadding(self , rsthis: & QTextTableCellFormat) -> f64 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK20QTextTableCellFormat10topPaddingEv()};
let mut ret = unsafe {C_ZNK20QTextTableCellFormat10topPaddingEv(rsthis.qclsinst)};
return ret as f64; // 1
// return 1;
}
}
// proto: qreal QTextTableCellFormat::rightPadding();
impl /*struct*/ QTextTableCellFormat {
pub fn rightPadding<RetType, T: QTextTableCellFormat_rightPadding<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.rightPadding(self);
// return 1;
}
}
pub trait QTextTableCellFormat_rightPadding<RetType> {
fn rightPadding(self , rsthis: & QTextTableCellFormat) -> RetType;
}
// proto: qreal QTextTableCellFormat::rightPadding();
impl<'a> /*trait*/ QTextTableCellFormat_rightPadding<f64> for () {
fn rightPadding(self , rsthis: & QTextTableCellFormat) -> f64 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK20QTextTableCellFormat12rightPaddingEv()};
let mut ret = unsafe {C_ZNK20QTextTableCellFormat12rightPaddingEv(rsthis.qclsinst)};
return ret as f64; // 1
// return 1;
}
}
// proto: qreal QTextTableCellFormat::bottomPadding();
impl /*struct*/ QTextTableCellFormat {
pub fn bottomPadding<RetType, T: QTextTableCellFormat_bottomPadding<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.bottomPadding(self);
// return 1;
}
}
pub trait QTextTableCellFormat_bottomPadding<RetType> {
fn bottomPadding(self , rsthis: & QTextTableCellFormat) -> RetType;
}
// proto: qreal QTextTableCellFormat::bottomPadding();
impl<'a> /*trait*/ QTextTableCellFormat_bottomPadding<f64> for () {
fn bottomPadding(self , rsthis: & QTextTableCellFormat) -> f64 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK20QTextTableCellFormat13bottomPaddingEv()};
let mut ret = unsafe {C_ZNK20QTextTableCellFormat13bottomPaddingEv(rsthis.qclsinst)};
return ret as f64; // 1
// return 1;
}
}
// proto: void QTextTableCellFormat::setRightPadding(qreal padding);
impl /*struct*/ QTextTableCellFormat {
pub fn setRightPadding<RetType, T: QTextTableCellFormat_setRightPadding<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setRightPadding(self);
// return 1;
}
}
pub trait QTextTableCellFormat_setRightPadding<RetType> {
fn setRightPadding(self , rsthis: & QTextTableCellFormat) -> RetType;
}
// proto: void QTextTableCellFormat::setRightPadding(qreal padding);
impl<'a> /*trait*/ QTextTableCellFormat_setRightPadding<()> for (f64) {
fn setRightPadding(self , rsthis: & QTextTableCellFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN20QTextTableCellFormat15setRightPaddingEd()};
let arg0 = self as c_double;
unsafe {C_ZN20QTextTableCellFormat15setRightPaddingEd(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: void QTextTableCellFormat::setBottomPadding(qreal padding);
impl /*struct*/ QTextTableCellFormat {
pub fn setBottomPadding<RetType, T: QTextTableCellFormat_setBottomPadding<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setBottomPadding(self);
// return 1;
}
}
pub trait QTextTableCellFormat_setBottomPadding<RetType> {
fn setBottomPadding(self , rsthis: & QTextTableCellFormat) -> RetType;
}
// proto: void QTextTableCellFormat::setBottomPadding(qreal padding);
impl<'a> /*trait*/ QTextTableCellFormat_setBottomPadding<()> for (f64) {
fn setBottomPadding(self , rsthis: & QTextTableCellFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN20QTextTableCellFormat16setBottomPaddingEd()};
let arg0 = self as c_double;
unsafe {C_ZN20QTextTableCellFormat16setBottomPaddingEd(rsthis.qclsinst, arg0)};
// return 1;
}
}
impl /*struct*/ QTextListFormat {
pub fn inheritFrom(qthis: u64 /* *mut c_void*/) -> QTextListFormat {
return QTextListFormat{qbase: QTextFormat::inheritFrom(qthis), qclsinst: qthis, ..Default::default()};
}
}
impl Deref for QTextListFormat {
type Target = QTextFormat;
fn deref(&self) -> &QTextFormat {
return & self.qbase;
}
}
impl AsRef<QTextFormat> for QTextListFormat {
fn as_ref(& self) -> & QTextFormat {
return & self.qbase;
}
}
// proto: int QTextListFormat::indent();
impl /*struct*/ QTextListFormat {
pub fn indent<RetType, T: QTextListFormat_indent<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.indent(self);
// return 1;
}
}
pub trait QTextListFormat_indent<RetType> {
fn indent(self , rsthis: & QTextListFormat) -> RetType;
}
// proto: int QTextListFormat::indent();
impl<'a> /*trait*/ QTextListFormat_indent<i32> for () {
fn indent(self , rsthis: & QTextListFormat) -> i32 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK15QTextListFormat6indentEv()};
let mut ret = unsafe {C_ZNK15QTextListFormat6indentEv(rsthis.qclsinst)};
return ret as i32; // 1
// return 1;
}
}
// proto: void QTextListFormat::setIndent(int indent);
impl /*struct*/ QTextListFormat {
pub fn setIndent<RetType, T: QTextListFormat_setIndent<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setIndent(self);
// return 1;
}
}
pub trait QTextListFormat_setIndent<RetType> {
fn setIndent(self , rsthis: & QTextListFormat) -> RetType;
}
// proto: void QTextListFormat::setIndent(int indent);
impl<'a> /*trait*/ QTextListFormat_setIndent<()> for (i32) {
fn setIndent(self , rsthis: & QTextListFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN15QTextListFormat9setIndentEi()};
let arg0 = self as c_int;
unsafe {C_ZN15QTextListFormat9setIndentEi(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: QString QTextListFormat::numberSuffix();
impl /*struct*/ QTextListFormat {
pub fn numberSuffix<RetType, T: QTextListFormat_numberSuffix<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.numberSuffix(self);
// return 1;
}
}
pub trait QTextListFormat_numberSuffix<RetType> {
fn numberSuffix(self , rsthis: & QTextListFormat) -> RetType;
}
// proto: QString QTextListFormat::numberSuffix();
impl<'a> /*trait*/ QTextListFormat_numberSuffix<QString> for () {
fn numberSuffix(self , rsthis: & QTextListFormat) -> QString {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK15QTextListFormat12numberSuffixEv()};
let mut ret = unsafe {C_ZNK15QTextListFormat12numberSuffixEv(rsthis.qclsinst)};
let mut ret1 = QString::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: void QTextListFormat::QTextListFormat();
impl /*struct*/ QTextListFormat {
pub fn new<T: QTextListFormat_new>(value: T) -> QTextListFormat {
let rsthis = value.new();
return rsthis;
// return 1;
}
}
pub trait QTextListFormat_new {
fn new(self) -> QTextListFormat;
}
// proto: void QTextListFormat::QTextListFormat();
impl<'a> /*trait*/ QTextListFormat_new for () {
fn new(self) -> QTextListFormat {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN15QTextListFormatC2Ev()};
let ctysz: c_int = unsafe{QTextListFormat_Class_Size()};
let qthis_ph: u64 = unsafe{calloc(1, ctysz as usize)} as u64;
let qthis: u64 = unsafe {C_ZN15QTextListFormatC2Ev()};
let rsthis = QTextListFormat{qbase: QTextFormat::inheritFrom(qthis), qclsinst: qthis, ..Default::default()};
return rsthis;
// return 1;
}
}
// proto: QString QTextListFormat::numberPrefix();
impl /*struct*/ QTextListFormat {
pub fn numberPrefix<RetType, T: QTextListFormat_numberPrefix<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.numberPrefix(self);
// return 1;
}
}
pub trait QTextListFormat_numberPrefix<RetType> {
fn numberPrefix(self , rsthis: & QTextListFormat) -> RetType;
}
// proto: QString QTextListFormat::numberPrefix();
impl<'a> /*trait*/ QTextListFormat_numberPrefix<QString> for () {
fn numberPrefix(self , rsthis: & QTextListFormat) -> QString {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK15QTextListFormat12numberPrefixEv()};
let mut ret = unsafe {C_ZNK15QTextListFormat12numberPrefixEv(rsthis.qclsinst)};
let mut ret1 = QString::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: bool QTextListFormat::isValid();
impl /*struct*/ QTextListFormat {
pub fn isValid<RetType, T: QTextListFormat_isValid<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.isValid(self);
// return 1;
}
}
pub trait QTextListFormat_isValid<RetType> {
fn isValid(self , rsthis: & QTextListFormat) -> RetType;
}
// proto: bool QTextListFormat::isValid();
impl<'a> /*trait*/ QTextListFormat_isValid<i8> for () {
fn isValid(self , rsthis: & QTextListFormat) -> i8 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK15QTextListFormat7isValidEv()};
let mut ret = unsafe {C_ZNK15QTextListFormat7isValidEv(rsthis.qclsinst)};
return ret as i8; // 1
// return 1;
}
}
// proto: void QTextListFormat::setNumberSuffix(const QString & numberSuffix);
impl /*struct*/ QTextListFormat {
pub fn setNumberSuffix<RetType, T: QTextListFormat_setNumberSuffix<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setNumberSuffix(self);
// return 1;
}
}
pub trait QTextListFormat_setNumberSuffix<RetType> {
fn setNumberSuffix(self , rsthis: & QTextListFormat) -> RetType;
}
// proto: void QTextListFormat::setNumberSuffix(const QString & numberSuffix);
impl<'a> /*trait*/ QTextListFormat_setNumberSuffix<()> for (&'a QString) {
fn setNumberSuffix(self , rsthis: & QTextListFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN15QTextListFormat15setNumberSuffixERK7QString()};
let arg0 = self.qclsinst as *mut c_void;
unsafe {C_ZN15QTextListFormat15setNumberSuffixERK7QString(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: void QTextListFormat::setNumberPrefix(const QString & numberPrefix);
impl /*struct*/ QTextListFormat {
pub fn setNumberPrefix<RetType, T: QTextListFormat_setNumberPrefix<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setNumberPrefix(self);
// return 1;
}
}
pub trait QTextListFormat_setNumberPrefix<RetType> {
fn setNumberPrefix(self , rsthis: & QTextListFormat) -> RetType;
}
// proto: void QTextListFormat::setNumberPrefix(const QString & numberPrefix);
impl<'a> /*trait*/ QTextListFormat_setNumberPrefix<()> for (&'a QString) {
fn setNumberPrefix(self , rsthis: & QTextListFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN15QTextListFormat15setNumberPrefixERK7QString()};
let arg0 = self.qclsinst as *mut c_void;
unsafe {C_ZN15QTextListFormat15setNumberPrefixERK7QString(rsthis.qclsinst, arg0)};
// return 1;
}
}
impl /*struct*/ QTextFrameFormat {
pub fn inheritFrom(qthis: u64 /* *mut c_void*/) -> QTextFrameFormat {
return QTextFrameFormat{qbase: QTextFormat::inheritFrom(qthis), qclsinst: qthis, ..Default::default()};
}
}
impl Deref for QTextFrameFormat {
type Target = QTextFormat;
fn deref(&self) -> &QTextFormat {
return & self.qbase;
}
}
impl AsRef<QTextFormat> for QTextFrameFormat {
fn as_ref(& self) -> & QTextFormat {
return & self.qbase;
}
}
// proto: bool QTextFrameFormat::isValid();
impl /*struct*/ QTextFrameFormat {
pub fn isValid<RetType, T: QTextFrameFormat_isValid<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.isValid(self);
// return 1;
}
}
pub trait QTextFrameFormat_isValid<RetType> {
fn isValid(self , rsthis: & QTextFrameFormat) -> RetType;
}
// proto: bool QTextFrameFormat::isValid();
impl<'a> /*trait*/ QTextFrameFormat_isValid<i8> for () {
fn isValid(self , rsthis: & QTextFrameFormat) -> i8 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK16QTextFrameFormat7isValidEv()};
let mut ret = unsafe {C_ZNK16QTextFrameFormat7isValidEv(rsthis.qclsinst)};
return ret as i8; // 1
// return 1;
}
}
// proto: void QTextFrameFormat::setHeight(qreal height);
impl /*struct*/ QTextFrameFormat {
pub fn setHeight<RetType, T: QTextFrameFormat_setHeight<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setHeight(self);
// return 1;
}
}
pub trait QTextFrameFormat_setHeight<RetType> {
fn setHeight(self , rsthis: & QTextFrameFormat) -> RetType;
}
// proto: void QTextFrameFormat::setHeight(qreal height);
impl<'a> /*trait*/ QTextFrameFormat_setHeight<()> for (f64) {
fn setHeight(self , rsthis: & QTextFrameFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN16QTextFrameFormat9setHeightEd()};
let arg0 = self as c_double;
unsafe {C_ZN16QTextFrameFormat9setHeightEd(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: void QTextFrameFormat::setBorderBrush(const QBrush & brush);
impl /*struct*/ QTextFrameFormat {
pub fn setBorderBrush<RetType, T: QTextFrameFormat_setBorderBrush<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setBorderBrush(self);
// return 1;
}
}
pub trait QTextFrameFormat_setBorderBrush<RetType> {
fn setBorderBrush(self , rsthis: & QTextFrameFormat) -> RetType;
}
// proto: void QTextFrameFormat::setBorderBrush(const QBrush & brush);
impl<'a> /*trait*/ QTextFrameFormat_setBorderBrush<()> for (&'a QBrush) {
fn setBorderBrush(self , rsthis: & QTextFrameFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN16QTextFrameFormat14setBorderBrushERK6QBrush()};
let arg0 = self.qclsinst as *mut c_void;
unsafe {C_ZN16QTextFrameFormat14setBorderBrushERK6QBrush(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: qreal QTextFrameFormat::margin();
impl /*struct*/ QTextFrameFormat {
pub fn margin<RetType, T: QTextFrameFormat_margin<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.margin(self);
// return 1;
}
}
pub trait QTextFrameFormat_margin<RetType> {
fn margin(self , rsthis: & QTextFrameFormat) -> RetType;
}
// proto: qreal QTextFrameFormat::margin();
impl<'a> /*trait*/ QTextFrameFormat_margin<f64> for () {
fn margin(self , rsthis: & QTextFrameFormat) -> f64 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK16QTextFrameFormat6marginEv()};
let mut ret = unsafe {C_ZNK16QTextFrameFormat6marginEv(rsthis.qclsinst)};
return ret as f64; // 1
// return 1;
}
}
// proto: QBrush QTextFrameFormat::borderBrush();
impl /*struct*/ QTextFrameFormat {
pub fn borderBrush<RetType, T: QTextFrameFormat_borderBrush<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.borderBrush(self);
// return 1;
}
}
pub trait QTextFrameFormat_borderBrush<RetType> {
fn borderBrush(self , rsthis: & QTextFrameFormat) -> RetType;
}
// proto: QBrush QTextFrameFormat::borderBrush();
impl<'a> /*trait*/ QTextFrameFormat_borderBrush<QBrush> for () {
fn borderBrush(self , rsthis: & QTextFrameFormat) -> QBrush {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK16QTextFrameFormat11borderBrushEv()};
let mut ret = unsafe {C_ZNK16QTextFrameFormat11borderBrushEv(rsthis.qclsinst)};
let mut ret1 = QBrush::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: void QTextFrameFormat::setRightMargin(qreal margin);
impl /*struct*/ QTextFrameFormat {
pub fn setRightMargin<RetType, T: QTextFrameFormat_setRightMargin<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setRightMargin(self);
// return 1;
}
}
pub trait QTextFrameFormat_setRightMargin<RetType> {
fn setRightMargin(self , rsthis: & QTextFrameFormat) -> RetType;
}
// proto: void QTextFrameFormat::setRightMargin(qreal margin);
impl<'a> /*trait*/ QTextFrameFormat_setRightMargin<()> for (f64) {
fn setRightMargin(self , rsthis: & QTextFrameFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN16QTextFrameFormat14setRightMarginEd()};
let arg0 = self as c_double;
unsafe {C_ZN16QTextFrameFormat14setRightMarginEd(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: void QTextFrameFormat::setMargin(qreal margin);
impl /*struct*/ QTextFrameFormat {
pub fn setMargin<RetType, T: QTextFrameFormat_setMargin<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setMargin(self);
// return 1;
}
}
pub trait QTextFrameFormat_setMargin<RetType> {
fn setMargin(self , rsthis: & QTextFrameFormat) -> RetType;
}
// proto: void QTextFrameFormat::setMargin(qreal margin);
impl<'a> /*trait*/ QTextFrameFormat_setMargin<()> for (f64) {
fn setMargin(self , rsthis: & QTextFrameFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN16QTextFrameFormat9setMarginEd()};
let arg0 = self as c_double;
unsafe {C_ZN16QTextFrameFormat9setMarginEd(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: void QTextFrameFormat::setBorder(qreal border);
impl /*struct*/ QTextFrameFormat {
pub fn setBorder<RetType, T: QTextFrameFormat_setBorder<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setBorder(self);
// return 1;
}
}
pub trait QTextFrameFormat_setBorder<RetType> {
fn setBorder(self , rsthis: & QTextFrameFormat) -> RetType;
}
// proto: void QTextFrameFormat::setBorder(qreal border);
impl<'a> /*trait*/ QTextFrameFormat_setBorder<()> for (f64) {
fn setBorder(self , rsthis: & QTextFrameFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN16QTextFrameFormat9setBorderEd()};
let arg0 = self as c_double;
unsafe {C_ZN16QTextFrameFormat9setBorderEd(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: void QTextFrameFormat::setHeight(const QTextLength & height);
impl<'a> /*trait*/ QTextFrameFormat_setHeight<()> for (&'a QTextLength) {
fn setHeight(self , rsthis: & QTextFrameFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN16QTextFrameFormat9setHeightERK11QTextLength()};
let arg0 = self.qclsinst as *mut c_void;
unsafe {C_ZN16QTextFrameFormat9setHeightERK11QTextLength(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: void QTextFrameFormat::setWidth(const QTextLength & length);
impl /*struct*/ QTextFrameFormat {
pub fn setWidth<RetType, T: QTextFrameFormat_setWidth<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setWidth(self);
// return 1;
}
}
pub trait QTextFrameFormat_setWidth<RetType> {
fn setWidth(self , rsthis: & QTextFrameFormat) -> RetType;
}
// proto: void QTextFrameFormat::setWidth(const QTextLength & length);
impl<'a> /*trait*/ QTextFrameFormat_setWidth<()> for (&'a QTextLength) {
fn setWidth(self , rsthis: & QTextFrameFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN16QTextFrameFormat8setWidthERK11QTextLength()};
let arg0 = self.qclsinst as *mut c_void;
unsafe {C_ZN16QTextFrameFormat8setWidthERK11QTextLength(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: qreal QTextFrameFormat::bottomMargin();
impl /*struct*/ QTextFrameFormat {
pub fn bottomMargin<RetType, T: QTextFrameFormat_bottomMargin<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.bottomMargin(self);
// return 1;
}
}
pub trait QTextFrameFormat_bottomMargin<RetType> {
fn bottomMargin(self , rsthis: & QTextFrameFormat) -> RetType;
}
// proto: qreal QTextFrameFormat::bottomMargin();
impl<'a> /*trait*/ QTextFrameFormat_bottomMargin<f64> for () {
fn bottomMargin(self , rsthis: & QTextFrameFormat) -> f64 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK16QTextFrameFormat12bottomMarginEv()};
let mut ret = unsafe {C_ZNK16QTextFrameFormat12bottomMarginEv(rsthis.qclsinst)};
return ret as f64; // 1
// return 1;
}
}
// proto: void QTextFrameFormat::setBottomMargin(qreal margin);
impl /*struct*/ QTextFrameFormat {
pub fn setBottomMargin<RetType, T: QTextFrameFormat_setBottomMargin<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setBottomMargin(self);
// return 1;
}
}
pub trait QTextFrameFormat_setBottomMargin<RetType> {
fn setBottomMargin(self , rsthis: & QTextFrameFormat) -> RetType;
}
// proto: void QTextFrameFormat::setBottomMargin(qreal margin);
impl<'a> /*trait*/ QTextFrameFormat_setBottomMargin<()> for (f64) {
fn setBottomMargin(self , rsthis: & QTextFrameFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN16QTextFrameFormat15setBottomMarginEd()};
let arg0 = self as c_double;
unsafe {C_ZN16QTextFrameFormat15setBottomMarginEd(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: QTextLength QTextFrameFormat::height();
impl /*struct*/ QTextFrameFormat {
pub fn height<RetType, T: QTextFrameFormat_height<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.height(self);
// return 1;
}
}
pub trait QTextFrameFormat_height<RetType> {
fn height(self , rsthis: & QTextFrameFormat) -> RetType;
}
// proto: QTextLength QTextFrameFormat::height();
impl<'a> /*trait*/ QTextFrameFormat_height<QTextLength> for () {
fn height(self , rsthis: & QTextFrameFormat) -> QTextLength {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK16QTextFrameFormat6heightEv()};
let mut ret = unsafe {C_ZNK16QTextFrameFormat6heightEv(rsthis.qclsinst)};
let mut ret1 = QTextLength::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: void QTextFrameFormat::setWidth(qreal width);
impl<'a> /*trait*/ QTextFrameFormat_setWidth<()> for (f64) {
fn setWidth(self , rsthis: & QTextFrameFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN16QTextFrameFormat8setWidthEd()};
let arg0 = self as c_double;
unsafe {C_ZN16QTextFrameFormat8setWidthEd(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: qreal QTextFrameFormat::rightMargin();
impl /*struct*/ QTextFrameFormat {
pub fn rightMargin<RetType, T: QTextFrameFormat_rightMargin<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.rightMargin(self);
// return 1;
}
}
pub trait QTextFrameFormat_rightMargin<RetType> {
fn rightMargin(self , rsthis: & QTextFrameFormat) -> RetType;
}
// proto: qreal QTextFrameFormat::rightMargin();
impl<'a> /*trait*/ QTextFrameFormat_rightMargin<f64> for () {
fn rightMargin(self , rsthis: & QTextFrameFormat) -> f64 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK16QTextFrameFormat11rightMarginEv()};
let mut ret = unsafe {C_ZNK16QTextFrameFormat11rightMarginEv(rsthis.qclsinst)};
return ret as f64; // 1
// return 1;
}
}
// proto: void QTextFrameFormat::setPadding(qreal padding);
impl /*struct*/ QTextFrameFormat {
pub fn setPadding<RetType, T: QTextFrameFormat_setPadding<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setPadding(self);
// return 1;
}
}
pub trait QTextFrameFormat_setPadding<RetType> {
fn setPadding(self , rsthis: & QTextFrameFormat) -> RetType;
}
// proto: void QTextFrameFormat::setPadding(qreal padding);
impl<'a> /*trait*/ QTextFrameFormat_setPadding<()> for (f64) {
fn setPadding(self , rsthis: & QTextFrameFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN16QTextFrameFormat10setPaddingEd()};
let arg0 = self as c_double;
unsafe {C_ZN16QTextFrameFormat10setPaddingEd(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: void QTextFrameFormat::setTopMargin(qreal margin);
impl /*struct*/ QTextFrameFormat {
pub fn setTopMargin<RetType, T: QTextFrameFormat_setTopMargin<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setTopMargin(self);
// return 1;
}
}
pub trait QTextFrameFormat_setTopMargin<RetType> {
fn setTopMargin(self , rsthis: & QTextFrameFormat) -> RetType;
}
// proto: void QTextFrameFormat::setTopMargin(qreal margin);
impl<'a> /*trait*/ QTextFrameFormat_setTopMargin<()> for (f64) {
fn setTopMargin(self , rsthis: & QTextFrameFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN16QTextFrameFormat12setTopMarginEd()};
let arg0 = self as c_double;
unsafe {C_ZN16QTextFrameFormat12setTopMarginEd(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: qreal QTextFrameFormat::topMargin();
impl /*struct*/ QTextFrameFormat {
pub fn topMargin<RetType, T: QTextFrameFormat_topMargin<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.topMargin(self);
// return 1;
}
}
pub trait QTextFrameFormat_topMargin<RetType> {
fn topMargin(self , rsthis: & QTextFrameFormat) -> RetType;
}
// proto: qreal QTextFrameFormat::topMargin();
impl<'a> /*trait*/ QTextFrameFormat_topMargin<f64> for () {
fn topMargin(self , rsthis: & QTextFrameFormat) -> f64 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK16QTextFrameFormat9topMarginEv()};
let mut ret = unsafe {C_ZNK16QTextFrameFormat9topMarginEv(rsthis.qclsinst)};
return ret as f64; // 1
// return 1;
}
}
// proto: QTextLength QTextFrameFormat::width();
impl /*struct*/ QTextFrameFormat {
pub fn width<RetType, T: QTextFrameFormat_width<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.width(self);
// return 1;
}
}
pub trait QTextFrameFormat_width<RetType> {
fn width(self , rsthis: & QTextFrameFormat) -> RetType;
}
// proto: QTextLength QTextFrameFormat::width();
impl<'a> /*trait*/ QTextFrameFormat_width<QTextLength> for () {
fn width(self , rsthis: & QTextFrameFormat) -> QTextLength {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK16QTextFrameFormat5widthEv()};
let mut ret = unsafe {C_ZNK16QTextFrameFormat5widthEv(rsthis.qclsinst)};
let mut ret1 = QTextLength::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: qreal QTextFrameFormat::padding();
impl /*struct*/ QTextFrameFormat {
pub fn padding<RetType, T: QTextFrameFormat_padding<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.padding(self);
// return 1;
}
}
pub trait QTextFrameFormat_padding<RetType> {
fn padding(self , rsthis: & QTextFrameFormat) -> RetType;
}
// proto: qreal QTextFrameFormat::padding();
impl<'a> /*trait*/ QTextFrameFormat_padding<f64> for () {
fn padding(self , rsthis: & QTextFrameFormat) -> f64 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK16QTextFrameFormat7paddingEv()};
let mut ret = unsafe {C_ZNK16QTextFrameFormat7paddingEv(rsthis.qclsinst)};
return ret as f64; // 1
// return 1;
}
}
// proto: void QTextFrameFormat::setLeftMargin(qreal margin);
impl /*struct*/ QTextFrameFormat {
pub fn setLeftMargin<RetType, T: QTextFrameFormat_setLeftMargin<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setLeftMargin(self);
// return 1;
}
}
pub trait QTextFrameFormat_setLeftMargin<RetType> {
fn setLeftMargin(self , rsthis: & QTextFrameFormat) -> RetType;
}
// proto: void QTextFrameFormat::setLeftMargin(qreal margin);
impl<'a> /*trait*/ QTextFrameFormat_setLeftMargin<()> for (f64) {
fn setLeftMargin(self , rsthis: & QTextFrameFormat) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN16QTextFrameFormat13setLeftMarginEd()};
let arg0 = self as c_double;
unsafe {C_ZN16QTextFrameFormat13setLeftMarginEd(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: qreal QTextFrameFormat::border();
impl /*struct*/ QTextFrameFormat {
pub fn border<RetType, T: QTextFrameFormat_border<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.border(self);
// return 1;
}
}
pub trait QTextFrameFormat_border<RetType> {
fn border(self , rsthis: & QTextFrameFormat) -> RetType;
}
// proto: qreal QTextFrameFormat::border();
impl<'a> /*trait*/ QTextFrameFormat_border<f64> for () {
fn border(self , rsthis: & QTextFrameFormat) -> f64 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK16QTextFrameFormat6borderEv()};
let mut ret = unsafe {C_ZNK16QTextFrameFormat6borderEv(rsthis.qclsinst)};
return ret as f64; // 1
// return 1;
}
}
// proto: void QTextFrameFormat::QTextFrameFormat();
impl /*struct*/ QTextFrameFormat {
pub fn new<T: QTextFrameFormat_new>(value: T) -> QTextFrameFormat {
let rsthis = value.new();
return rsthis;
// return 1;
}
}
pub trait QTextFrameFormat_new {
fn new(self) -> QTextFrameFormat;
}
// proto: void QTextFrameFormat::QTextFrameFormat();
impl<'a> /*trait*/ QTextFrameFormat_new for () {
fn new(self) -> QTextFrameFormat {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN16QTextFrameFormatC2Ev()};
let ctysz: c_int = unsafe{QTextFrameFormat_Class_Size()};
let qthis_ph: u64 = unsafe{calloc(1, ctysz as usize)} as u64;
let qthis: u64 = unsafe {C_ZN16QTextFrameFormatC2Ev()};
let rsthis = QTextFrameFormat{qbase: QTextFormat::inheritFrom(qthis), qclsinst: qthis, ..Default::default()};
return rsthis;
// return 1;
}
}
// proto: qreal QTextFrameFormat::leftMargin();
impl /*struct*/ QTextFrameFormat {
pub fn leftMargin<RetType, T: QTextFrameFormat_leftMargin<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.leftMargin(self);
// return 1;
}
}
pub trait QTextFrameFormat_leftMargin<RetType> {
fn leftMargin(self , rsthis: & QTextFrameFormat) -> RetType;
}
// proto: qreal QTextFrameFormat::leftMargin();
impl<'a> /*trait*/ QTextFrameFormat_leftMargin<f64> for () {
fn leftMargin(self , rsthis: & QTextFrameFormat) -> f64 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK16QTextFrameFormat10leftMarginEv()};
let mut ret = unsafe {C_ZNK16QTextFrameFormat10leftMarginEv(rsthis.qclsinst)};
return ret as f64; // 1
// return 1;
}
}
// <= body block end
|
// Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
use cm_json::Error;
use serde::ser::Serialize;
use serde_json::ser::{CompactFormatter, PrettyFormatter, Serializer};
use serde_json::Value;
use std::fs;
use std::io::{Read, Write};
use std::path::PathBuf;
use std::str::from_utf8;
/// read in the json file from the given path, minify it if pretty is false or pretty-ify it if
/// pretty is true, and then write the results to stdout if output is None or to the given path if
/// output is Some.
pub fn format(file: &PathBuf, pretty: bool, output: Option<PathBuf>) -> Result<(), Error> {
let mut buffer = String::new();
fs::File::open(&file)?.read_to_string(&mut buffer)?;
let v: Value = serde_json::from_str(&buffer)
.map_err(|e| Error::parse(format!("Couldn't read input as JSON: {}", e)))?;
let mut res = Vec::new();
if pretty {
let mut ser = Serializer::with_formatter(&mut res, PrettyFormatter::with_indent(b" "));
v.serialize(&mut ser)
.map_err(|e| Error::parse(format!("Couldn't serialize JSON: {}", e)))?;
} else {
let mut ser = Serializer::with_formatter(&mut res, CompactFormatter {});
v.serialize(&mut ser)
.map_err(|e| Error::parse(format!("Couldn't serialize JSON: {}", e)))?;
}
if let Some(output_path) = output {
fs::OpenOptions::new()
.create(true)
.truncate(true)
.write(true)
.open(output_path)?
.write_all(&res)?;
} else {
println!("{}", from_utf8(&res)?);
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use std::fs::File;
use std::io::Write;
use tempfile::TempDir;
fn count_num_newlines(input: &str) -> usize {
let mut ret = 0;
for c in input.chars() {
if c == '\n' {
ret += 1;
}
}
ret
}
#[test]
fn test_format_json() {
let example_json = r#"{ "program": { "binary": "bin/app"
}, "sandbox": {
"dev": [
"class/camera" ], "features": [
"persistent-storage", "vulkan"] } }"#;
let tmp_dir = TempDir::new().unwrap();
let tmp_file_path = tmp_dir.path().join("input.json");
File::create(&tmp_file_path).unwrap().write_all(example_json.as_bytes()).unwrap();
let output_file_path = tmp_dir.path().join("output.json");
// format as not-pretty
let result = format(&tmp_file_path, false, Some(output_file_path.clone()));
assert!(result.is_ok());
let mut buffer = String::new();
File::open(&output_file_path).unwrap().read_to_string(&mut buffer).unwrap();
assert_eq!(0, count_num_newlines(&buffer));
// format as pretty
let result = format(&tmp_file_path, true, Some(output_file_path.clone()));
assert!(result.is_ok());
let mut buffer = String::new();
File::open(&output_file_path).unwrap().read_to_string(&mut buffer).unwrap();
assert_eq!(13, count_num_newlines(&buffer));
}
#[test]
fn test_format_invalid_json_fails() {
let example_json = "{\"foo\": 1,}";
let tmp_dir = TempDir::new().unwrap();
let tmp_file_path = tmp_dir.path().join("input.json");
File::create(&tmp_file_path).unwrap().write_all(example_json.as_bytes()).unwrap();
// format as not-pretty
let result = format(&tmp_file_path, false, None);
assert!(result.is_err());
}
}
|
// xfail-stage1
// xfail-stage2
// xfail-stage3
io fn main() {
let port[int] po = port();
// Spawn 10 tasks each sending us back one int.
let int i = 10;
while (i > 0) {
log i;
spawn "child" child(i, chan(po));
i = i - 1;
}
// Spawned tasks are likely killed before they get a chance to send
// anything back, so we deadlock here.
i = 10;
let int value = 0;
while (i > 0) {
log i;
po |> value;
i = i - 1;
}
log "main thread exiting";
}
io fn child(int x, chan[int] ch) {
log x;
ch <| x;
}
|
use std::rc::Rc;
use regex_syntax::hir::{Class, HirKind, Literal, RepetitionKind, RepetitionRange};
use crate::mutators::grammar::{alternation, concatenation, literal, literal_ranges, repetition, Grammar};
#[no_coverage]
pub(crate) fn grammar_from_regex(regex: &str) -> Rc<Grammar> {
let mut parser = regex_syntax::Parser::new();
let hir = parser.parse(regex).unwrap();
grammar_from_regex_hir_kind(hir.kind())
}
#[no_coverage]
pub fn grammar_from_regex_hir_kind(hir: &HirKind) -> Rc<Grammar> {
match hir {
HirKind::Empty => panic!("empty regexes are not supported"),
HirKind::Literal(l) => match l {
Literal::Unicode(l) => literal(*l),
Literal::Byte(_) => panic!("non-unicode regexes are not supported"),
},
HirKind::Class(class) => match class {
Class::Unicode(class) => {
let ranges = class
.ranges()
.iter()
.map(
#[no_coverage]
|r| r.start()..=r.end(),
)
.collect::<Vec<_>>();
literal_ranges(ranges)
}
Class::Bytes(_) => panic!("non-unicode regexes are not supported"),
},
HirKind::Anchor(_) => panic!("anchors are not supported"),
HirKind::WordBoundary(_) => panic!("word boundaries are not supported"),
HirKind::Repetition(rep) => {
let range = match rep.kind.clone() {
RepetitionKind::ZeroOrOne => 0..=1u32,
RepetitionKind::ZeroOrMore => 0..=u32::MAX,
RepetitionKind::OneOrMore => 1..=u32::MAX,
RepetitionKind::Range(range) => match range {
RepetitionRange::Exactly(n) => n..=n,
RepetitionRange::AtLeast(n) => n..=u32::MAX,
RepetitionRange::Bounded(n, m) => n..=m,
},
};
let range = (*range.start() as usize)..=(*range.end() as usize);
let grammar = grammar_from_regex_hir_kind(rep.hir.kind());
repetition(grammar, range)
}
HirKind::Group(group) => grammar_from_regex_hir_kind(group.hir.kind()),
HirKind::Concat(concat) => concatenation(concat.iter().map(
#[no_coverage]
|hir| grammar_from_regex_hir_kind(hir.kind()),
)),
HirKind::Alternation(alt) => alternation(alt.iter().map(
#[no_coverage]
|hir| grammar_from_regex_hir_kind(hir.kind()),
)),
}
}
|
//==============================================================================
// Notes
//==============================================================================
// drivers::lcd::images.rs
// LCD Drivers Mod List
//==============================================================================
// Crates and Mods
//==============================================================================
//==============================================================================
// Enums, Structs, and Types
//==============================================================================
//==============================================================================
// Variables
//==============================================================================
#[allow(dead_code)]
pub const RUSTACEAN: [u8; 33920] = [
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF,
0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xDA, 0x00, 0xB9, 0xC0, 0xA9, 0x80, 0xA1, 0x80, 0xA9, 0x80, 0xC1, 0xE0, 0xE2, 0x40,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xEA, 0x40, 0xC1, 0xE0,
0x99, 0x60, 0x89, 0x40, 0x99, 0x60, 0xB9, 0xC0, 0xEA, 0x40, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x61, 0xE5, 0x75,
0xEF, 0x5C, 0xE7, 0x5C, 0xB5, 0x96, 0x10, 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00,
0x89, 0x40, 0xE2, 0x20, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0xC5, 0xFE, 0x58, 0xF7, 0x7D, 0xE7, 0x3C,
0x94, 0xB2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x60, 0xB1, 0xC0, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFD, 0xD6, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xBD, 0xF7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x38, 0x60, 0xD2, 0x00, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xE2, 0x20, 0xE6, 0x99, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0x94, 0x92, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x89, 0x40, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF3, 0x6A, 0xFF, 0xDE, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x63, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x38, 0x60, 0xE2, 0x20, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xEA, 0x40, 0x93, 0xEF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xEF, 0x5D, 0x10, 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x99, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xED, 0x74, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xB5, 0x96, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x79, 0x20, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xA1, 0x80, 0xBD, 0xF7, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0x6B, 0x4D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00,
0xE2, 0x20, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xCE, 0x17, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xCE, 0x59, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xD2, 0x00, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xE2, 0x40, 0x20, 0x20, 0xD6, 0xBA, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0x8C, 0x71, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xA9, 0xA0, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xC1, 0xE0, 0xC6, 0x18, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xCE, 0x79, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x91, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xB1, 0xA0, 0x00, 0x00, 0xD6, 0x9A, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0x8C, 0x71, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x58, 0xA0, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0x89, 0x40, 0xAD, 0x75, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xB5, 0xD6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0x68, 0xE0, 0x00, 0x00, 0xB5, 0xD6, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0x5A, 0xEB, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0xDA, 0x20, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0x30, 0x40, 0x63, 0x2C, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x73, 0xAE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE2, 0x40, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xEA, 0x40, 0x10, 0x00, 0x00, 0x00, 0x6B, 0x4D, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xDF, 0x1B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0xB9, 0xC0, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xDA, 0x20, 0x00, 0x00, 0x00, 0x00, 0xCE, 0x59, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xD6, 0x9A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xDA, 0x00, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xDA, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xBD, 0xF7, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xF7, 0xDE, 0x7B, 0xCF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x99, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xC9, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x29, 0x45, 0xCE, 0x59,
0xFF, 0xDF, 0xFF, 0xFF, 0xCE, 0x79, 0x39, 0xC7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xD2, 0x00, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xCA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x62, 0xA5, 0x34, 0xDE, 0xDB, 0xCE, 0x79,
0x73, 0xAE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x81, 0x20, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xC9, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x39, 0xC7, 0x39, 0xC7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xD2, 0x00, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xD2, 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, 0x79, 0x00, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xD2, 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, 0xE2, 0x20, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xE2, 0x20, 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, 0x89, 0x20, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xEA, 0x40, 0x10, 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, 0x28, 0x20, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0x48, 0x80, 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, 0xA1, 0x80, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0x79, 0x20, 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, 0x81, 0x20, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xA1, 0x80, 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, 0xD2, 0x00, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xD2, 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, 0xC9, 0xE0, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xE2, 0x20, 0x28, 0x20, 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,
0x68, 0xE0, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0x99, 0x60, 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, 0x70, 0xE0, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xB9, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x40,
0xDA, 0x20, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0x91, 0x40, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x40, 0x80, 0xE2, 0x20, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0x99, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x68, 0xE0, 0xDA, 0x20,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xB1, 0xC0,
0x30, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x60, 0xC0, 0xDA, 0x20, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0x91, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x80, 0xB9, 0xC0, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xE2, 0x20, 0xD2, 0x00, 0xEA, 0x40, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xE2, 0x40, 0xA1, 0x80, 0x38, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x68, 0xE0,
0xB9, 0xC0, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xCA, 0x00, 0x89, 0x40, 0x48, 0x80,
0x20, 0x20, 0x58, 0xC0, 0x91, 0x40, 0xC9, 0xE0, 0xEA, 0x40, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xEA, 0x40, 0xE2, 0x20, 0xDA, 0x00, 0xDA, 0x00, 0xDA, 0x20, 0xE2, 0x40, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xEA, 0x40, 0xC1, 0xC0,
0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xC1, 0xC0, 0xE2, 0x20, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xEA, 0x40, 0xC9, 0xE0, 0xB9, 0xC0, 0xC9, 0xE0, 0xE2, 0x20, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x40, 0xA9, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA9, 0x60,
0xC1, 0xC0, 0xDA, 0x20, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xB9, 0xA0, 0xA1, 0x60,
0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xB1, 0x80, 0xD2, 0x00, 0xEA, 0x40,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xDA, 0x00, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60,
0xA1, 0x60, 0xA1, 0x60, 0xB1, 0xA0, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xA1, 0x60, 0xA1, 0x60,
0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60,
0xB9, 0xA0, 0xDA, 0x00, 0xF2, 0x40, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xB1, 0x80, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60,
0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xA1, 0x60,
0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60,
0xA1, 0x60, 0xA1, 0x60, 0xA9, 0x60, 0xEA, 0x40, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xEA, 0x40, 0xEA, 0x40, 0xEA, 0x40, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xE2, 0x20,
0xC1, 0xE0, 0xB1, 0xA0, 0xA9, 0xA0, 0xA9, 0xA0, 0xC1, 0xC0, 0xDA, 0x20, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xDA, 0x20,
0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xFF, 0xFF, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60,
0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF,
0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60,
0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xC1, 0xC0, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xE2, 0x40, 0xB9, 0xC0, 0x89, 0x40, 0x48, 0x80, 0x18, 0x20, 0x08, 0x00, 0x10, 0x00, 0x38, 0x60,
0x81, 0x20, 0xB1, 0xA0, 0xDA, 0x20, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xEA, 0x40, 0xB1, 0xA0, 0x60, 0xC0, 0x00, 0x00,
0x58, 0xC0, 0x89, 0x40, 0xA1, 0x60, 0x99, 0x60, 0x81, 0x20, 0x48, 0x80, 0x48, 0x80, 0xA9, 0x80,
0xE2, 0x40, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xEA, 0x40, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xB1, 0x80,
0xA1, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60,
0xA1, 0x60, 0xA1, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF,
0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60,
0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xDA, 0x20, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xDA, 0x20, 0x91, 0x40,
0x18, 0x20, 0x00, 0x00, 0x00, 0x00, 0x48, 0x80, 0x58, 0xC0, 0x58, 0xC0, 0x48, 0x80, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x79, 0x00, 0xCA, 0x00, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xB1, 0xA0, 0x38, 0x40, 0x58, 0xA0, 0xB1, 0xA0, 0xE2, 0x20,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xDA, 0x20, 0xA1, 0x80,
0x40, 0x80, 0xA9, 0x80, 0xEA, 0x40, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xDA, 0x00, 0xC1, 0xC0, 0xD1, 0xE0, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x40, 0xA1, 0x60,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60,
0xA1, 0x60, 0xA1, 0x60, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60,
0xFF, 0xFF, 0xFF, 0xFF, 0xA1, 0x60, 0xA1, 0x60, 0xA9, 0x80, 0xEA, 0x40, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xDA, 0x20, 0xEA, 0x40,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xEA, 0x40, 0xA1, 0x80, 0x18, 0x20, 0x48, 0x80,
0xA1, 0x80, 0xCA, 0x00, 0xEA, 0x40, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xEA, 0x40,
0xCA, 0x00, 0xA1, 0x80, 0x40, 0x80, 0x00, 0x00, 0x00, 0x00, 0x81, 0x20, 0xE2, 0x20, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xDA, 0x20, 0x60, 0xE0, 0x40, 0x80, 0xB9, 0xC0, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xEA, 0x40, 0x99, 0x60, 0x60, 0xC0, 0xDA, 0x20, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xEA, 0x40,
0xDA, 0x00, 0xC1, 0xC0, 0xA9, 0x60, 0xA1, 0x60, 0xC9, 0xE0, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60,
0xA1, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60,
0xA1, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x40, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xDA, 0x00, 0xA1, 0x60,
0xB1, 0x80, 0xC9, 0xE0, 0xDA, 0x00, 0xEA, 0x40, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xDA, 0x20, 0x60, 0xC0, 0x58, 0xA0, 0xC1, 0xC0, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xEA, 0x40, 0xC1, 0xC0, 0x58, 0xA0, 0x00, 0x00, 0x30, 0x40, 0xB9, 0xC0,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xC1, 0xC0, 0x20, 0x20, 0x89, 0x40, 0xEA, 0x40, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xCA, 0x00, 0x50, 0xA0, 0xC9, 0xE0, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xE2, 0x40, 0xD1, 0xE0, 0xB9, 0xA0, 0xA1, 0x60,
0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xD1, 0xE0, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60,
0xA1, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xC1, 0xC0,
0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA9, 0x80, 0xC1, 0xC0, 0xD2, 0x00, 0xE2, 0x20,
0xF2, 0x60, 0xF2, 0x60, 0xCA, 0x00, 0x40, 0x60, 0xA9, 0xA0, 0xEA, 0x40, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xEA, 0x40, 0xA9, 0xA0, 0x20, 0x20, 0x00, 0x00,
0x99, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xA9, 0x80,
0x10, 0x00, 0xB1, 0xA0, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xE2, 0x20, 0x60, 0xC0, 0xC1, 0xC0, 0xF2, 0x60, 0xF2, 0x60,
0xE2, 0x40, 0xD2, 0x00, 0xC1, 0xC0, 0xA9, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60,
0xA1, 0x60, 0xA1, 0x60, 0xDA, 0x00, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60,
0xA1, 0x60, 0xA1, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x40,
0xB1, 0x80, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60,
0xA1, 0x60, 0x99, 0x40, 0x58, 0xC0, 0xDA, 0x00, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xDA, 0x20, 0x60, 0xC0,
0x00, 0x00, 0x81, 0x20, 0xEA, 0x40, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xA1, 0x80, 0x28, 0x20,
0xC9, 0xE0, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xE2, 0x40, 0x60, 0xC0, 0xA1, 0x60, 0xA9, 0x60,
0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60,
0xA9, 0x60, 0xE2, 0x20, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60,
0xA1, 0x60, 0xA1, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xEA, 0x40, 0xA9, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60,
0x89, 0x20, 0x71, 0x00, 0xEA, 0x40, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xEA, 0x40,
0x81, 0x20, 0x00, 0x00, 0x79, 0x00, 0xEA, 0x40, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xA1, 0x80, 0x20, 0x20, 0xCA, 0x00,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xE2, 0x20, 0x48, 0x80, 0x91, 0x20,
0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xB1, 0xA0,
0xEA, 0x40, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60,
0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xEA, 0x40, 0xB1, 0x80, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0x91, 0x20,
0x81, 0x20, 0xEA, 0x40, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0x91, 0x60, 0x00, 0x00, 0x81, 0x20, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xB1, 0xC0, 0x10, 0x00, 0xC9, 0xE0, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xD2, 0x00, 0x38, 0x60,
0x99, 0x40, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xEA, 0x40, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xA1, 0x60, 0xA1, 0x60,
0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xA1, 0x60, 0xA1, 0x60, 0x89, 0x20,
0xEA, 0x40, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0x91, 0x60, 0x00, 0x00, 0x81, 0x20, 0xC1, 0xC0, 0xC1, 0xC0, 0xC1, 0xC0,
0xC1, 0xC0, 0xC1, 0xC0, 0xC1, 0xC0, 0xA9, 0x80, 0x10, 0x00, 0xB9, 0xC0, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xA9, 0xA0,
0x48, 0x80, 0xA1, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xA1, 0x60,
0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xF2, 0x60, 0xEA, 0x40,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0x89, 0x40, 0x00, 0x00, 0x70, 0xE0, 0xA1, 0x60, 0xA1, 0x60,
0xA1, 0x60, 0xA1, 0x60, 0x91, 0x40, 0x20, 0x20, 0xA1, 0x80, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0x99, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xA1, 0x60,
0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xEA, 0x40, 0x79, 0x00, 0x08, 0x00, 0x89, 0x20, 0xA1, 0x60,
0xA1, 0x60, 0xA1, 0x40, 0x40, 0x60, 0x79, 0x00, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xA1, 0x60,
0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xEA, 0x40, 0xB9, 0xC0, 0x50, 0xA0, 0xA1, 0x60,
0xA1, 0x60, 0x00, 0x00, 0xB1, 0xC0, 0xEA, 0x40, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xA1, 0x60, 0xA1, 0x60,
0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xA1, 0x60, 0xA1, 0x60,
0xA1, 0x60, 0xA1, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xA1, 0x60, 0xA1, 0x60,
0xA1, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60,
0xA1, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xA1, 0x60, 0xA1, 0x60, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xA1, 0x60, 0xA1, 0x60, 0xA1, 0x60, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xA1, 0x60, 0xA1, 0x60,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xA1, 0x60, 0xA1, 0x60, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xA1, 0x60,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xA1, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60,
0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xF2, 0x60, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
];
//==============================================================================
// Public Functions
//==============================================================================
//==============================================================================
// Private Functions
//==============================================================================
//==============================================================================
// Interrupt Handler
//==============================================================================
//==============================================================================
// Task Handler
//============================================================================== |
use super::{DisplayError, Item, Problem, Solution};
use std::fs;
use std::str::FromStr;
#[derive(Debug)]
pub struct SolutionsFromFile(pub Vec<Solution>);
impl FromStr for SolutionsFromFile {
type Err = DisplayError;
fn from_str(file_name: &str) -> Result<SolutionsFromFile, DisplayError> {
Ok(SolutionsFromFile(
fs::read_to_string(file_name)
.map_err(|e| {
format!(
"Could not solution load file: {}, because: {}",
file_name, e
)
})?
.lines()
.map(|line| {
parse_solution_line(line).map_err(|e| format!("{}\nSolution Line: {}", e, line))
})
.collect::<Result<_, _>>()?,
))
}
}
#[derive(Debug)]
pub struct ProblemFromfile(pub Vec<Problem>);
impl FromStr for ProblemFromfile {
type Err = DisplayError;
fn from_str(file_name: &str) -> Result<ProblemFromfile, DisplayError> {
Ok(ProblemFromfile(
fs::read_to_string(file_name)
.map_err(|e| format!("Could not problem load file: {}, because: {}", file_name, e))?
.lines()
.map(|line| {
parse_problem_line(line).map_err(|e| format!("{}\nProblem Line: {}", e, line))
})
.collect::<Result<_, _>>()?,
))
}
}
pub fn next_parse_with_err<'a, T, K>(iter: &mut T) -> Result<K, DisplayError>
where
T: Iterator<Item = &'a str>,
K: FromStr,
<K as std::str::FromStr>::Err: std::fmt::Debug,
{
Ok(iter
.next()
.ok_or_else(|| "Line exhasted, but next item was expecting".to_string())?
.parse()
.map_err(|e| format!("Could not parse number {:?}", e))?)
}
pub fn parse_problem_line(line: &str) -> Result<Problem, DisplayError> {
let mut iter = line.split(' ').filter(|x| !x.is_empty());
let id: i32 = next_parse_with_err(&mut iter)?;
let size = next_parse_with_err(&mut iter)?;
let max_weight = next_parse_with_err(&mut iter)?;
let min_cost = match () {
() if id < 0 => Ok(Some(next_parse_with_err(&mut iter)?)),
() if id > 0 => Ok(None),
_ => Err("zero id not permitted"),
}?;
let items = (0..size)
.map(|_| {
let weight = next_parse_with_err(&mut iter)?;
let cost = next_parse_with_err(&mut iter)?;
Ok(Item { weight, cost })
})
.collect::<Result<Vec<_>, DisplayError>>()?;
assert_eq!(
iter.next(),
None,
"Line was not exhausted, wrong problem line!"
);
Ok(Problem {
id: id.abs() as u32,
max_weight,
size,
min_cost,
items,
})
}
pub fn parse_solution_line(line: &str) -> Result<Solution, DisplayError> {
let mut iter = line.split(' ').filter(|x| !x.is_empty());
let id = next_parse_with_err(&mut iter)?;
let size = next_parse_with_err(&mut iter)?;
let cost = next_parse_with_err(&mut iter)?;
let items = Some(
(0..size)
.map(
|_| match iter.next().ok_or_else(|| "Not enough bits in line!")? {
"1" => Ok(true),
"0" => Ok(false),
_ => Err("Reference solution is not in (0, 1)!".into()),
},
)
.collect::<Result<Vec<_>, DisplayError>>()?,
);
if iter.next() != None {
return Err("Line was not exhausted, wrong solution line!".into());
}
Ok(Solution {
id,
size,
cost,
items,
})
}
|
use rustcommon::httpaccessor;
use tokio;
#[tokio::test]
async fn test_http_async_get() -> Result<(), String> {
let resp_wrapper_result = httpaccessor::HttpAccessor::async_get("http://www.baidu.com", 10).await;
match resp_wrapper_result {
Ok(resp) => match resp.status_code() {
200 => Ok(()),
_ => Err(String::from("do http_async_get fail"))
},
Err(e) => {
Err(String::from("do http_async_get fail"))
}
}
}
#[tokio::test]
async fn test_http_async_multi_get() -> Result<(), String> {
let resp_wrapper_list_result = httpaccessor::HttpAccessor::async_multi_get(&vec!["http://www.baidu.com", "http://www.taobao.com"], 10).await;
match resp_wrapper_list_result {
Ok(resp_result_list) => {
match resp_result_list.into_iter().all(|resp_result| {
match resp_result {
Ok(resp) => match resp.status_code() {
200 => true,
_ => false
}
_ => false
}
}) {
true => Ok(()),
false => Err(String::from("do http_async_multi_get fail"))
}
},
Err(e) => Err(String::from("do http_async_multi_get fail"))
}
}
|
// Copyright 2019 The Tari Project
//
// Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
// following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following
// disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
// following disclaimer in the documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote
// products derived from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
// USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
use crate::{
base_node::{comms_interface::BlockEvent, generate_request_key, RequestKey, WaitingRequests},
chain_storage::BlockchainBackend,
mempool::{
proto,
service::{
error::MempoolServiceError,
inbound_handlers::MempoolInboundHandlers,
MempoolRequest,
MempoolResponse,
},
MempoolServiceConfig,
},
transactions::{proto::types::Transaction as ProtoTransaction, transaction::Transaction},
};
use futures::{
channel::{
mpsc::{channel, Receiver, Sender, UnboundedReceiver},
oneshot::Sender as OneshotSender,
},
pin_mut,
stream::StreamExt,
SinkExt,
Stream,
};
use log::*;
use rand::rngs::OsRng;
use std::{convert::TryInto, sync::Arc, time::Duration};
use tari_broadcast_channel::Subscriber;
use tari_comms::types::CommsPublicKey;
use tari_comms_dht::{
domain_message::OutboundDomainMessage,
envelope::NodeDestination,
outbound::{OutboundEncryption, OutboundMessageRequester},
};
use tari_crypto::{ristretto::RistrettoPublicKey, tari_utilities::hex::Hex};
use tari_p2p::{domain_message::DomainMessage, tari_message::TariMessageType};
use tari_service_framework::RequestContext;
use tokio::task;
const LOG_TARGET: &str = "c::mempool::service::service";
/// A convenience struct to hold all the Mempool service streams
pub struct MempoolStreams<SOutReq, SInReq, SInRes, STxIn, SLocalReq> {
outbound_request_stream: SOutReq,
outbound_tx_stream: UnboundedReceiver<(Transaction, Vec<CommsPublicKey>)>,
inbound_request_stream: SInReq,
inbound_response_stream: SInRes,
inbound_transaction_stream: STxIn,
local_request_stream: SLocalReq,
block_event_stream: Subscriber<BlockEvent>,
}
impl<SOutReq, SInReq, SInRes, STxIn, SLocalReq> MempoolStreams<SOutReq, SInReq, SInRes, STxIn, SLocalReq>
where
SOutReq: Stream<Item = RequestContext<MempoolRequest, Result<MempoolResponse, MempoolServiceError>>>,
SInReq: Stream<Item = DomainMessage<proto::MempoolServiceRequest>>,
SInRes: Stream<Item = DomainMessage<proto::MempoolServiceResponse>>,
STxIn: Stream<Item = DomainMessage<Transaction>>,
SLocalReq: Stream<Item = RequestContext<MempoolRequest, Result<MempoolResponse, MempoolServiceError>>>,
{
pub fn new(
outbound_request_stream: SOutReq,
outbound_tx_stream: UnboundedReceiver<(Transaction, Vec<CommsPublicKey>)>,
inbound_request_stream: SInReq,
inbound_response_stream: SInRes,
inbound_transaction_stream: STxIn,
local_request_stream: SLocalReq,
block_event_stream: Subscriber<BlockEvent>,
) -> Self
{
Self {
outbound_request_stream,
outbound_tx_stream,
inbound_request_stream,
inbound_response_stream,
inbound_transaction_stream,
local_request_stream,
block_event_stream,
}
}
}
/// The Mempool Service is responsible for handling inbound requests and responses and for sending new requests to the
/// Mempools of remote Base nodes.
pub struct MempoolService<B: BlockchainBackend + 'static> {
outbound_message_service: OutboundMessageRequester,
inbound_handlers: MempoolInboundHandlers<B>,
waiting_requests: WaitingRequests<Result<MempoolResponse, MempoolServiceError>>,
timeout_sender: Sender<RequestKey>,
timeout_receiver_stream: Option<Receiver<RequestKey>>,
config: MempoolServiceConfig,
}
impl<B> MempoolService<B>
where B: BlockchainBackend + 'static
{
pub fn new(
outbound_message_service: OutboundMessageRequester,
inbound_handlers: MempoolInboundHandlers<B>,
config: MempoolServiceConfig,
) -> Self
{
let (timeout_sender, timeout_receiver) = channel(100);
Self {
outbound_message_service,
inbound_handlers,
waiting_requests: WaitingRequests::new(),
timeout_sender,
timeout_receiver_stream: Some(timeout_receiver),
config,
}
}
pub async fn start<SOutReq, SInReq, SInRes, STxIn, SLocalReq>(
mut self,
streams: MempoolStreams<SOutReq, SInReq, SInRes, STxIn, SLocalReq>,
) -> Result<(), MempoolServiceError>
where
SOutReq: Stream<Item = RequestContext<MempoolRequest, Result<MempoolResponse, MempoolServiceError>>>,
SInReq: Stream<Item = DomainMessage<proto::MempoolServiceRequest>>,
SInRes: Stream<Item = DomainMessage<proto::MempoolServiceResponse>>,
STxIn: Stream<Item = DomainMessage<Transaction>>,
SLocalReq: Stream<Item = RequestContext<MempoolRequest, Result<MempoolResponse, MempoolServiceError>>>,
{
let outbound_request_stream = streams.outbound_request_stream.fuse();
pin_mut!(outbound_request_stream);
let outbound_tx_stream = streams.outbound_tx_stream.fuse();
pin_mut!(outbound_tx_stream);
let inbound_request_stream = streams.inbound_request_stream.fuse();
pin_mut!(inbound_request_stream);
let inbound_response_stream = streams.inbound_response_stream.fuse();
pin_mut!(inbound_response_stream);
let inbound_transaction_stream = streams.inbound_transaction_stream.fuse();
pin_mut!(inbound_transaction_stream);
let local_request_stream = streams.local_request_stream.fuse();
pin_mut!(local_request_stream);
let block_event_stream = streams.block_event_stream.fuse();
pin_mut!(block_event_stream);
let timeout_receiver_stream = self
.timeout_receiver_stream
.take()
.expect("Mempool Service initialized without timeout_receiver_stream")
.fuse();
pin_mut!(timeout_receiver_stream);
loop {
futures::select! {
// Outbound request messages from the OutboundMempoolServiceInterface
outbound_request_context = outbound_request_stream.select_next_some() => {
self.spawn_handle_outbound_request(outbound_request_context);
},
// Outbound tx messages from the OutboundMempoolServiceInterface
outbound_tx_context = outbound_tx_stream.select_next_some() => {
self.spawn_handle_outbound_tx(outbound_tx_context);
},
// Incoming request messages from the Comms layer
domain_msg = inbound_request_stream.select_next_some() => {
self.spawn_handle_incoming_request(domain_msg);
},
// Incoming response messages from the Comms layer
domain_msg = inbound_response_stream.select_next_some() => {
self.spawn_handle_incoming_response(domain_msg);
},
// Incoming transaction messages from the Comms layer
transaction_msg = inbound_transaction_stream.select_next_some() => {
self.spawn_handle_incoming_tx(transaction_msg);
}
// Incoming local request messages from the LocalMempoolServiceInterface and other local services
local_request_context = local_request_stream.select_next_some() => {
self.spawn_handle_local_request(local_request_context);
},
// Block events from local Base Node.
block_event = block_event_stream.select_next_some() => {
self.spawn_handle_block_event(block_event);
},
// Timeout events for waiting requests
timeout_request_key = timeout_receiver_stream.select_next_some() => {
self.spawn_handle_request_timeout(timeout_request_key);
},
complete => {
info!(target: LOG_TARGET, "Mempool service shutting down");
break;
}
}
}
Ok(())
}
fn spawn_handle_outbound_request(
&self,
request_context: RequestContext<MempoolRequest, Result<MempoolResponse, MempoolServiceError>>,
)
{
let outbound_message_service = self.outbound_message_service.clone();
let waiting_requests = self.waiting_requests.clone();
let timeout_sender = self.timeout_sender.clone();
let config = self.config;
task::spawn(async move {
let (request, reply_tx) = request_context.split();
let _ = handle_outbound_request(
outbound_message_service,
waiting_requests,
timeout_sender,
reply_tx,
request,
config,
)
.await
.or_else(|err| {
error!(
target: LOG_TARGET,
"Failed to handle outbound request message: {:?}", err
);
Err(err)
});
});
}
fn spawn_handle_outbound_tx(&self, tx_context: (Transaction, Vec<RistrettoPublicKey>)) {
let outbound_message_service = self.outbound_message_service.clone();
task::spawn(async move {
let (tx, excluded_peers) = tx_context;
let _ = handle_outbound_tx(outbound_message_service, tx, excluded_peers)
.await
.or_else(|err| {
error!(target: LOG_TARGET, "Failed to handle outbound tx message {:?}", err);
Err(err)
});
});
}
fn spawn_handle_incoming_request(&self, domain_msg: DomainMessage<proto::mempool::MempoolServiceRequest>) {
let inbound_handlers = self.inbound_handlers.clone();
let outbound_message_service = self.outbound_message_service.clone();
task::spawn(async move {
let _ = handle_incoming_request(inbound_handlers, outbound_message_service, domain_msg)
.await
.or_else(|err| {
error!(
target: LOG_TARGET,
"Failed to handle incoming request message: {:?}", err
);
Err(err)
});
});
}
fn spawn_handle_incoming_response(&self, domain_msg: DomainMessage<proto::mempool::MempoolServiceResponse>) {
let waiting_requests = self.waiting_requests.clone();
task::spawn(async move {
let _ = handle_incoming_response(waiting_requests, domain_msg.into_inner())
.await
.or_else(|err| {
error!(
target: LOG_TARGET,
"Failed to handle incoming response message: {:?}", err
);
Err(err)
});
});
}
fn spawn_handle_incoming_tx(&self, tx_msg: DomainMessage<Transaction>) {
let inbound_handlers = self.inbound_handlers.clone();
task::spawn(async move {
let _ = handle_incoming_tx(inbound_handlers, tx_msg).await.or_else(|err| {
error!(
target: LOG_TARGET,
"Failed to handle incoming transaction message: {:?}", err
);
Err(err)
});
});
}
fn spawn_handle_local_request(
&self,
request_context: RequestContext<MempoolRequest, Result<MempoolResponse, MempoolServiceError>>,
)
{
let mut inbound_handlers = self.inbound_handlers.clone();
task::spawn(async move {
let (request, reply_tx) = request_context.split();
let _ = reply_tx
.send(inbound_handlers.handle_request(&request).await)
.or_else(|err| {
error!(
target: LOG_TARGET,
"MempoolService failed to send reply to local request {:?}", err
);
Err(err)
});
});
}
fn spawn_handle_block_event(&self, block_event: Arc<BlockEvent>) {
let inbound_handlers = self.inbound_handlers.clone();
task::spawn(async move {
let _ = handle_block_event(inbound_handlers, &block_event).await.or_else(|err| {
error!(target: LOG_TARGET, "Failed to handle base node block event: {:?}", err);
Err(err)
});
});
}
fn spawn_handle_request_timeout(&self, timeout_request_key: u64) {
let waiting_requests = self.waiting_requests.clone();
task::spawn(async move {
let _ = handle_request_timeout(waiting_requests, timeout_request_key)
.await
.or_else(|err| {
error!(target: LOG_TARGET, "Failed to handle request timeout event: {:?}", err);
Err(err)
});
});
}
}
async fn handle_incoming_request<B: BlockchainBackend + 'static>(
mut inbound_handlers: MempoolInboundHandlers<B>,
mut outbound_message_service: OutboundMessageRequester,
domain_request_msg: DomainMessage<proto::MempoolServiceRequest>,
) -> Result<(), MempoolServiceError>
{
let (origin_public_key, inner_msg) = domain_request_msg.into_origin_and_inner();
// Convert proto::MempoolServiceRequest to a MempoolServiceRequest
let request = inner_msg
.request
.ok_or_else(|| MempoolServiceError::InvalidRequest("Received invalid mempool service request".to_string()))?;
let response = inbound_handlers
.handle_request(&request.try_into().map_err(MempoolServiceError::InvalidRequest)?)
.await?;
let message = proto::MempoolServiceResponse {
request_key: inner_msg.request_key,
response: Some(response.into()),
};
outbound_message_service
.send_direct(
origin_public_key,
OutboundEncryption::None,
OutboundDomainMessage::new(TariMessageType::MempoolResponse, message),
)
.await?;
Ok(())
}
async fn handle_incoming_response(
waiting_requests: WaitingRequests<Result<MempoolResponse, MempoolServiceError>>,
incoming_response: proto::MempoolServiceResponse,
) -> Result<(), MempoolServiceError>
{
let proto::MempoolServiceResponse { request_key, response } = incoming_response;
let response: MempoolResponse = response
.and_then(|r| r.try_into().ok())
.ok_or_else(|| MempoolServiceError::InvalidResponse("Received an invalid mempool response".to_string()))?;
if let Some(reply_tx) = waiting_requests.remove(request_key)? {
let _ = reply_tx.send(Ok(response).or_else(|resp| {
warn!(
target: LOG_TARGET,
"Failed to finalize request (request key:{}): {:?}", &request_key, resp
);
Err(resp)
}));
}
Ok(())
}
async fn handle_outbound_request(
mut outbound_message_service: OutboundMessageRequester,
waiting_requests: WaitingRequests<Result<MempoolResponse, MempoolServiceError>>,
timeout_sender: Sender<RequestKey>,
reply_tx: OneshotSender<Result<MempoolResponse, MempoolServiceError>>,
request: MempoolRequest,
config: MempoolServiceConfig,
) -> Result<(), MempoolServiceError>
{
let request_key = generate_request_key(&mut OsRng);
let service_request = proto::MempoolServiceRequest {
request_key,
request: Some(request.into()),
};
let send_result = outbound_message_service
.send_random(
1,
NodeDestination::Unknown,
OutboundEncryption::None,
OutboundDomainMessage::new(TariMessageType::MempoolRequest, service_request),
)
.await
.or_else(|e| {
error!(target: LOG_TARGET, "mempool outbound request failure. {:?}", e);
Err(e)
})
.map_err(|e| MempoolServiceError::OutboundMessageService(e.to_string()))?;
match send_result.resolve_ok().await {
Some(send_states) if !send_states.is_empty() => {
// Spawn timeout and wait for matching response to arrive
waiting_requests.insert(request_key, Some(reply_tx))?;
// Spawn timeout for waiting_request
spawn_request_timeout(timeout_sender, request_key, config.request_timeout);
},
Some(_) => {
let _ = reply_tx.send(Err(MempoolServiceError::NoBootstrapNodesConfigured).or_else(|resp| {
error!(
target: LOG_TARGET,
"Failed to send outbound request as no bootstrap nodes were configured"
);
Err(resp)
}));
},
None => {
let _ = reply_tx
.send(Err(MempoolServiceError::BroadcastFailed))
.or_else(|resp| {
error!(
target: LOG_TARGET,
"Failed to send outbound request because DHT outbound broadcast failed"
);
Err(resp)
});
},
}
Ok(())
}
async fn handle_incoming_tx<B: BlockchainBackend + 'static>(
mut inbound_handlers: MempoolInboundHandlers<B>,
domain_transaction_msg: DomainMessage<Transaction>,
) -> Result<(), MempoolServiceError>
{
let DomainMessage::<_> { source_peer, inner, .. } = domain_transaction_msg;
debug!(
"New transaction received: {}, from: {}",
inner.body.kernels()[0].excess_sig.get_signature().to_hex(),
source_peer.public_key,
);
trace!(
target: LOG_TARGET,
"New transaction: {}, from: {}",
inner,
source_peer.public_key
);
inbound_handlers
.handle_transaction(&inner, Some(source_peer.public_key))
.await?;
Ok(())
}
async fn handle_request_timeout(
waiting_requests: WaitingRequests<Result<MempoolResponse, MempoolServiceError>>,
request_key: RequestKey,
) -> Result<(), MempoolServiceError>
{
if let Some(reply_tx) = waiting_requests.remove(request_key)? {
let reply_msg = Err(MempoolServiceError::RequestTimedOut);
let _ = reply_tx.send(reply_msg.or_else(|resp| {
error!(
target: LOG_TARGET,
"Failed to send outbound request (request key: {}): {:?}", &request_key, resp
);
Err(resp)
}));
}
Ok(())
}
async fn handle_outbound_tx(
mut outbound_message_service: OutboundMessageRequester,
tx: Transaction,
exclude_peers: Vec<CommsPublicKey>,
) -> Result<(), MempoolServiceError>
{
outbound_message_service
.propagate(
NodeDestination::Unknown,
OutboundEncryption::None,
exclude_peers,
OutboundDomainMessage::new(TariMessageType::NewTransaction, ProtoTransaction::from(tx)),
)
.await
.or_else(|e| {
error!(target: LOG_TARGET, "Handle outbound tx failure. {:?}", e);
Err(e)
})
.map_err(|e| MempoolServiceError::OutboundMessageService(e.to_string()))
.map(|_| ())
}
async fn handle_block_event<B: BlockchainBackend + 'static>(
mut inbound_handlers: MempoolInboundHandlers<B>,
block_event: &BlockEvent,
) -> Result<(), MempoolServiceError>
{
inbound_handlers.handle_block_event(block_event).await?;
Ok(())
}
fn spawn_request_timeout(mut timeout_sender: Sender<RequestKey>, request_key: RequestKey, timeout: Duration) {
task::spawn(async move {
tokio::time::delay_for(timeout).await;
let _ = timeout_sender.send(request_key).await;
});
}
|
#[doc = "Reader of register CTL"]
pub type R = crate::R<u32, super::CTL>;
#[doc = "Writer for register CTL"]
pub type W = crate::W<u32, super::CTL>;
#[doc = "Register CTL `reset()`'s with value 0"]
impl crate::ResetValue for super::CTL {
type Type = u32;
#[inline(always)]
fn reset_value() -> Self::Type {
0
}
}
#[doc = "Reader of field `UARTEN`"]
pub type UARTEN_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `UARTEN`"]
pub struct UARTEN_W<'a> {
w: &'a mut W,
}
impl<'a> UARTEN_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !0x01) | ((value as u32) & 0x01);
self.w
}
}
#[doc = "Reader of field `SIREN`"]
pub type SIREN_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `SIREN`"]
pub struct SIREN_W<'a> {
w: &'a mut W,
}
impl<'a> SIREN_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 1)) | (((value as u32) & 0x01) << 1);
self.w
}
}
#[doc = "Reader of field `SIRLP`"]
pub type SIRLP_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `SIRLP`"]
pub struct SIRLP_W<'a> {
w: &'a mut W,
}
impl<'a> SIRLP_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 2)) | (((value as u32) & 0x01) << 2);
self.w
}
}
#[doc = "Reader of field `SMART`"]
pub type SMART_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `SMART`"]
pub struct SMART_W<'a> {
w: &'a mut W,
}
impl<'a> SMART_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 3)) | (((value as u32) & 0x01) << 3);
self.w
}
}
#[doc = "Reader of field `EOT`"]
pub type EOT_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `EOT`"]
pub struct EOT_W<'a> {
w: &'a mut W,
}
impl<'a> EOT_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 4)) | (((value as u32) & 0x01) << 4);
self.w
}
}
#[doc = "Reader of field `HSE`"]
pub type HSE_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `HSE`"]
pub struct HSE_W<'a> {
w: &'a mut W,
}
impl<'a> HSE_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 5)) | (((value as u32) & 0x01) << 5);
self.w
}
}
#[doc = "Reader of field `LBE`"]
pub type LBE_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `LBE`"]
pub struct LBE_W<'a> {
w: &'a mut W,
}
impl<'a> LBE_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 7)) | (((value as u32) & 0x01) << 7);
self.w
}
}
#[doc = "Reader of field `TXE`"]
pub type TXE_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `TXE`"]
pub struct TXE_W<'a> {
w: &'a mut W,
}
impl<'a> TXE_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 8)) | (((value as u32) & 0x01) << 8);
self.w
}
}
#[doc = "Reader of field `RXE`"]
pub type RXE_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `RXE`"]
pub struct RXE_W<'a> {
w: &'a mut W,
}
impl<'a> RXE_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 9)) | (((value as u32) & 0x01) << 9);
self.w
}
}
#[doc = "Reader of field `DTR`"]
pub type DTR_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `DTR`"]
pub struct DTR_W<'a> {
w: &'a mut W,
}
impl<'a> DTR_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 10)) | (((value as u32) & 0x01) << 10);
self.w
}
}
#[doc = "Reader of field `RTS`"]
pub type RTS_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `RTS`"]
pub struct RTS_W<'a> {
w: &'a mut W,
}
impl<'a> RTS_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 11)) | (((value as u32) & 0x01) << 11);
self.w
}
}
#[doc = "Reader of field `RTSEN`"]
pub type RTSEN_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `RTSEN`"]
pub struct RTSEN_W<'a> {
w: &'a mut W,
}
impl<'a> RTSEN_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 14)) | (((value as u32) & 0x01) << 14);
self.w
}
}
#[doc = "Reader of field `CTSEN`"]
pub type CTSEN_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `CTSEN`"]
pub struct CTSEN_W<'a> {
w: &'a mut W,
}
impl<'a> CTSEN_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 15)) | (((value as u32) & 0x01) << 15);
self.w
}
}
impl R {
#[doc = "Bit 0 - UART Enable"]
#[inline(always)]
pub fn uarten(&self) -> UARTEN_R {
UARTEN_R::new((self.bits & 0x01) != 0)
}
#[doc = "Bit 1 - UART SIR Enable"]
#[inline(always)]
pub fn siren(&self) -> SIREN_R {
SIREN_R::new(((self.bits >> 1) & 0x01) != 0)
}
#[doc = "Bit 2 - UART SIR Low-Power Mode"]
#[inline(always)]
pub fn sirlp(&self) -> SIRLP_R {
SIRLP_R::new(((self.bits >> 2) & 0x01) != 0)
}
#[doc = "Bit 3 - ISO 7816 Smart Card Support"]
#[inline(always)]
pub fn smart(&self) -> SMART_R {
SMART_R::new(((self.bits >> 3) & 0x01) != 0)
}
#[doc = "Bit 4 - End of Transmission"]
#[inline(always)]
pub fn eot(&self) -> EOT_R {
EOT_R::new(((self.bits >> 4) & 0x01) != 0)
}
#[doc = "Bit 5 - High-Speed Enable"]
#[inline(always)]
pub fn hse(&self) -> HSE_R {
HSE_R::new(((self.bits >> 5) & 0x01) != 0)
}
#[doc = "Bit 7 - UART Loop Back Enable"]
#[inline(always)]
pub fn lbe(&self) -> LBE_R {
LBE_R::new(((self.bits >> 7) & 0x01) != 0)
}
#[doc = "Bit 8 - UART Transmit Enable"]
#[inline(always)]
pub fn txe(&self) -> TXE_R {
TXE_R::new(((self.bits >> 8) & 0x01) != 0)
}
#[doc = "Bit 9 - UART Receive Enable"]
#[inline(always)]
pub fn rxe(&self) -> RXE_R {
RXE_R::new(((self.bits >> 9) & 0x01) != 0)
}
#[doc = "Bit 10 - Data Terminal Ready"]
#[inline(always)]
pub fn dtr(&self) -> DTR_R {
DTR_R::new(((self.bits >> 10) & 0x01) != 0)
}
#[doc = "Bit 11 - Request to Send"]
#[inline(always)]
pub fn rts(&self) -> RTS_R {
RTS_R::new(((self.bits >> 11) & 0x01) != 0)
}
#[doc = "Bit 14 - Enable Request to Send"]
#[inline(always)]
pub fn rtsen(&self) -> RTSEN_R {
RTSEN_R::new(((self.bits >> 14) & 0x01) != 0)
}
#[doc = "Bit 15 - Enable Clear To Send"]
#[inline(always)]
pub fn ctsen(&self) -> CTSEN_R {
CTSEN_R::new(((self.bits >> 15) & 0x01) != 0)
}
}
impl W {
#[doc = "Bit 0 - UART Enable"]
#[inline(always)]
pub fn uarten(&mut self) -> UARTEN_W {
UARTEN_W { w: self }
}
#[doc = "Bit 1 - UART SIR Enable"]
#[inline(always)]
pub fn siren(&mut self) -> SIREN_W {
SIREN_W { w: self }
}
#[doc = "Bit 2 - UART SIR Low-Power Mode"]
#[inline(always)]
pub fn sirlp(&mut self) -> SIRLP_W {
SIRLP_W { w: self }
}
#[doc = "Bit 3 - ISO 7816 Smart Card Support"]
#[inline(always)]
pub fn smart(&mut self) -> SMART_W {
SMART_W { w: self }
}
#[doc = "Bit 4 - End of Transmission"]
#[inline(always)]
pub fn eot(&mut self) -> EOT_W {
EOT_W { w: self }
}
#[doc = "Bit 5 - High-Speed Enable"]
#[inline(always)]
pub fn hse(&mut self) -> HSE_W {
HSE_W { w: self }
}
#[doc = "Bit 7 - UART Loop Back Enable"]
#[inline(always)]
pub fn lbe(&mut self) -> LBE_W {
LBE_W { w: self }
}
#[doc = "Bit 8 - UART Transmit Enable"]
#[inline(always)]
pub fn txe(&mut self) -> TXE_W {
TXE_W { w: self }
}
#[doc = "Bit 9 - UART Receive Enable"]
#[inline(always)]
pub fn rxe(&mut self) -> RXE_W {
RXE_W { w: self }
}
#[doc = "Bit 10 - Data Terminal Ready"]
#[inline(always)]
pub fn dtr(&mut self) -> DTR_W {
DTR_W { w: self }
}
#[doc = "Bit 11 - Request to Send"]
#[inline(always)]
pub fn rts(&mut self) -> RTS_W {
RTS_W { w: self }
}
#[doc = "Bit 14 - Enable Request to Send"]
#[inline(always)]
pub fn rtsen(&mut self) -> RTSEN_W {
RTSEN_W { w: self }
}
#[doc = "Bit 15 - Enable Clear To Send"]
#[inline(always)]
pub fn ctsen(&mut self) -> CTSEN_W {
CTSEN_W { w: self }
}
}
|
use crate::dependencies::DomainResult;
use crate::dependencies::PostDb;
use async_trait::async_trait;
use mockall::*;
use serde::Serialize;
#[derive(Serialize, Clone)]
pub struct Post {
pub id: i32,
pub title: String,
pub body: String,
pub published: bool,
}
#[automock]
#[async_trait]
pub trait PostDomain {
async fn get_post(&self, post_id: i32) -> DomainResult<Option<Post>>;
async fn get_posts(&self, show_all: bool) -> DomainResult<Vec<Post>>;
async fn create_post(&self, title: String, body: String) -> DomainResult<Post>;
async fn publish_post(&self, post_id: i32) -> DomainResult<Option<Post>>;
async fn unpublish_post(&self, post_id: i32) -> DomainResult<Option<Post>>;
}
pub fn new_post_domain(post_db: impl PostDb + Send + Sync) -> impl PostDomain {
PostDomainImpl { post_db }
}
struct PostDomainImpl<P: PostDb> {
post_db: P,
}
#[async_trait]
impl<P: PostDb + Send + Sync> PostDomain for PostDomainImpl<P> {
async fn get_post(&self, post_id: i32) -> DomainResult<Option<Post>> {
self.post_db.get_post_by_id(post_id).await
}
async fn get_posts(&self, show_all: bool) -> DomainResult<Vec<Post>> {
self.post_db.get_posts(show_all).await
}
async fn create_post(&self, title: String, body: String) -> DomainResult<Post> {
self.post_db.create_post(title, body).await
}
async fn publish_post(&self, post_id: i32) -> DomainResult<Option<Post>> {
let post = self.post_db.get_post_by_id(post_id).await?;
if let Some(post) = post.clone() {
if !post.published {
return self.post_db.post_set_published(post_id, true).await;
}
}
Ok(post)
}
async fn unpublish_post(&self, post_id: i32) -> DomainResult<Option<Post>> {
let post = self.post_db.get_post_by_id(post_id).await?;
if let Some(post) = post.clone() {
if post.published {
return self.post_db.post_set_published(post_id, false).await;
}
}
Ok(post)
}
}
|
use winapi::shared::{
windef::HBRUSH,
minwindef::{WPARAM, LPARAM}
};
use winapi::um::{
winuser::{WS_VISIBLE, WS_TABSTOP},
wingdi::DeleteObject,
};
use winapi::um::commctrl::{TBS_AUTOTICKS, TBS_VERT, TBS_HORZ, TBS_TOP, TBS_BOTTOM, TBS_LEFT, TBS_RIGHT, TBS_NOTICKS, TBS_ENABLESELRANGE};
use crate::win32::window_helper as wh;
use crate::win32::base_helper::check_hwnd;
use crate::{NwgError, RawEventHandler};
use super::{ControlBase, ControlHandle};
use std::cell::RefCell;
use std::ops::Range;
const NOT_BOUND: &'static str = "TrackBar is not yet bound to a winapi object";
const BAD_HANDLE: &'static str = "INTERNAL ERROR: TrackBar handle is not HWND!";
bitflags! {
/**
The track bar flags
*/
pub struct TrackBarFlags: u32 {
const VISIBLE = WS_VISIBLE;
const AUTO_TICK = TBS_AUTOTICKS;
const VERTICAL = TBS_VERT;
const HORIZONTAL = TBS_HORZ;
const TICK_TOP = TBS_TOP;
const TICK_BOTTOM = TBS_BOTTOM;
const TICK_LEFT = TBS_LEFT;
const TICK_RIGHT = TBS_RIGHT;
const NO_TICK = TBS_NOTICKS;
const RANGE = TBS_ENABLESELRANGE;
const TAB_STOP = WS_TABSTOP;
}
}
/**
A trackbar is a window that contains a slider (sometimes called a thumb) in a channel, and optional tick marks.
When the user moves the slider, using either the mouse or the direction keys, the trackbar sends notification messages to indicate the change.
Requires the `trackbar` feature.
**Builder parameters:**
* `parent`: **Required.** The trackbar parent container.
* `size`: The trackbar size.
* `position`: The trackbar position.
* `focus`: The control receive focus after being created
* `flags`: A combination of the TrackBarFlags values.
* `ex_flags`: A combination of win32 window extended flags. Unlike `flags`, ex_flags must be used straight from winapi
* `range`: The value range of the trackbar
* `selected_range`: The selected value range of the trackbar. Used with `TrackBarFlags::RANGE`
* `pos`: The current value of the trackbar
* `background_color`: The background color the of the trackbar
**Control events:**
* `OnVerticalScroll`: When the value of a trackbar with the VERTICAL flags is changed
* `OnHorizontalScroll`: When the value of a trackbar with the HORIZONTAL flags is changed
* `MousePress(_)`: Generic mouse press events on the button
* `OnMouseMove`: Generic mouse mouse event
* `OnMouseWheel`: Generic mouse wheel event
```rust
use native_windows_gui as nwg;
fn build_trackbar(track: &mut nwg::TrackBar, window: &nwg::Window) {
nwg::TrackBar::builder()
.range(Some(0..100))
.pos(Some(10))
.parent(window)
.build(track);
}
```
*/
#[derive(Default)]
pub struct TrackBar {
pub handle: ControlHandle,
background_brush: Option<HBRUSH>,
handler0: RefCell<Option<RawEventHandler>>,
}
impl TrackBar {
pub fn builder() -> TrackBarBuilder {
TrackBarBuilder {
size: (100, 20),
position: (0, 0),
focus: false,
range: None,
selected_range: None,
pos: None,
flags: None,
ex_flags: 0,
parent: None,
background_color: None
}
}
/// Retrieves the current logical position of the slider in a trackbar.
/// The logical positions are the integer values in the trackbar's range of minimum to maximum slider positions.
pub fn pos(&self) -> usize {
use winapi::um::commctrl::TBM_GETPOS;
let handle = check_hwnd(&self.handle, NOT_BOUND, BAD_HANDLE);
wh::send_message(handle, TBM_GETPOS, 0, 0) as usize
}
/// Sets the current logical position of the slider in a trackbar.
pub fn set_pos(&self, p: usize) {
use winapi::um::commctrl::TBM_SETPOSNOTIFY;
let handle = check_hwnd(&self.handle, NOT_BOUND, BAD_HANDLE);
wh::send_message(handle, TBM_SETPOSNOTIFY, 1, p as LPARAM);
}
/// Retrieves the starting and ending position of the current selection range in a trackbar.
/// Only work for trackbar with the `Range` flags
pub fn selection_range_pos(&self) -> Range<usize> {
use winapi::um::commctrl::{TBM_GETSELEND, TBM_GETSELSTART};
let handle = check_hwnd(&self.handle, NOT_BOUND, BAD_HANDLE);
let end = wh::send_message(handle, TBM_GETSELEND, 0, 0) as usize;
let start = wh::send_message(handle, TBM_GETSELSTART, 0, 0) as usize;
start..end
}
/// Sets the range value of the trackbar
/// Only work for trackbar with the `Range` flags
pub fn set_selection_range_pos(&self, value: Range<usize>) {
use winapi::um::commctrl::{TBM_SETSELEND, TBM_SETSELSTART};
let handle = check_hwnd(&self.handle, NOT_BOUND, BAD_HANDLE);
wh::send_message(handle, TBM_SETSELEND, 0, value.end as LPARAM);
wh::send_message(handle, TBM_SETSELSTART, 1, value.start as LPARAM);
}
/// Retrieves the minimum position for the slider in a trackbar.
pub fn range_min(&self) -> usize {
use winapi::um::commctrl::TBM_GETRANGEMIN;
let handle = check_hwnd(&self.handle, NOT_BOUND, BAD_HANDLE);
wh::send_message(handle, TBM_GETRANGEMIN, 0, 0) as usize
}
/// Sets the minium logical position for the slider in a trackbar.
pub fn set_range_min(&self, min: usize) {
use winapi::um::commctrl::TBM_SETRANGEMIN;
let handle = check_hwnd(&self.handle, NOT_BOUND, BAD_HANDLE);
wh::send_message(handle, TBM_SETRANGEMIN, 1, min as LPARAM);
}
/// Retrieves the maximum position for the slider in a trackbar.
pub fn range_max(&self) -> usize {
use winapi::um::commctrl::TBM_GETRANGEMAX;
let handle = check_hwnd(&self.handle, NOT_BOUND, BAD_HANDLE);
wh::send_message(handle, TBM_GETRANGEMAX, 0, 0) as usize
}
/// Sets the maximum logical position for the slider in a trackbar.
pub fn set_range_max(&self, max: usize) {
use winapi::um::commctrl::TBM_SETRANGEMAX;
let handle = check_hwnd(&self.handle, NOT_BOUND, BAD_HANDLE);
wh::send_message(handle, TBM_SETRANGEMAX, 1, max as LPARAM);
}
/// Retrieves the number of tick marks in a trackbar
pub fn tics_len(&self) -> usize {
use winapi::um::commctrl::TBM_GETNUMTICS;
let handle = check_hwnd(&self.handle, NOT_BOUND, BAD_HANDLE);
wh::send_message(handle, TBM_GETNUMTICS, 0, 0) as usize
}
/// Retrieves the logical position of a tick mark in a trackbar.
/// The logical position can be any of the integer values in the trackbar's range of minimum to maximum slider positions.
pub fn tic_value(&self, index: usize) -> usize {
use winapi::um::commctrl::TBM_GETTIC;
let handle = check_hwnd(&self.handle, NOT_BOUND, BAD_HANDLE);
wh::send_message(handle, TBM_GETTIC, index as WPARAM, 0) as usize
}
//
// Basic methods
//
/// Return true if the control user can interact with the control, return false otherwise
pub fn enabled(&self) -> bool {
let handle = check_hwnd(&self.handle, NOT_BOUND, BAD_HANDLE);
unsafe { wh::get_window_enabled(handle) }
}
/// Enable or disable the control
pub fn set_enabled(&self, v: bool) {
let handle = check_hwnd(&self.handle, NOT_BOUND, BAD_HANDLE);
unsafe { wh::set_window_enabled(handle, v) }
}
/// Return true if the control is visible to the user. Will return true even if the
/// control is outside of the parent client view (ex: at the position (10000, 10000))
pub fn visible(&self) -> bool {
let handle = check_hwnd(&self.handle, NOT_BOUND, BAD_HANDLE);
unsafe { wh::get_window_visibility(handle) }
}
/// Show or hide the control to the user
pub fn set_visible(&self, v: bool) {
let handle = check_hwnd(&self.handle, NOT_BOUND, BAD_HANDLE);
unsafe { wh::set_window_visibility(handle, v) }
}
/// Return the size of the button in the parent window
pub fn size(&self) -> (u32, u32) {
let handle = check_hwnd(&self.handle, NOT_BOUND, BAD_HANDLE);
unsafe { wh::get_window_size(handle) }
}
/// Set the size of the button in the parent window
pub fn set_size(&self, x: u32, y: u32) {
let handle = check_hwnd(&self.handle, NOT_BOUND, BAD_HANDLE);
unsafe { wh::set_window_size(handle, x, y, false) }
}
/// Return the position of the button in the parent window
pub fn position(&self) -> (i32, i32) {
let handle = check_hwnd(&self.handle, NOT_BOUND, BAD_HANDLE);
unsafe { wh::get_window_position(handle) }
}
/// Set the position of the button in the parent window
pub fn set_position(&self, x: i32, y: i32) {
let handle = check_hwnd(&self.handle, NOT_BOUND, BAD_HANDLE);
unsafe { wh::set_window_position(handle, x, y) }
}
/// Return true if the control currently has the keyboard focus
pub fn focus(&self) -> bool {
let handle = check_hwnd(&self.handle, NOT_BOUND, BAD_HANDLE);
unsafe { wh::get_focus(handle) }
}
/// Set the keyboard focus on the track bar
pub fn set_focus(&self) {
let handle = check_hwnd(&self.handle, NOT_BOUND, BAD_HANDLE);
unsafe { wh::set_focus(handle); }
}
/// Winapi class name used during control creation
pub fn class_name(&self) -> &'static str {
winapi::um::commctrl::TRACKBAR_CLASS
}
/// Winapi base flags used during window creation
pub fn flags(&self) -> u32 {
WS_VISIBLE | TBS_AUTOTICKS | WS_TABSTOP
}
/// Winapi flags required by the control
pub fn forced_flags(&self) -> u32 {
use winapi::um::winuser::{WS_CHILD};
WS_CHILD
}
/// Change the label background color to transparent.
fn hook_background_color(&mut self, c: [u8; 3]) {
use crate::bind_raw_event_handler_inner;
use winapi::um::winuser::{WM_CTLCOLORSTATIC};
use winapi::shared::{basetsd::UINT_PTR, windef::{HWND}, minwindef::LRESULT};
use winapi::um::wingdi::{CreateSolidBrush, RGB};
if self.handle.blank() { panic!("{}", NOT_BOUND); }
let handle = self.handle.hwnd().expect(BAD_HANDLE);
let parent_handle = ControlHandle::Hwnd(wh::get_window_parent(handle));
let brush = unsafe { CreateSolidBrush(RGB(c[0], c[1], c[2])) };
self.background_brush = Some(brush);
let handler = bind_raw_event_handler_inner(&parent_handle, handle as UINT_PTR, move |_hwnd, msg, _w, l| {
match msg {
WM_CTLCOLORSTATIC => {
let child = l as HWND;
if child == handle {
return Some(brush as LRESULT);
}
},
_ => {}
}
None
});
*self.handler0.borrow_mut() = Some(handler.unwrap());
}
}
impl Drop for TrackBar {
fn drop(&mut self) {
use crate::unbind_raw_event_handler;
let handler = self.handler0.borrow();
if let Some(h) = handler.as_ref() {
drop(unbind_raw_event_handler(h));
}
if let Some(bg) = self.background_brush {
unsafe { DeleteObject(bg as _); }
}
self.handle.destroy();
}
}
pub struct TrackBarBuilder {
size: (i32, i32),
position: (i32, i32),
focus: bool,
range: Option<Range<usize>>,
selected_range: Option<Range<usize>>,
pos: Option<usize>,
flags: Option<TrackBarFlags>,
ex_flags: u32,
parent: Option<ControlHandle>,
background_color: Option<[u8; 3]>,
}
impl TrackBarBuilder {
pub fn flags(mut self, flags: TrackBarFlags) -> TrackBarBuilder {
self.flags = Some(flags);
self
}
pub fn ex_flags(mut self, flags: u32) -> TrackBarBuilder {
self.ex_flags = flags;
self
}
pub fn size(mut self, size: (i32, i32)) -> TrackBarBuilder {
self.size = size;
self
}
pub fn position(mut self, pos: (i32, i32)) -> TrackBarBuilder {
self.position = pos;
self
}
pub fn focus(mut self, focus: bool) -> TrackBarBuilder {
self.focus = focus;
self
}
pub fn range(mut self, range: Option<Range<usize>>) -> TrackBarBuilder {
self.range = range;
self
}
pub fn selected_range(mut self, range: Option<Range<usize>>) -> TrackBarBuilder {
self.selected_range = range;
self
}
pub fn pos(mut self, pos: Option<usize>) -> TrackBarBuilder {
self.pos = pos;
self
}
pub fn parent<C: Into<ControlHandle>>(mut self, p: C) -> TrackBarBuilder {
self.parent = Some(p.into());
self
}
pub fn background_color(mut self, color: Option<[u8;3]>) -> TrackBarBuilder {
self.background_color = color;
self
}
pub fn build(self, out: &mut TrackBar) -> Result<(), NwgError> {
let flags = self.flags.map(|f| f.bits()).unwrap_or(out.flags());
let parent = match self.parent {
Some(p) => Ok(p),
None => Err(NwgError::no_parent("TrackBar"))
}?;
*out = Default::default();
out.handle = ControlBase::build_hwnd()
.class_name(out.class_name())
.forced_flags(out.forced_flags())
.flags(flags)
.ex_flags(self.ex_flags)
.size(self.size)
.position(self.position)
.parent(Some(parent))
.build()?;
if self.background_color.is_some() {
out.hook_background_color(self.background_color.unwrap());
}
if self.focus {
out.set_focus();
}
if let Some(range) = self.range {
out.set_range_min(range.start);
out.set_range_max(range.end);
}
if let Some(range) = self.selected_range {
out.set_selection_range_pos(range);
}
if let Some(pos) = self.pos {
out.set_pos(pos);
}
Ok(())
}
}
impl PartialEq for TrackBar {
fn eq(&self, other: &Self) -> bool {
self.handle == other.handle
}
}
|
//! Skills ページ
use yew::prelude::*;
pub struct Skills {}
impl Component for Skills {
type Message = ();
type Properties = ();
fn create(_: Self::Properties, _: ComponentLink<Self>) -> Self {
Self {}
}
fn update(&mut self, _: Self::Message) -> ShouldRender {
false
}
fn change(&mut self, _: Self::Properties) -> ShouldRender {
false
}
fn view(&self) -> Html {
html! {
<>
<h2>{"プログラミング言語"}</h2>
{"💪Rust/Python/Julia/C"}<br/>
{"👌C#/JavaScript(TypeScript)/C++/Java/OCaml/Matlab/Verilog/Visual Basic/Pascal"}
<h2>{"フレームワーク＆ライブラリ"}</h2>
{"PyTorch/NumPy/Chainer/Unity/Acitx/React etc."}
<h2>{"その他"}</h2>
{"Vim/Docker/LaTeX etc."}
</>
}
}
}
|
use colors::{ERROR_COLOR, SUCCESS_COLOR, WARN_COLOR};
use serenity::model::id::ChannelId;
use std::fmt::Display;
#[macro_export]
macro_rules! chain(
($y:expr; $( $x:expr ),*) => (
{
$(
$y = $x;
)*
$y
}
);
);
#[allow(dead_code)]
pub fn report_error<D: Display>(channel: ChannelId, message: D) {
let _ = channel.send_message(|m| {
m.embed(|e| {
e.color(ERROR_COLOR)
.title("Error! 😞 ")
.description(message)
})
});
}
pub fn warn<D: Display>(channel: ChannelId, message: D, title: Option<&str>) {
let _ = channel.send_message(|m| {
m.embed(|e| {
e.color(WARN_COLOR)
.title(title.unwrap_or("⚠"))
.description(message)
})
});
}
pub fn success<D: Display>(channel: ChannelId, message: D, title: Option<&str>) {
let _ = channel.send_message(|m| {
m.embed(|e| {
e.color(SUCCESS_COLOR)
.title(title.unwrap_or("😀"))
.description(message)
})
});
}
|
//! Query routing simulation application.
#![warn(
missing_docs,
trivial_casts,
trivial_numeric_casts,
unused_import_braces,
unused_qualifications
)]
#![warn(clippy::all, clippy::pedantic)]
#![allow(
clippy::module_name_repetitions,
clippy::default_trait_access,
clippy::inline_always
)]
use std::convert::TryFrom;
use std::fs::File;
use std::path::PathBuf;
use clap::Clap;
use eyre::{eyre, WrapErr};
use indicatif::ProgressBar;
use optimization::AssignmentResult;
use qrsim::{DispatcherOption, NodeId, NumCores, QueueType, SimulationConfig};
/// Runs query routing simulation.
#[derive(Clap)]
#[clap(version, author)]
struct Opt {
/// Path to a file containing query input data.
#[clap(long)]
queries_path: PathBuf,
/// Path to a file containing query events describing when queries arrrive at the broker.
#[clap(long)]
query_events_path: PathBuf,
/// List of nodes to disable at the beginning of the simulation.
#[clap(long)]
disabled_nodes: Vec<NodeId>,
/// Path to a file containing query events describing when queries arrrive at the broker.
#[clap(long, default_value = "8")]
num_cores: NumCores,
/// Path to a file containing node configuration in JSON array format.
/// Each element (node) contains the IDs of shards it contains.
#[clap(long)]
nodes: PathBuf,
/// Path to a file containing shard ranking scores for queries.
#[clap(long)]
shard_scores: Option<PathBuf>,
/// Output file where the query statistics will be stored in the CSV format.
#[clap(long)]
query_output: PathBuf,
/// Output file where the node-level statistics will be stored in the CSV format.
#[clap(long)]
node_output: PathBuf,
/// Verbosity.
#[clap(short, long, parse(from_occurrences))]
verbose: i32,
/// Dispatcher type.
#[clap(short, long)]
dispatcher: DispatcherOption,
/// File where to store the probability matrix solved by the probabilistic dispatcher.
#[clap(long)]
prob_matrix_output: Option<PathBuf>,
/// Store the logs this file.
#[clap(long)]
log_output: Option<PathBuf>,
/// Do not log to the stderr.
#[clap(long)]
no_stderr: bool,
/// Type of queue for incoming shard requests in nodes.
#[clap(long, default_value = "fifo")]
queue_type: QueueType,
}
impl TryFrom<Opt> for SimulationConfig {
type Error = eyre::Error;
fn try_from(opt: Opt) -> eyre::Result<Self> {
let nodes_file = File::open(&opt.nodes).wrap_err("unable to read node config")?;
let assignment: AssignmentResult =
serde_json::from_reader(nodes_file).wrap_err("unable to parse node config")?;
let max_shard = *assignment
.nodes
.iter()
.flatten()
.max()
.ok_or_else(|| eyre!("empty node config"))?;
let num_nodes = assignment.nodes.len();
Ok(Self {
label: qrsim::SimulationLabel::default(),
queries_path: opt.queries_path,
query_events_path: opt.query_events_path,
failure_events_path: None,
shard_scores_path: opt.shard_scores,
estimates: None,
query_output: opt.query_output,
node_output: opt.node_output,
num_cores: opt.num_cores,
assignment,
num_nodes,
num_shards: max_shard + 1,
dispatcher: opt.dispatcher,
disabled_nodes: opt.disabled_nodes,
queue_type: opt.queue_type,
selective: None,
shard_probabilities: None,
dispatch_overhead: std::time::Duration::default(),
recompute_policies: false,
probabilistic_recompute_delay: std::time::Duration::from_millis(0),
})
}
}
/// Set up a logger based on the given user options.
fn set_up_logger(opt: &Opt) -> Result<(), fern::InitError> {
let log_level = match opt.verbose {
1 => log::LevelFilter::Info,
2 => log::LevelFilter::Debug,
3 => log::LevelFilter::Trace,
_ => log::LevelFilter::Warn,
};
let dispatch = fern::Dispatch::new()
.format(|out, message, record| out.finish(format_args!("[{}] {}", record.level(), message)))
.level(log_level);
let dispatch = if let Some(path) = &opt.log_output {
let _ = std::fs::remove_file(path);
dispatch.chain(
std::fs::OpenOptions::new()
.write(true)
.create(true)
.append(false)
.open(path)?,
)
} else {
dispatch
};
let dispatch = if opt.no_stderr {
dispatch
} else {
dispatch.chain(std::io::stderr())
};
dispatch.apply()?;
Ok(())
}
fn main() -> eyre::Result<()> {
color_eyre::install()?;
let opt = Opt::parse();
if opt.prob_matrix_output.is_some() && opt.dispatcher != DispatcherOption::Probabilistic {
eyre::bail!("matrix output given but dispatcher is not probabilistic");
}
set_up_logger(&opt)?;
let conf = SimulationConfig::try_from(opt)?;
let pb = ProgressBar::new_spinner();
conf.run(&pb, &qrsim::MessageType::Verbose)
}
|
use crate::tokenize::{Token, TokenKind};
use crate::{Entry, Yaml, YamlParseError};
use core::iter::{Enumerate, Iterator, Peekable};
use core::slice::Iter;
use crate::Result;
// Implementation lifted from std, as it's currently only on Nightly. It's such a simple macro that it's low risk to duplicate it here (and better than writing one myself)
macro_rules! matches {
($expression:expr, $( $pattern:pat )|+ $( if $guard: expr )?) => {
match $expression {
$( $pattern )|+ $( if $guard )? => true,
_ => false
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum ParseContext {
Scalar,
FlowMapping,
FlowSequence,
Sequence,
Mapping,
}
pub(crate) struct Parser<'a, 'b> {
token: &'b Token<'a>,
stream: Peekable<Enumerate<Iter<'b, Token<'a>>>>,
tok_stream: &'b [Token<'a>],
source: &'a str,
tok_idx: usize,
indent: usize,
expected: Vec<TokenKind<'a>>,
contexts: Vec<ParseContext>,
}
impl<'a, 'b> Parser<'a, 'b> {
pub(crate) fn new(source: &'a str, tok_stream: &'b [Token<'a>]) -> Result<Self> {
let mut stream = tok_stream.iter().enumerate().peekable();
let first = stream.next().ok_or_else(|| YamlParseError {
line: 0,
col: 0,
msg: Some("expected input".into()),
source: None,
})?;
Ok(Self {
token: &first.1,
stream,
tok_stream,
source,
tok_idx: first.0,
indent: 0,
expected: Vec::new(),
contexts: Vec::new(),
})
}
fn start_context(&mut self, context: ParseContext) {
self.contexts.push(context)
}
fn end_context(&mut self, expect: ParseContext) -> Result<()> {
if let Some(actual) = self.contexts.pop() {
if actual == expect {
Ok(())
} else {
self.parse_error_with_msg(format!(
"expected but failed to end context {:?}, instead found {:?}",
expect, actual
))
}
} else {
self.parse_error_with_msg(format!(
"expected context {:?} but no contexts remained",
expect
))
}
}
fn context(&self) -> Option<ParseContext> {
self.contexts.last().map(|&c| c)
}
fn bump(&mut self) -> bool {
match self.stream.next() {
Some(tok) => {
self.tok_idx = tok.0;
self.token = tok.1;
true
}
None => false,
}
}
fn advance(&mut self) -> Result<()> {
if self.bump() {
Ok(())
} else {
self.parse_error_with_msg("unexpected end of input")
}
}
fn peek(&mut self) -> Option<&Token<'a>> {
self.stream.peek().map(|t| t.1)
}
fn at_end(&self) -> bool {
self.tok_idx == self.tok_stream.len() - 1
}
fn parse_mapping_maybe(&mut self, node: Yaml<'a>) -> Result<Yaml<'a>> {
use TokenKind::*;
self.chomp_whitespace();
match self.token.kind {
Colon
if match self.expected.last() {
Some(RightBrace) | Some(Colon) => false,
_ => true,
} =>
{
self.parse_mapping_block(node)
}
_ => Ok(node),
}
}
pub(crate) fn parse(&mut self) -> Result<Yaml<'a>> {
use TokenKind::*;
let res = match self.token.kind {
DoubleQuote | SingleQuote | Literal(..) => {
let node = self.parse_scalar()?;
self.parse_mapping_maybe(node)?
}
LeftBrace => {
self.expected.push(RightBrace);
let res = self.parse_mapping_flow()?;
if let Some(RightBrace) = self.expected.last() {
self.pop_if_match(&RightBrace)?;
}
self.parse_mapping_maybe(res)?
}
LeftBracket => {
let node = self.parse_sequence_flow()?;
self.parse_mapping_maybe(node)?
}
Dash => match self.peek() {
Some(Token { kind: Dash, .. }) => {
if self.check_ahead_n(2, |tk| matches!(tk, Dash)) {
self.bump();
self.bump();
self.bump();
self.parse()?
} else {
// TODO: Provide error message
return self.parse_error();
}
}
_ => self.parse_sequence_block()?,
},
RightBrace | RightBracket => {
return self
.parse_error_with_msg(format!(r#"unexpected symbol '{}'"#, self.token.kind))
}
Whitespace(amt) => {
self.indent = amt;
self.advance()?;
self.parse()?
}
Newline => {
self.chomp_newlines()?;
self.indent = 0;
self.parse()?
}
// TODO: Provide error message
_ => return self.parse_error(),
};
Ok(res)
}
pub(crate) fn parse_scalar(&mut self) -> Result<Yaml<'a>> {
use TakeUntilCond::*;
use TokenKind::*;
let context = self.context();
self.start_context(ParseContext::Scalar);
match self.token.kind {
// TODO: currently qouble quote/single quote scalars are handled identically. maybe handle as defined
// by the YAML spec?
DoubleQuote => {
let scal_start = self.tok_idx;
self.advance()?;
self.take_until(MatchOrErr, |tok, _| matches!(tok, DoubleQuote))?;
let scal_end = if self.bump() {
self.tok_idx
} else {
self.tok_stream.len()
};
let entire_literal = self.slice_tok_range((scal_start, scal_end));
self.end_context(ParseContext::Scalar)?;
Ok(Yaml::Scalar(entire_literal))
}
SingleQuote => {
let scal_start = self.tok_idx;
self.advance()?;
self.take_until(MatchOrErr, |tok, _| matches!(tok, SingleQuote))?;
let scal_end = if self.bump() {
self.tok_idx
} else {
self.tok_stream.len()
};
let entire_literal = self.slice_tok_range((scal_start, scal_end));
self.end_context(ParseContext::Scalar)?;
Ok(Yaml::Scalar(entire_literal))
}
Literal(..) => {
let stop: Box<dyn Fn(&TokenKind<'_>, &TokenKind<'_>) -> bool> = match context {
Some(ctx) => match ctx {
ParseContext::FlowSequence | ParseContext::FlowMapping => {
Box::new(|tok: &TokenKind<'_>, nxt: &TokenKind<'_>| {
tok.is_flow_indicator()
|| (tok.is_indicator()
&& matches!(nxt, TokenKind::Whitespace(..)))
|| (matches!(tok, TokenKind::Whitespace(..))
&& (nxt.is_indicator()
|| matches!(tok, TokenKind::Newline)))
})
}
ParseContext::Mapping | ParseContext::Sequence | ParseContext::Scalar => {
Box::new(|tok: &TokenKind<'_>, nxt: &TokenKind<'_>| {
(tok.is_indicator()
&& matches!(
nxt,
TokenKind::Whitespace(..) | TokenKind::Newline
))
|| matches!(tok, TokenKind::Newline)
|| (matches!(tok, TokenKind::Whitespace(..))
&& (nxt.is_indicator()
|| matches!(tok, TokenKind::Newline)))
})
}
},
None => Box::new(|tok: &TokenKind<'_>, nxt: &TokenKind<'_>| {
(tok.is_indicator()
&& matches!(nxt, TokenKind::Whitespace(..) | TokenKind::Newline))
|| matches!(tok, TokenKind::Newline)
|| (matches!(tok, TokenKind::Whitespace(..))
&& (nxt.is_indicator() || matches!(tok, TokenKind::Newline)))
}),
};
let scal_range = self.take_until(MatchOrEnd, stop)?;
let entire_literal = self.slice_tok_range(scal_range);
self.end_context(ParseContext::Scalar)?;
Ok(Yaml::Scalar(entire_literal))
}
// TODO: Provide error message
_ => self.parse_error_with_msg(format!(
r#"unexpectedly found "{}" when parsing scalar"#,
self.token.kind
)),
}
}
fn lookup_line_col(&self) -> (usize, usize) {
let err_off: usize = usize::from(self.token.start()) + 1;
let mut off = 0;
let mut line_len = 0;
let mut chars = self.source.chars().map(|c| (c, c.len_utf8()));
let mut line_lens = Vec::new();
while let Some((chr, len)) = chars.next() {
match chr {
'\r' => {
if let Some(('\n', nxtlen)) = chars.next() {
line_lens.push(line_len + nxtlen + len);
line_len = 0;
continue;
}
}
'\n' => {
line_lens.push(line_len + len);
line_len = 0;
continue;
}
_ => line_len += len,
}
}
let mut line_num = 0;
for ((line_no, _), len) in self.source.lines().enumerate().zip(line_lens) {
if err_off >= off && err_off < off + len {
return (line_no + 1, err_off - off + 1);
}
line_num = line_no;
off += len;
}
if err_off >= off {
return (line_num + 1, err_off - off + 1);
}
eprintln!("Couldn't find error location, please report this bug");
(0, 0)
}
fn parse_error<T>(&self) -> Result<T> {
let (line, col) = self.lookup_line_col();
Err(YamlParseError {
line,
col,
msg: Some(format!(
r#"unexpectedly found "{}" while parsing"#,
self.token.kind
)),
source: None,
})
}
fn parse_error_with_msg<T, S: Into<String>>(&self, msg: S) -> Result<T> {
let (line, col) = self.lookup_line_col();
Err(YamlParseError {
line,
col,
msg: Some(msg.into()),
source: None,
})
}
pub(crate) fn parse_mapping_flow(&mut self) -> Result<Yaml<'a>> {
use TokenKind::*;
self.start_context(ParseContext::FlowMapping);
match self.token.kind {
LeftBrace => (),
_ => return self.parse_error_with_msg("expected left brace"),
}
self.advance()?;
let mut entries: Vec<Entry<'a>> = Vec::new();
loop {
match self.token.kind {
RightBrace => {
self.bump();
self.end_context(ParseContext::FlowMapping)?;
return Ok(Yaml::Mapping(entries));
}
Comma => {
self.advance()?;
}
_ => {
self.expected.push(Colon);
let key = self.parse()?;
self.chomp_whitespace();
match self.token.kind {
Colon => {
self.pop_if_match(&Colon)?;
self.advance()?;
self.chomp_whitespace();
let value = self.parse()?;
self.chomp_whitespace();
entries.push(Entry { key, value })
}
// TODO: Provide error message
_ => return self.parse_error(),
}
}
}
}
}
pub(crate) fn parse_mapping_block(&mut self, start_key: Yaml<'a>) -> Result<Yaml<'a>> {
use TokenKind::*;
self.start_context(ParseContext::Mapping);
let indent = self.indent;
match self.token.kind {
Colon => {
self.advance()?;
let mut entries = Vec::new();
self.chomp_whitespace();
let value = self.parse()?;
entries.push(Entry::new(start_key, value));
loop {
match self.token.kind {
Newline => {
self.indent = 0;
if self.bump() {
continue;
} else {
break;
}
}
Whitespace(idt) => {
self.indent = idt;
if !self.bump() {
break;
}
}
_ if self.indent < indent || self.at_end() => break,
_ => {
self.expected.push(Colon);
let key = self.parse()?;
self.chomp_whitespace();
if let Colon = self.token.kind {
self.pop_if_match(&Colon)?;
self.advance()?;
self.chomp_whitespace();
let value = self.parse()?;
entries.push(Entry::new(key, value));
} else {
// TODO: Provide error message
return self.parse_error();
}
}
}
}
self.end_context(ParseContext::Mapping)?;
Ok(Yaml::Mapping(entries))
}
// TODO: Provide error message
_ => self.parse_error(),
}
}
fn slice_tok_range(&self, range: (usize, usize)) -> &'a str {
let start = self.tok_stream[range.0].start();
let end = match self.tok_stream.get(range.1) {
Some(tok) => tok.start(),
None => self.tok_stream.last().unwrap().end(),
};
&self.source[start.into()..end.into()]
}
fn chomp_whitespace(&mut self) {
while let TokenKind::Whitespace(..) = self.token.kind {
if !self.bump() {
break;
}
}
}
fn chomp_newlines(&mut self) -> Result<()> {
while let TokenKind::Newline = self.token.kind {
self.advance()?;
}
Ok(())
}
pub(crate) fn parse_sequence_flow(&mut self) -> Result<Yaml<'a>> {
use TokenKind::*;
self.start_context(ParseContext::FlowSequence);
match self.token.kind {
LeftBracket => {
self.advance()?;
let mut elements = Vec::new();
loop {
match self.token.kind {
RightBracket => {
self.bump();
self.end_context(ParseContext::FlowSequence)?;
return Ok(Yaml::Sequence(elements));
}
Whitespace(..) => {
self.advance()?;
}
_ => {
let elem = self.parse()?;
elements.push(elem);
self.chomp_whitespace();
match self.token.kind {
Comma => {
self.advance()?;
continue;
}
RightBracket => {
self.bump();
self.end_context(ParseContext::FlowSequence)?;
return Ok(Yaml::Sequence(elements));
}
// TODO: Provide error message
_ => return self.parse_error(),
}
}
}
}
}
// TODO: Provide error message
_ => self.parse_error(),
}
}
fn check_ahead_1(&mut self, stop: impl Fn(&TokenKind<'a>) -> bool) -> bool {
match self.peek() {
Some(tok) => stop(&tok.kind),
None => false,
}
}
pub(crate) fn parse_sequence_block(&mut self) -> Result<Yaml<'a>> {
use TokenKind::*;
self.start_context(ParseContext::Sequence);
let indent = self.indent;
match self.token.kind {
Dash => {
let mut seq = Vec::new();
loop {
match self.token.kind {
Newline => {
self.indent = 0;
if self.bump() {
continue;
} else {
break;
}
}
Whitespace(idt) => {
self.indent = idt;
if !self.bump() {
break;
}
}
_ if self.indent < indent || self.at_end() => break,
Dash => {
if self.check_ahead_1(|t| matches!(t, Newline)) {
self.advance()?;
self.advance()?;
self.indent = 0;
if let Whitespace(idt) = self.token.kind {
if idt < indent {
break;
} else {
let node = self.parse()?;
seq.push(node);
}
} else if 0 < indent {
break;
} else {
let node = self.parse()?;
seq.push(node);
}
} else {
self.advance()?;
let node = self.parse()?;
seq.push(node);
}
}
_ => return self.parse_error(),
}
}
self.end_context(ParseContext::Sequence)?;
Ok(Yaml::Sequence(seq))
}
// TODO: Provide error message
_ => self.parse_error(),
}
}
fn check_ahead_n(&self, n: usize, stop: impl Fn(&TokenKind<'a>) -> bool) -> bool {
match self.tok_stream.get(self.tok_idx + n) {
Some(Token { kind: tok_kind, .. }) => stop(tok_kind),
None => false,
}
}
fn peekahead_n(&self, n: usize) -> Option<&TokenKind<'a>> {
match self.tok_stream.get(self.tok_idx + n) {
Some(Token { kind: tok_kind, .. }) => Some(tok_kind),
None => None,
}
}
fn take_until(
&mut self,
cond: TakeUntilCond,
stop: impl Fn(&TokenKind<'a>, &TokenKind<'a>) -> bool,
) -> Result<(usize, usize)> {
let start = self.tok_idx;
let mut end = start;
loop {
let peeked = self.peekahead_n(1);
if match peeked {
Some(tok_kind) => stop(&self.token.kind, tok_kind),
None => stop(&self.token.kind, &TokenKind::default()),
} {
break;
} else if !self.bump() {
return match cond {
TakeUntilCond::MatchOrEnd => Ok((start, self.tok_stream.len())),
// TODO: Provide error message
TakeUntilCond::MatchOrErr => self.parse_error(),
};
}
end += 1;
}
Ok((start, end))
}
fn pop_if_match(&mut self, expect: &TokenKind<'a>) -> Result<()> {
match self.expected.last() {
Some(tk) if tk == expect => {
self.expected.pop();
Ok(())
}
// TODO: Provide error message
_ => self.parse_error(),
}
}
}
#[derive(Clone, Copy)]
enum TakeUntilCond {
MatchOrEnd,
MatchOrErr,
}
|
// Copyright 2022 Datafuse Labs.
//
// 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.
use std::sync::Arc;
use common_catalog::table_context::TableContext;
use common_exception::Result;
use common_expression::DataBlock;
use common_expression::DataSchemaRef;
use common_expression::Expr;
use common_expression::Scalar as DataScalar;
use common_sql::evaluator::BlockOperator;
use common_sql::evaluator::CompoundBlockOperator;
use crate::pipelines::processors::port::InputPort;
use crate::pipelines::processors::port::OutputPort;
use crate::pipelines::processors::processor::ProcessorPtr;
use crate::pipelines::processors::transforms::transform::Transform;
use crate::pipelines::processors::transforms::transform::Transformer;
use crate::sessions::QueryContext;
pub struct TransformAddConstColumns {
expression_transform: CompoundBlockOperator,
input_len: usize,
}
impl TransformAddConstColumns
where Self: Transform
{
/// used in insert with with placeholder.
/// e.g. for `insert into t1 (a, b, c) values (?, 1, ?)`,
/// output_schema has all 3 columns,
/// input_schema has columns (a, c) to load data from attachment,
/// const_values contains a scalar 1
pub fn try_create(
ctx: Arc<QueryContext>,
input: Arc<InputPort>,
output: Arc<OutputPort>,
input_schema: DataSchemaRef,
output_schema: DataSchemaRef,
mut const_values: Vec<DataScalar>,
) -> Result<ProcessorPtr> {
let fields = output_schema.fields();
let mut exprs = Vec::with_capacity(fields.len());
for f in fields.iter() {
let expr = if !input_schema.has_field(f.name()) {
Expr::Constant {
span: None,
scalar: const_values.remove(0),
data_type: f.data_type().clone(),
}
} else {
let field = input_schema.field_with_name(f.name()).unwrap();
let id = input_schema.index_of(f.name()).unwrap();
Expr::ColumnRef {
span: None,
id,
data_type: field.data_type().clone(),
display_name: field.name().clone(),
}
};
exprs.push(expr);
}
let func_ctx = ctx.get_function_context()?;
let expression_transform = CompoundBlockOperator {
ctx: func_ctx,
operators: vec![BlockOperator::Map { exprs }],
};
Ok(ProcessorPtr::create(Transformer::create(
input,
output,
Self {
expression_transform,
input_len: input_schema.num_fields(),
},
)))
}
}
impl Transform for TransformAddConstColumns {
const NAME: &'static str = "AddConstColumnsTransform";
fn transform(&mut self, mut block: DataBlock) -> Result<DataBlock> {
block = self.expression_transform.transform(block)?;
let columns = block.columns()[self.input_len..].to_owned();
Ok(DataBlock::new(columns, block.num_rows()))
}
}
|
use engine::{self, EngineMessage};
use transform::Transform;
use std::f32::consts::PI;
use std::fmt::{self, Debug, Formatter};
use std::marker::PhantomData;
use std::mem;
use std::ops::{Deref, DerefMut};
use std::ptr::Unique;
pub struct Camera {
data: Unique<CameraData>,
// Pretend `Camera` owns a raw pointer to default implementation for `Sync`.
// TODO: Remove this once negative trait bounds are stabilized.
_phantom: PhantomData<*mut ()>,
}
impl Camera {
pub fn new(transform: &Transform) -> Camera {
let mut camera_data = Box::new(CameraData::default());
let ptr = &mut *camera_data as *mut _;
engine::send_message(EngineMessage::Camera(camera_data, transform.inner()));
Camera {
data: unsafe { Unique::new(ptr) },
_phantom: PhantomData,
}
}
pub fn forget(self) {
mem::forget(self);
}
}
unsafe impl Send for Camera {}
impl Debug for Camera {
fn fmt(&self, fmt: &mut Formatter) -> Result<(), fmt::Error> {
let data = unsafe { self.data.get() };
fmt.debug_struct("Camera")
.field("fov", &data.fov)
.field("aspect", &data.aspect)
.field("near", &data.near)
.field("far", &data.far)
.finish()
}
}
impl Deref for Camera {
type Target = CameraData;
fn deref(&self) -> &CameraData { unsafe { self.data.get() } }
}
impl DerefMut for Camera {
fn deref_mut(&mut self) -> &mut CameraData { unsafe { self.data.get_mut() } }
}
#[derive(Debug)]
pub struct CameraData {
fov: f32,
aspect: f32,
near: f32,
far: f32,
}
impl CameraData {
pub fn fov(&self) -> f32 { self.fov }
pub fn aspect(&self) -> f32 { self.aspect }
pub fn near(&self) -> f32 { self.near }
pub fn far(&self) -> f32 { self.far }
}
impl Default for CameraData {
fn default() -> CameraData {
CameraData {
fov: PI / 3.0,
aspect: 1.0,
near: 0.001,
far: 1_000.0,
}
}
}
|
// SPDX-License-Identifier: Apache-2.0 AND MIT
//! `Client` and `Connection` structs
use std::default::Default;
/// A [non-consuming] [Connection] builder.
///
/// [Connection]: struct.Connection.html
/// [non-consuming]: https://doc.rust-lang.org/1.0.0/style/ownership/builders.html#non-consuming-builders-(preferred):
pub struct Client {
props: lapin::ConnectionProperties,
}
impl Client {
pub fn new() -> Self {
Self {
..Default::default()
}
}
pub async fn connect(&self, uri: &str) -> crate::Result<Connection> {
let c = lapin::Connection::connect(uri, self.props.clone())
.await
.map_err(crate::Error::from)?;
Ok(Connection(c))
}
}
impl Default for Client {
fn default() -> Self {
Self {
props: lapin::ConnectionProperties::default(),
}
}
}
/// A [non-consuming] [ProducerBuilder] and [ConsumerBuilder] builder.
///
/// [ProducerBuilder]: ../produce/struct.ProducerBuilder.html
/// [ConsumerBuilder]: ../consume/struct.ConsumerBuilder.html
/// [non-consuming]: https://doc.rust-lang.org/1.0.0/style/ownership/builders.html#non-consuming-builders-(preferred):
#[derive(Clone)]
pub struct Connection(lapin::Connection);
#[derive(Clone)]
pub struct QueueOptions {
pub kind: lapin::ExchangeKind,
pub ex_opts: lapin::options::ExchangeDeclareOptions,
pub ex_field: lapin::types::FieldTable,
pub queue_opts: lapin::options::QueueDeclareOptions,
pub queue_field: lapin::types::FieldTable,
pub bind_opts: lapin::options::QueueBindOptions,
pub bind_field: lapin::types::FieldTable,
}
impl Connection {
/// Build a [non-consuming] [ProducerBuilder].
///
/// [ProducerBuilder]: ../consume/struct.ProducerBuilder.html
/// [non-consuming]: https://doc.rust-lang.org/1.0.0/style/ownership/builders.html#non-consuming-builders-(preferred):
pub fn producer_builder(&self) -> crate::ProducerBuilder {
crate::ProducerBuilder::new(self.clone())
}
/// Build a [non-consuming] [ConsumerBuilder].
///
/// [ConsumerBuilder]: ../consume/struct.ConsumerBuilder.html
/// [non-consuming]: https://doc.rust-lang.org/1.0.0/style/ownership/builders.html#non-consuming-builders-(preferred):
pub fn consumer_builder(&self) -> crate::ConsumerBuilder {
crate::ConsumerBuilder::new(self.clone())
}
/// channel creates a channel over the [Connection]
/// and returns the `Future<Output = <lapin::Channel>>`.
pub async fn channel(&self) -> crate::Result<lapin::Channel> {
self.0.create_channel().await.map_err(crate::Error::from)
}
/// queue creates a channel and a queue over the [Connection]
/// and returns the `Future<Output = <lapin::Channel, lapin::Queue>>`.
pub async fn queue(
&self,
ex: &str,
queue: &str,
opts: QueueOptions,
) -> crate::Result<(lapin::Channel, lapin::Queue)> {
let ch = self.0.create_channel().await.map_err(crate::Error::from)?;
let q = ch
.queue_declare(queue, opts.queue_opts, opts.queue_field)
.await
.map_err(crate::Error::from)?;
if Self::is_default_exchange(ex) {
// We don't need to bind to the exchange in case of the default
// exchange.
return Ok((ch, q));
}
ch.exchange_declare(ex, opts.kind, opts.ex_opts, opts.ex_field)
.await
.map_err(crate::Error::from)?;
let routing_key = if Self::is_ephemeral_queue(queue) {
q.name().as_str()
} else {
queue
};
ch.queue_bind(
queue,
ex,
routing_key,
opts.bind_opts.clone(),
opts.bind_field.clone(),
)
.await
.map_err(crate::Error::from)?;
Ok((ch, q))
}
fn is_default_exchange(name: &str) -> bool {
name == crate::DEFAULT_EXCHANGE
}
fn is_ephemeral_queue(name: &str) -> bool {
name == crate::EPHEMERAL_QUEUE
}
}
|
mod hoge;
pub use hoge::*;
|
use rusoto_core::RusotoError;
use std::time::Duration;
use std::fmt;
use rusoto_iam::{
Iam,
ListServiceSpecificCredentialsRequest,
ListServiceSpecificCredentialsError,
ServiceSpecificCredential,
ServiceSpecificCredentialMetadata,
CreateServiceSpecificCredentialRequest,
CreateServiceSpecificCredentialError,
ResetServiceSpecificCredentialRequest,
ResetServiceSpecificCredentialError,
UpdateServiceSpecificCredentialRequest,
UpdateServiceSpecificCredentialError,
};
use crate::IAM_CLIENT;
#[derive(Debug, Clone, PartialEq)]
pub enum CredentialStatus {
Active,
Inactive,
Unknown(String),
}
impl From<&str> for CredentialStatus {
fn from(s: &str) -> CredentialStatus {
match s {
"Active" => CredentialStatus::Active,
"Inactive" => CredentialStatus::Inactive,
s => CredentialStatus::Unknown(s.to_string())
}
}
}
impl Into<String> for CredentialStatus {
fn into(self) -> String {
match self {
CredentialStatus::Active => "Active".to_string(),
CredentialStatus::Inactive => "Inactive".to_string(),
CredentialStatus::Unknown(s) => s,
}
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct CredentialMetadata {
pub create_date: String,
pub service_name: String,
pub service_specific_credential_id: String,
pub service_user_name: String,
pub status: CredentialStatus,
pub user_name: String,
}
impl From<ServiceSpecificCredentialMetadata> for CredentialMetadata {
fn from(m: ServiceSpecificCredentialMetadata) -> CredentialMetadata {
CredentialMetadata {
create_date: m.create_date,
service_name: m.service_name,
service_specific_credential_id: m.service_specific_credential_id,
service_user_name: m.service_user_name,
status: CredentialStatus::from(&m.status[..]),
user_name: m.user_name,
}
}
}
#[derive(Clone, PartialEq)]
pub struct Credential {
pub create_date: String,
pub service_name: String,
pub service_password: String,
pub service_specific_credential_id: String,
pub service_user_name: String,
pub status: CredentialStatus,
pub user_name: String,
}
impl From<ServiceSpecificCredential> for Credential {
fn from(m: ServiceSpecificCredential) -> Credential {
Credential {
create_date: m.create_date,
service_name: m.service_name,
service_password: m.service_password,
service_specific_credential_id: m.service_specific_credential_id,
service_user_name: m.service_user_name,
status: CredentialStatus::from(&m.status[..]),
user_name: m.user_name,
}
}
}
#[derive(Debug, Clone, PartialEq)]
pub enum IamError {
EntityNotFound {
message: String,
},
ServiceNotSupported {
message: String,
},
LimitExceeded {
message: String,
},
RusotoError {
message: String,
},
MissingCredentialInResponse,
}
impl fmt::Display for IamError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "iam error: {:?}", self)
}
}
impl std::error::Error for IamError {
}
pub type IamResult<T> = std::result::Result<T, IamError>;
pub fn list_service_specific_credentials(user_name: Option<&str>, service_name: Option<&str>, timeout: Duration) -> IamResult<Vec<CredentialMetadata>> {
info!("listing service specific credentials user_name={:?} service_name={:?}", user_name, service_name);
IAM_CLIENT.list_service_specific_credentials(ListServiceSpecificCredentialsRequest {
service_name: service_name.map(|s| s.to_string()),
user_name: user_name.map(|s| s.to_string()),
})
.with_timeout(timeout)
.sync()
.map_err(|err| match err {
RusotoError::Service(ListServiceSpecificCredentialsError::NoSuchEntity(msg)) => {
IamError::EntityNotFound {
message: msg
}
},
RusotoError::Service(ListServiceSpecificCredentialsError::ServiceNotSupported(msg)) => {
IamError::ServiceNotSupported {
message: msg
}
},
err => IamError::RusotoError {
message: format!("{:?}", err)
}
})
.map(|creds| {
creds.service_specific_credentials.unwrap_or(vec![])
.into_iter()
.map(|metadata| CredentialMetadata::from(metadata))
.collect()
})
}
pub fn create_service_specific_credential(user_name: &str, service_name: &str, timeout: Duration) -> IamResult<Credential> {
let cred = IAM_CLIENT.create_service_specific_credential(CreateServiceSpecificCredentialRequest {
user_name: user_name.to_string(),
service_name: service_name.to_string(),
})
.with_timeout(timeout)
.sync()
.map_err(|err| match err {
RusotoError::Service(CreateServiceSpecificCredentialError::LimitExceeded(msg)) => {
IamError::LimitExceeded {
message: msg
}
},
RusotoError::Service(CreateServiceSpecificCredentialError::NoSuchEntity(msg)) => {
IamError::EntityNotFound {
message: msg
}
},
RusotoError::Service(CreateServiceSpecificCredentialError::ServiceNotSupported(msg)) => {
IamError::ServiceNotSupported {
message: msg
}
},
err => IamError::RusotoError {
message: format!("{:?}", err)
}
})?;
cred.service_specific_credential
.ok_or_else(|| IamError::MissingCredentialInResponse)
.map(|cred| Credential::from(cred))
}
pub fn reset_service_specific_credential(id: &str, user_name: Option<&str>, timeout: Duration) -> IamResult<Credential> {
let cred = IAM_CLIENT.reset_service_specific_credential(ResetServiceSpecificCredentialRequest {
service_specific_credential_id: id.to_string(),
user_name: user_name.map(|s| s.to_string()),
})
.with_timeout(timeout)
.sync()
.map_err(|err| match err {
RusotoError::Service(ResetServiceSpecificCredentialError::NoSuchEntity(msg)) => {
IamError::EntityNotFound {
message: msg
}
},
err => IamError::RusotoError {
message: format!("{:?}", err)
}
})?;
cred.service_specific_credential
.ok_or_else(|| IamError::MissingCredentialInResponse)
.map(|cred| Credential::from(cred))
}
pub fn update_service_specific_credential(id: &str, user_name: Option<&str>, status: CredentialStatus, timeout: Duration) -> IamResult<()> {
IAM_CLIENT.update_service_specific_credential(UpdateServiceSpecificCredentialRequest {
service_specific_credential_id: id.to_string(),
user_name: user_name.map(|s| s.to_string()),
status: status.into(),
})
.with_timeout(timeout)
.sync()
.map_err(|err| match err {
RusotoError::Service(UpdateServiceSpecificCredentialError::NoSuchEntity(msg)) => {
IamError::EntityNotFound {
message: msg
}
},
err => IamError::RusotoError {
message: format!("{:?}", err)
}
})
} |
use super::DataManager;
// System prototype
pub trait System {
fn name(&self) -> &'static str;
fn tick(&self, dm: &mut DataManager);
} |
use std::str::FromStr;
use std::{env, thread};
use std::time::{Duration, SystemTime};
use std::process;
use std::sync::{Arc, Mutex};
use std::sync::mpsc::{channel, Receiver};
use base64;
use getopts::Options;
use mime::Mime;
use hyper::body::HttpBody;
use hyper::{Body, Client, Method, Request};
use hyper::client::connect::HttpConnector;
use hyper::header::{HeaderName, HeaderValue};
const N_DEFAULT: i32 = 200;
const C_DEFAULT: i32 = 50;
mod report;
use report::Report;
#[derive(Clone)]
struct BoomOption {
concurrency: i32,
num_requests: i32,
method: Method,
url: String,
body: String,
username: String,
password: String,
proxy_host: String,
proxy_port: u16,
keepalive: bool,
compress: bool,
mime: Mime,
}
struct WorkerOption {
opts: BoomOption,
report: Arc<Mutex<Report>>,
}
fn get_request(options: &BoomOption) -> Client<HttpConnector> {
// TODO: support proxy and timeout
// let mut client = if options.proxy_host.is_empty() {
// Client::new()
// } else {
// Client::with_http_proxy(options.proxy_host.to_owned(), options.proxy_port)
// };
let client = Client::new();
// let timeout: Option<Duration> = Some(Duration::new(1, 0));
// client.set_connect_timeout(timeout);
return client;
}
// one request
async fn b(client: &Arc<Client<HttpConnector>>, options: BoomOption, report: Arc<Mutex<Report>>) -> bool {
let request_body = if options.body.is_empty() {
Body::empty()
} else {
Body::from(options.body.clone())
};
let mut request = Request::builder()
.method(options.method)
.uri(options.url.as_str())
.body(request_body)
.unwrap();
request.headers_mut().insert(HeaderName::from_static("user-agent"), HeaderValue::from_static("boom-rust"));
if !options.keepalive {
request.headers_mut().insert(HeaderName::from_static("connection"), HeaderValue::from_static("close"));
}
request.headers_mut().insert(HeaderName::from_static("content-type"), HeaderValue::from_str(options.mime.as_ref()).unwrap());
if options.compress {
request.headers_mut().insert(HeaderName::from_static("accept-encoding"), HeaderValue::from_static("gzip"));
}
if !options.username.is_empty() {
let b64 = base64::encode(format!("{}:{}", options.username, options.password));
request.headers_mut().insert(HeaderName::from_static("authorization"), HeaderValue::from_str(format!("Basic {}", b64).as_str()).unwrap());
}
let t1 = SystemTime::now();
let res = client.request(request).await.unwrap();
let t2 = SystemTime::now();
let duration = t2.duration_since(t1).unwrap();
let diff = duration.subsec_micros() as f32;
{
let mut r = report.lock().unwrap();
let millisec = diff / 1000.;
(*r).time_total += millisec;
(*r).req_num += 1;
(*r).results.push((res.status().as_u16(), millisec));
}
if res.status().as_u16() != 200 {
let mut r = report.lock().unwrap();
let status_num = (*r).status_num.entry(res.status().as_u16()).or_insert(0);
*status_num += 1;
return false;
}
let content_len = match res.body().size_hint().upper() {
Some(v) => v,
None => 1025, // TODO: error handling
};
{
let mut r = report.lock().unwrap();
(*r).size_total += content_len as i64;
}
let mut r = report.lock().unwrap();
let status_num = (*r).status_num.entry(200).or_insert(0);
*status_num += 1;
return true;
}
// exec actions
async fn exec_boom(client: &Arc<Client<HttpConnector>>, options: BoomOption, report: Arc<Mutex<Report>>) {
Some(b(client, options, report).await);
}
async fn exec_worker(client: &Arc<Client<HttpConnector>>, rx: Receiver<Option<WorkerOption>>) {
loop {
match rx.recv().expect("rx.recv() error:") {
Some(wconf) => {
exec_boom(client, wconf.opts, wconf.report).await;
}
None => {
break;
}
}
}
}
fn print_usage(opts: &Options) {
print!("{}", opts.usage("Usage: boom-rust [options] URL"));
}
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
let args: Vec<String> = env::args().collect();
let mut opts = Options::new();
opts.optopt("n", "num", "number of requests", "N");
opts.optopt("c", "concurrency", "concurrency", "C");
opts.optopt("m", "method", "HTTP method (GET, POST, PUT, DELETE, HEAD, OPTIONS)", "METHOD");
opts.optopt("d", "data", "HTTP request body data", "DATA");
opts.optopt("T", "", "Content-type, defaults to \"text/html\".", "ContentType");
opts.optopt("a", "", "use basic authentication", "USERNAME:PASSWORD");
opts.optopt("x", "", "HTTP proxy address as host:port", "PROXY_HOST:PROXY_PORT");
opts.optflag("", "disable-compress", "Disable compress");
opts.optflag("", "disable-keepalive", "Disable keep-alive");
let matches = match opts.parse(&args[1..]) {
Ok(m) => Some(m),
Err(_) => {
print_usage(&opts);
None
}
};
if matches.is_none() {
std::process::exit(1)
}
let matches = matches.unwrap();
if matches.free.len() < 1 {
print_usage(&opts);
std::process::exit(1)
}
let mime_v = match matches.opt_str("T") {
Some(v) => v,
None => "text/html".to_string(),
};
let method_v = match matches.opt_str("m") {
Some(v) => v.to_uppercase(),
None => "GET".to_string(),
};
let body_v = match matches.opt_str("d") {
Some(v) => v.to_string(),
None => "".to_string(),
};
let (basic_auth_name, basic_auth_pass) = match matches.opt_str("a") {
Some(v) => {
let s: Vec<&str> = v.split(':').collect();
let ret: (String, String) = if s.len() != 2 {
println!("invalid argument: {}\n", v);
print_usage(&opts);
process::exit(1);
} else {
(s[0].to_string(), s[1].to_string())
};
ret
}
None => ("".to_string(), "".to_string()),
};
let (proxy_host, proxy_port) = match matches.opt_str("x") {
Some(v) => {
let s: Vec<&str> = v.split(':').collect();
let ret: (String, u16) = if s.len() != 2 {
println!("invalid argument: {}\n", v);
print_usage(&opts);
process::exit(1);
} else {
match u16::from_str_radix(s[1], 10) {
Ok(v) => (s[0].to_string(), v),
Err(_) => {
println!("invalid proxy address: {}\n", v);
print_usage(&opts);
process::exit(1);
}
}
};
ret
}
None => ("".to_string(), 0),
};
let mut opt = BoomOption {
concurrency: 0,
num_requests: 0,
method: Method::from_str(method_v.as_str()).unwrap(),
url: matches.free[0].clone(),
body: body_v,
username: basic_auth_name,
password: basic_auth_pass,
proxy_host: proxy_host,
proxy_port: proxy_port,
mime: Mime::from_str(mime_v.as_str()).unwrap(),
keepalive: !matches.opt_present("disable-keepalive"),
compress: !matches.opt_present("disable-compress"),
};
opt.concurrency = match matches.opt_str("c") {
Some(v) => i32::from_str_radix(&v, 10).unwrap(),
None => C_DEFAULT,
};
opt.num_requests = match matches.opt_str("n") {
Some(v) => i32::from_str_radix(&v, 10).unwrap(),
None => N_DEFAULT,
};
if matches.free.is_empty() {
print_usage(&opts);
std::process::exit(1)
};
let mut handles = vec![];
let mut workers = vec![];
let client = Arc::new(get_request(&opt));
// create worker
for _ in 0..opt.concurrency {
let (worker_tx, worker_rx) = channel::<Option<WorkerOption>>();
workers.push(worker_tx.clone());
let c = client.clone();
// handles.push(thread::spawn(move || exec_worker(&c, worker_rx)));
handles.push(thread::spawn(move || {
let rt = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.unwrap();
rt.block_on(async {
exec_worker(&c, worker_rx).await
});
}));
}
let t1 = SystemTime::now();
let report = Arc::new(Mutex::new(Report::new()));
// request for attack
for cnt in 0..opt.num_requests {
let w = WorkerOption {
opts: opt.clone(),
report: report.clone(),
};
let offset = ((cnt as i32) % opt.concurrency) as usize;
let req = workers[offset].clone();
req.send(Some(w)).expect("request.send() error:");
}
// exit for worker
for worker in workers {
worker.send(None).expect("worker.send(None) error:");
}
for handle in handles {
handle.join().expect("thread.join() error:");
}
let t2 = SystemTime::now();
let duration = t2.duration_since(t1).unwrap();
let diff = duration.subsec_micros() as f32;
let request_per_seconds = 1000000. * opt.num_requests as f32 / diff;
{
let r = report.clone();
let mut report_mut = (*r).lock().unwrap();
report_mut.time_exec_total = diff / 1000.;
report_mut.req_per_sec = request_per_seconds;
report_mut.finalize();
}
Ok(())
}
|
use my_crate_denglitong;
use my_crate_denglitong::add_one;
fn main() {
let five = 5;
assert_eq!(6, add_one(five));
}
|
/* lib.rs */
pub mod riscv32_core;
pub mod riscv64_core;
pub mod riscv_csr;
pub mod riscv_csr_bitdef;
pub mod riscv_exception;
pub mod riscv32_insts;
pub mod riscv64_insts;
pub mod riscv_mmu;
pub mod riscv_tracer;
|
use crate::libc as c;
use pulse_sys as pulse;
use std::ptr;
/// A property list object.
///
/// Basically a dictionary with ASCII strings as keys and arbitrary data as values.
///
/// See [PropertyList::new].
pub struct PropertyList {
handle: ptr::NonNull<pulse::pa_proplist>,
}
impl PropertyList {
/// Construct a property list.
///
/// # Examples
///
/// ```rust
/// use audio_device::pulse;
///
/// # fn main() -> anyhow::Result<()> {
/// let props = pulse::PropertyList::new();
/// # Ok(()) }
/// ```
pub fn new() -> Self {
unsafe {
Self {
handle: ptr::NonNull::new_unchecked(pulse::pa_proplist_new()),
}
}
}
/// Return the number of entries in the property list.
///
/// # Examples
///
/// ```rust
/// use audio_device::pulse;
///
/// # fn main() -> anyhow::Result<()> {
/// let props = pulse::PropertyList::new();
/// assert_eq!(props.len(), 0);
/// # Ok(()) }
/// ```
pub fn len(&self) -> c::c_uint {
unsafe { pulse::pa_proplist_size(self.handle.as_ref()) }
}
/// Return the number of entries in the property list.
///
/// # Examples
///
/// ```rust
/// use audio_device::pulse;
///
/// # fn main() -> anyhow::Result<()> {
/// let props = pulse::PropertyList::new();
/// assert!(props.is_empty());
/// # Ok(()) }
/// ```
pub fn is_empty(&self) -> bool {
unsafe { dbg!(pulse::pa_proplist_isempty(self.handle.as_ref())) == 1 }
}
}
impl Drop for PropertyList {
fn drop(&mut self) {
unsafe {
pulse::pa_proplist_free(self.handle.as_ptr());
}
}
}
|
pub mod animation;
pub mod motion;
pub mod collision;
pub mod input;
pub mod hud; |
// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
//! Fast, non-cryptographic hash used by rustc and Firefox.
//!
//! # Example
//!
//! ```rust
//! # #[cfg(feature = "std")]
//! # fn main() {
//! use rustc_hash::FxHashMap;
//! let mut map: FxHashMap<u32, u32> = FxHashMap::default();
//! map.insert(22, 44);
//! # }
//! # #[cfg(not(feature = "std"))]
//! # fn main() { }
//! ```
#![no_std]
#[cfg(feature = "std")]
extern crate std;
use core::convert::TryInto;
use core::default::Default;
#[cfg(feature = "std")]
use core::hash::BuildHasherDefault;
use core::hash::Hasher;
use core::mem::size_of;
use core::ops::BitXor;
#[cfg(feature = "std")]
use std::collections::{HashMap, HashSet};
/// Type alias for a hashmap using the `fx` hash algorithm.
#[cfg(feature = "std")]
pub type FxHashMap<K, V> = HashMap<K, V, BuildHasherDefault<FxHasher>>;
/// Type alias for a hashset using the `fx` hash algorithm.
#[cfg(feature = "std")]
pub type FxHashSet<V> = HashSet<V, BuildHasherDefault<FxHasher>>;
/// A speedy hash algorithm for use within rustc. The hashmap in liballoc
/// by default uses SipHash which isn't quite as speedy as we want. In the
/// compiler we're not really worried about DOS attempts, so we use a fast
/// non-cryptographic hash.
///
/// This is the same as the algorithm used by Firefox -- which is a homespun
/// one not based on any widely-known algorithm -- though modified to produce
/// 64-bit hash values instead of 32-bit hash values. It consistently
/// out-performs an FNV-based hash within rustc itself -- the collision rate is
/// similar or slightly worse than FNV, but the speed of the hash function
/// itself is much higher because it works on up to 8 bytes at a time.
pub struct FxHasher {
hash: usize,
}
#[cfg(target_pointer_width = "32")]
const K: usize = 0x9e3779b9;
#[cfg(target_pointer_width = "64")]
const K: usize = 0x517cc1b727220a95;
impl Default for FxHasher {
#[inline]
fn default() -> FxHasher {
FxHasher { hash: 0 }
}
}
impl FxHasher {
#[inline]
fn add_to_hash(&mut self, i: usize) {
self.hash = self.hash.rotate_left(5).bitxor(i).wrapping_mul(K);
}
}
impl Hasher for FxHasher {
#[inline]
fn write(&mut self, mut bytes: &[u8]) {
#[cfg(target_pointer_width = "32")]
let read_usize = |bytes: &[u8]| u32::from_ne_bytes(bytes[..4].try_into().unwrap());
#[cfg(target_pointer_width = "64")]
let read_usize = |bytes: &[u8]| u64::from_ne_bytes(bytes[..8].try_into().unwrap());
let mut hash = FxHasher { hash: self.hash };
assert!(size_of::<usize>() <= 8);
while bytes.len() >= size_of::<usize>() {
hash.add_to_hash(read_usize(bytes) as usize);
bytes = &bytes[size_of::<usize>()..];
}
if (size_of::<usize>() > 4) && (bytes.len() >= 4) {
hash.add_to_hash(u32::from_ne_bytes(bytes[..4].try_into().unwrap()) as usize);
bytes = &bytes[4..];
}
if (size_of::<usize>() > 2) && bytes.len() >= 2 {
hash.add_to_hash(u16::from_ne_bytes(bytes[..2].try_into().unwrap()) as usize);
bytes = &bytes[2..];
}
if (size_of::<usize>() > 1) && bytes.len() >= 1 {
hash.add_to_hash(bytes[0] as usize);
}
self.hash = hash.hash;
}
#[inline]
fn write_u8(&mut self, i: u8) {
self.add_to_hash(i as usize);
}
#[inline]
fn write_u16(&mut self, i: u16) {
self.add_to_hash(i as usize);
}
#[inline]
fn write_u32(&mut self, i: u32) {
self.add_to_hash(i as usize);
}
#[cfg(target_pointer_width = "32")]
#[inline]
fn write_u64(&mut self, i: u64) {
self.add_to_hash(i as usize);
self.add_to_hash((i >> 32) as usize);
}
#[cfg(target_pointer_width = "64")]
#[inline]
fn write_u64(&mut self, i: u64) {
self.add_to_hash(i as usize);
}
#[inline]
fn write_usize(&mut self, i: usize) {
self.add_to_hash(i);
}
#[inline]
fn finish(&self) -> u64 {
self.hash as u64
}
}
|
fn main() {
// The Windows crate manually injects a functions needed to implement Matrix3x2.
// This test validates this is included.
windows::core::build_legacy! {
Windows::Foundation::Numerics::Matrix3x2,
};
}
|
/*
* Given an array of integers where 1 ≤ a[i] ≤ n (n = size of array), some elements appear twice and others appear once.
*
* Find all the elements of [1, n] inclusive that do not appear in this array.
* Could you do it without extra space and in O(n) runtime? You may assume the returned list does not count as extra space.
*
* Example:
* ---------
* Input: [4, 3, 2, 7, 8, 2, 3, 1]
* Output: [5, 6]
*/
pub fn find_disappeard_numbers(nums: Vec<i32>) -> Vec<i32> {
let mut zero_vec = vec![0; nums.len()];
let mut res: Vec<i32> = vec![];
for num in nums {
zero_vec[(num-1) as usize] = 1
}
for (index, val) in zero_vec.iter().enumerate() {
if *val == 0 {
res.push((index + 1) as i32)
}
}
return res
}
#[cfg(test)]
mod test {
use super::find_disappeard_numbers;
#[test]
fn example1() {
let input = vec![4, 3, 2, 7, 8, 2, 3, 1];
assert_eq!(find_disappeard_numbers(input), vec![5, 6]);
}
}
|
extern crate onig;
use onig::Regex;
pub fn abbreviate(s: &str) -> String {
let re = Regex::new(r"[a-z](?=[A-Z])|-|\s+").unwrap();
re.split(s)
.map(|w| w.chars().take(1).collect::<String>().to_uppercase())
.collect()
}
|
//! Improved cross-platform clipboard library
//!
//! Fork of https://github.com/aweinstock314/rust-clipboard with better error handling
#[cfg(target_os = "windows")]
extern crate clipboard_win;
#[cfg(any(target_os = "linux", target_os = "openbsd"))]
extern crate x11_clipboard;
#[cfg(target_os = "macos")]
#[macro_use]
extern crate objc;
#[cfg(target_os = "macos")]
extern crate objc_foundation;
#[cfg(target_os = "macos")]
extern crate objc_id;
pub mod clipboard_metadata;
mod errors;
pub use clipboard_metadata::ClipboardContentType;
pub use errors::ClipboardError;
pub trait Clipboard {
type Output;
fn new() -> Result<Self::Output, ClipboardError>;
fn get_contents(&self) -> Result<(Vec<u8>, ClipboardContentType), ClipboardError>;
fn get_string_contents(&self) -> Result<String, ClipboardError>;
fn set_contents(
&self,
contents: Vec<u8>,
format: ClipboardContentType,
) -> Result<(), ClipboardError>;
fn set_string_contents(&self, contents: String) -> Result<(), ClipboardError>;
}
#[cfg(target_os = "windows")]
pub mod win;
#[cfg(target_os = "windows")]
pub use win::WindowsClipboard as SystemClipboard;
#[cfg(any(target_os = "linux", target_os = "openbsd"))]
pub mod x11;
#[cfg(any(target_os = "linux", target_os = "openbsd"))]
pub use x11::X11Clipboard as SystemClipboard;
#[cfg(target_os = "macos")]
pub mod macos;
#[cfg(target_os = "macos")]
pub use macos::MacOsClipboard as SystemClipboard;
|
use actix_web::{http::StatusCode, HttpResponse, Json};
use bigneon_api::auth::{claims::AccessToken, claims::RefreshToken, TokenResponse};
use bigneon_api::controllers::auth;
use bigneon_api::controllers::auth::{LoginRequest, RefreshRequest};
use crypto::sha2::Sha256;
use jwt::{Header, Token};
use serde_json;
use support;
use support::database::TestDatabase;
use support::test_request::TestRequest;
use uuid::Uuid;
#[test]
fn token() {
let database = TestDatabase::new();
let email = "fake@localhost";
let password = "strong_password";
let user = database
.create_user()
.with_email(email.to_string())
.with_password(password.to_string())
.finish();
let test_request = TestRequest::create();
let json = Json(LoginRequest::new("fake@localhost", "strong_password"));
let response: HttpResponse =
auth::token((test_request.request, database.connection.into(), json)).into();
assert_eq!(response.status(), StatusCode::OK);
let body = support::unwrap_body_to_string(&response).unwrap();
let response: TokenResponse = serde_json::from_str(&body).unwrap();
let access_token = Token::<Header, AccessToken>::parse(&response.access_token).unwrap();
let refresh_token = Token::<Header, RefreshToken>::parse(&response.refresh_token).unwrap();
assert_eq!(access_token.claims.get_id(), user.id);
assert_eq!(refresh_token.claims.get_id(), user.id);
}
#[test]
fn token_invalid_email() {
let database = TestDatabase::new();
database.create_user().finish();
let test_request = TestRequest::create();
let json = Json(LoginRequest::new("incorrect@localhost", "strong_password"));
let response: HttpResponse =
auth::token((test_request.request, database.connection.into(), json)).into();
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
let body = support::unwrap_body_to_string(&response).unwrap();
assert_eq!(
body,
json!({"error": "Email or password incorrect"}).to_string()
);
}
#[test]
fn token_incorrect_password() {
let database = TestDatabase::new();
let user = database
.create_user()
.with_email("fake@localhost".to_string())
.finish();
let test_request = TestRequest::create();
let json = Json(LoginRequest::new(&user.email.unwrap(), "incorrect"));
let response: HttpResponse =
auth::token((test_request.request, database.connection.into(), json)).into();
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
let body = support::unwrap_body_to_string(&response).unwrap();
assert_eq!(
body,
json!({"error": "Email or password incorrect"}).to_string()
);
}
#[test]
fn token_refresh() {
let database = TestDatabase::new();
let user = database.create_user().finish();
let test_request = TestRequest::create();
let state = test_request.extract_state();
let refresh_token_claims = RefreshToken::new(&user.id, state.config.token_issuer.clone());
let header: Header = Default::default();
let refresh_token = Token::new(header, refresh_token_claims)
.signed(state.config.token_secret.as_bytes(), Sha256::new())
.unwrap();
let json = Json(RefreshRequest::new(&refresh_token));
let response: HttpResponse =
auth::token_refresh((state, database.connection.into(), json)).into();
assert_eq!(response.status(), StatusCode::OK);
let body = support::unwrap_body_to_string(&response).unwrap();
let response: TokenResponse = serde_json::from_str(&body).unwrap();
let access_token = Token::<Header, AccessToken>::parse(&response.access_token).unwrap();
assert_eq!(response.refresh_token, refresh_token);
assert_eq!(access_token.claims.get_id(), user.id);
}
#[test]
fn token_refresh_invalid_refresh_token_secret() {
let database = TestDatabase::new();
let user = database.create_user().finish();
let test_request = TestRequest::create();
let state = test_request.extract_state();
let refresh_token_claims = RefreshToken::new(&user.id, state.config.token_issuer.clone());
let header: Header = Default::default();
let refresh_token = Token::new(header, refresh_token_claims)
.signed(b"incorrect-secret", Sha256::new())
.unwrap();
let json = Json(RefreshRequest::new(&refresh_token));
let response: HttpResponse =
auth::token_refresh((state, database.connection.into(), json)).into();
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
let body = support::unwrap_body_to_string(&response).unwrap();
assert_eq!(body, json!({"error": "Invalid token"}).to_string());
}
#[test]
fn token_refresh_invalid_refresh_token() {
let database = TestDatabase::new();
database.create_user().finish();
let test_request = TestRequest::create();
let state = test_request.extract_state();
let json = Json(RefreshRequest::new(&"not.a.real.token"));
let response: HttpResponse =
auth::token_refresh((state, database.connection.into(), json)).into();
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
let body = support::unwrap_body_to_string(&response).unwrap();
assert_eq!(body, json!({"error": "Invalid token"}).to_string());
}
#[test]
fn token_refresh_user_does_not_exist() {
let database = TestDatabase::new();
let user = database.create_user().finish();
let test_request = TestRequest::create();
let state = test_request.extract_state();
let mut refresh_token_claims = RefreshToken::new(&user.id, state.config.token_issuer.clone());
refresh_token_claims.sub = Uuid::new_v4().to_string();
let header: Header = Default::default();
let refresh_token = Token::new(header, refresh_token_claims)
.signed(state.config.token_secret.as_bytes(), Sha256::new())
.unwrap();
let json = Json(RefreshRequest::new(&refresh_token));
let response: HttpResponse =
auth::token_refresh((state, database.connection.into(), json)).into();
assert_eq!(response.status(), StatusCode::NOT_FOUND);
}
#[test]
fn token_refresh_password_reset_since_issued() {
let database = TestDatabase::new();
let user = database.create_user().finish();
let password_modified_timestamp = user.password_modified_at.timestamp() as u64;
let test_request = TestRequest::create();
let state = test_request.extract_state();
let mut refresh_token_claims = RefreshToken::new(&user.id, state.config.token_issuer.clone());
// Issued a second prior to the latest password
refresh_token_claims.issued = password_modified_timestamp - 1;
let header: Header = Default::default();
let refresh_token = Token::new(header, refresh_token_claims)
.signed(state.config.token_secret.as_bytes(), Sha256::new())
.unwrap();
let json = Json(RefreshRequest::new(&refresh_token));
let response: HttpResponse =
auth::token_refresh((state, database.connection.into(), json)).into();
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
let body = support::unwrap_body_to_string(&response).unwrap();
assert_eq!(body, json!({"error": "Invalid token"}).to_string());
}
#[test]
fn token_refreshed_after_password_change() {
let database = TestDatabase::new();
let user = database.create_user().finish();
let password_modified_timestamp = user.password_modified_at.timestamp() as u64;
let test_request = TestRequest::create();
let state = test_request.extract_state();
let mut refresh_token_claims = RefreshToken::new(&user.id, state.config.token_issuer.clone());
// Issued a second after the latest password
refresh_token_claims.issued = password_modified_timestamp + 1;
let header: Header = Default::default();
let refresh_token = Token::new(header, refresh_token_claims)
.signed(state.config.token_secret.as_bytes(), Sha256::new())
.unwrap();
let json = Json(RefreshRequest::new(&refresh_token));
let response: HttpResponse =
auth::token_refresh((state, database.connection.into(), json)).into();
assert_eq!(response.status(), StatusCode::OK);
let body = support::unwrap_body_to_string(&response).unwrap();
let response: TokenResponse = serde_json::from_str(&body).unwrap();
let access_token = Token::<Header, AccessToken>::parse(&response.access_token).unwrap();
assert_eq!(response.refresh_token, refresh_token);
assert_eq!(access_token.claims.get_id(), user.id);
}
|
// Score of Parentheses
// https://leetcode.com/explore/challenge/card/february-leetcoding-challenge-2021/587/week-4-february-22nd-february-28th/3651/
pub struct Solution;
impl Solution {
pub fn score_of_parentheses(s: String) -> i32 {
let mut stack = vec![0];
for c in s.chars() {
match c {
'(' => stack.push(0),
')' => {
let val = match stack.pop().unwrap() {
0 => 1,
val => val * 2,
};
*stack.last_mut().unwrap() += val;
}
_ => unreachable!(),
}
}
stack[0]
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn example1() {
assert_eq!(Solution::score_of_parentheses("()".into()), 1);
}
#[test]
fn example2() {
assert_eq!(Solution::score_of_parentheses("(())".into()), 2);
}
#[test]
fn example3() {
assert_eq!(Solution::score_of_parentheses("()()".into()), 2);
}
#[test]
fn example4() {
assert_eq!(Solution::score_of_parentheses("(()(()))".into()), 6);
}
}
|
use std::collections::BTreeMap;
use {Error, Result, Plist, PlistEvent, u64_option_to_usize};
pub struct Builder<T> {
stream: T,
token: Option<PlistEvent>,
}
impl<T: Iterator<Item = Result<PlistEvent>>> Builder<T> {
pub fn new(stream: T) -> Builder<T> {
Builder {
stream: stream,
token: None,
}
}
pub fn build(mut self) -> Result<Plist> {
self.bump()?;
let plist = self.build_value()?;
self.bump()?;
match self.token {
None => (),
// The stream should have finished
_ => return Err(Error::InvalidData),
};
Ok(plist)
}
fn bump(&mut self) -> Result<()> {
self.token = match self.stream.next() {
Some(Ok(token)) => Some(token),
Some(Err(err)) => return Err(err),
None => None,
};
Ok(())
}
fn build_value(&mut self) -> Result<Plist> {
match self.token.take() {
Some(PlistEvent::StartArray(len)) => Ok(Plist::Array(self.build_array(len)?)),
Some(PlistEvent::StartDictionary(len)) => Ok(Plist::Dictionary(self.build_dict(len)?)),
Some(PlistEvent::BooleanValue(b)) => Ok(Plist::Boolean(b)),
Some(PlistEvent::DataValue(d)) => Ok(Plist::Data(d)),
Some(PlistEvent::DateValue(d)) => Ok(Plist::Date(d)),
Some(PlistEvent::IntegerValue(i)) => Ok(Plist::Integer(i)),
Some(PlistEvent::RealValue(f)) => Ok(Plist::Real(f)),
Some(PlistEvent::StringValue(s)) => Ok(Plist::String(s)),
Some(PlistEvent::EndArray) => Err(Error::InvalidData),
Some(PlistEvent::EndDictionary) => Err(Error::InvalidData),
// The stream should not have ended here
None => Err(Error::InvalidData),
}
}
fn build_array(&mut self, len: Option<u64>) -> Result<Vec<Plist>> {
let len = u64_option_to_usize(len)?;
let mut values = match len {
Some(len) => Vec::with_capacity(len),
None => Vec::new(),
};
loop {
self.bump()?;
if let Some(PlistEvent::EndArray) = self.token {
self.token.take();
return Ok(values);
}
values.push(self.build_value()?);
}
}
fn build_dict(&mut self, _len: Option<u64>) -> Result<BTreeMap<String, Plist>> {
let mut values = BTreeMap::new();
loop {
self.bump()?;
match self.token.take() {
Some(PlistEvent::EndDictionary) => return Ok(values),
Some(PlistEvent::StringValue(s)) => {
self.bump()?;
values.insert(s, self.build_value()?);
}
_ => {
// Only string keys are supported in plists
return Err(Error::InvalidData);
}
}
}
}
}
#[cfg(test)]
mod tests {
use std::collections::BTreeMap;
use super::*;
use Plist;
#[test]
fn builder() {
use PlistEvent::*;
// Input
let events = vec![StartDictionary(None),
StringValue("Author".to_owned()),
StringValue("William Shakespeare".to_owned()),
StringValue("Lines".to_owned()),
StartArray(None),
StringValue("It is a tale told by an idiot,".to_owned()),
StringValue("Full of sound and fury, signifying nothing.".to_owned()),
EndArray,
StringValue("Birthdate".to_owned()),
IntegerValue(1564),
StringValue("Height".to_owned()),
RealValue(1.60),
EndDictionary];
let builder = Builder::new(events.into_iter().map(|e| Ok(e)));
let plist = builder.build();
// Expected output
let mut lines = Vec::new();
lines.push(Plist::String("It is a tale told by an idiot,".to_owned()));
lines.push(Plist::String("Full of sound and fury, signifying nothing.".to_owned()));
let mut dict = BTreeMap::new();
dict.insert("Author".to_owned(),
Plist::String("William Shakespeare".to_owned()));
dict.insert("Lines".to_owned(), Plist::Array(lines));
dict.insert("Birthdate".to_owned(), Plist::Integer(1564));
dict.insert("Height".to_owned(), Plist::Real(1.60));
assert_eq!(plist.unwrap(), Plist::Dictionary(dict));
}
}
|
// See LICENSE file for copyright and license details.
use std::str::Words;
use std::str::CharSplits;
use std::from_str::FromStr;
use std::io::{BufferedReader, File};
use cgmath::{Vector3, Vector2};
use error_context;
use core::types::{MInt};
use visualizer::types::{VertexCoord, TextureCoord, Normal};
struct Face {
vertex: [MInt, ..3],
texture: [MInt, ..3],
normal: [MInt, ..3],
}
pub struct Model {
coords: Vec<VertexCoord>,
normals: Vec<Normal>,
texture_coords: Vec<TextureCoord>,
faces: Vec<Face>,
}
fn parse_word<T: FromStr>(words: &mut Words) -> T {
let str = words.next().expect("Can not read next word");
from_str(str).expect("Can not convert from string")
}
fn parse_charsplit<T: FromStr>(words: &mut CharSplits<char>) -> T {
let str = words.next().expect("Can not read next word");
from_str(str).expect("Can not convert from string")
}
impl Model {
pub fn new(path: &Path) -> Model {
set_error_context!("loading obj", path.as_str().unwrap());
let mut obj = Model {
coords: Vec::new(),
normals: Vec::new(),
texture_coords: Vec::new(),
faces: Vec::new(),
};
obj.read(path);
obj
}
fn read_v(words: &mut Words) -> VertexCoord {
VertexCoord{v: Vector3 {
x: parse_word(words),
y: parse_word(words),
z: parse_word(words),
}}
}
fn read_vn(words: &mut Words) -> Normal {
Normal{v: Vector3 {
x: parse_word(words),
y: parse_word(words),
z: parse_word(words),
}}
}
fn read_vt(words: &mut Words) -> TextureCoord {
TextureCoord{v: Vector2 {
x: parse_word(words),
y: 1.0 - parse_word(words), // flip
}}
}
fn read_f(words: &mut Words) -> Face {
let mut face = Face {
vertex: [0, 0, 0],
texture: [0, 0, 0],
normal: [0, 0, 0],
};
let mut i = 0;
for group in *words {
let mut w = group.split('/');
face.vertex[i] = parse_charsplit(&mut w);
face.texture[i] = parse_charsplit(&mut w);
face.normal[i] = parse_charsplit(&mut w);
i += 1;
}
face
}
fn read_line(&mut self, line: &str) {
let mut words = line.words();
fn is_correct_tag(tag: &str) -> bool {
tag.len() != 0 && tag.char_at(0) != '#'
}
match words.next() {
Some(tag) if is_correct_tag(tag) => {
let w = &mut words;
match tag {
"v" => self.coords.push(Model::read_v(w)),
"vn" => self.normals.push(Model::read_vn(w)),
"vt" => self.texture_coords.push(Model::read_vt(w)),
"f" => self.faces.push(Model::read_f(w)),
_ => {},
}
}
_ => {},
};
}
fn read(&mut self, path: &Path) {
let mut file = BufferedReader::new(File::open(path));
for line in file.lines() {
match line {
Ok(line) => self.read_line(line.as_slice()),
Err(msg) => panic!("Obj: read error: {}", msg),
}
}
}
pub fn build(&self) -> Vec<VertexCoord> {
let mut mesh = Vec::new();
for face in self.faces.iter() {
for i in range(0u, 3) {
let vertex_id = face.vertex[i] - 1;
mesh.push(self.coords[vertex_id as uint]);
}
}
mesh
}
pub fn build_tex_coord(&self) -> Vec<TextureCoord> {
let mut tex_coords = Vec::new();
for face in self.faces.iter() {
for i in range(0u, 3) {
let texture_coord_id = face.texture[i] as uint - 1;
tex_coords.push(self.texture_coords[texture_coord_id]);
}
}
tex_coords
}
}
// vim: set tabstop=4 shiftwidth=4 softtabstop=4 expandtab:
|
//! Max memory allocated slice
use std::convert::{From, Into};
use std::slice;
///A slice allocated and freed using max_sys
pub struct Slice<T: 'static + Sized> {
inner: &'static mut [T],
}
impl<T> Slice<T>
where
T: 'static + Sized + Default,
{
pub fn new_with_length(len: usize) -> Self {
let inner = unsafe {
let ptr = max_sys::sysmem_newptr((std::mem::size_of::<T>() * len) as _);
if ptr.is_null() {
panic!("max_sys::sysmem_newptr returned null");
}
let slice = slice::from_raw_parts_mut(std::mem::transmute::<_, *mut T>(ptr), len);
for v in slice.iter_mut() {
*v = Default::default();
}
slice
};
Self { inner }
}
}
impl<T> Slice<T> {
/// convert into raw ptr and size, most likely to be passed to, and managed by, max_sys
pub fn into_raw(self) -> (*mut T, usize) {
let len = self.inner.len();
let ptr = self.inner.as_mut_ptr();
std::mem::forget(self);
(ptr, len)
}
pub fn from_raw_parts_mut(ptr: *mut T, len: usize) -> Self {
assert!(
!(len > 0 && ptr.is_null()),
"cannot have null ptr and non zero length"
);
Self {
inner: unsafe { slice::from_raw_parts_mut(ptr, len) },
}
}
pub fn len(&self) -> usize {
self.inner.len()
}
pub fn as_ref(&self) -> &[T] {
self.inner
}
pub fn as_mut(&mut self) -> &mut [T] {
self.inner
}
}
impl<T> Default for Slice<T>
where
T: 'static + Sized,
{
fn default() -> Self {
unsafe {
Self {
inner: slice::from_raw_parts_mut(std::ptr::null_mut(), 0),
}
}
}
}
impl<T> Drop for Slice<T> {
fn drop(&mut self) {
if self.inner.len() > 0 {
unsafe {
max_sys::sysmem_freeptr(self.inner.as_mut_ptr() as _);
self.inner = slice::from_raw_parts_mut(std::ptr::null_mut(), 0);
}
}
}
}
impl<T, I, U> From<U> for Slice<T>
where
I: Into<T>,
U: ExactSizeIterator<Item = I>,
{
fn from(iter: U) -> Self {
unsafe {
let len = iter.len();
let ptr = max_sys::sysmem_newptr((std::mem::size_of::<T>() * len) as _);
if ptr.is_null() {
panic!("max_sys::sysmem_newptr returned null");
}
let inner = slice::from_raw_parts_mut(std::mem::transmute::<_, *mut T>(ptr), len);
for (i, o) in inner.iter_mut().zip(iter) {
*i = o.into();
}
Self { inner }
}
}
}
#[cfg(test)]
mod test {
use super::*;
use crate::atom::Atom;
use std::convert::From;
#[test]
fn can_create() {
let s: Slice<Atom> = Slice::from([0i64, 1i64].iter());
assert_eq!(2, s.len());
let (p, l) = s.into_raw();
assert!(!p.is_null());
assert_eq!(2, l);
let s = Slice::from_raw_parts_mut(p, l);
assert_eq!(2, s.len());
}
}
|
// auto generated, do not modify.
// created: Mon Feb 22 23:57:02 2016
// src-file: /QtWidgets/qgraphicslayoutitem.h
// dst-file: /src/widgets/qgraphicslayoutitem.rs
//
// header block begin =>
#![feature(libc)]
#![feature(core)]
#![feature(collections)]
extern crate libc;
use self::libc::*;
// <= header block end
// main block begin =>
// <= main block end
// use block begin =>
use std::ops::Deref;
use super::qsizepolicy::*; // 773
use super::qgraphicsitem::*; // 773
use super::super::core::qsize::*; // 771
use super::super::core::qrect::*; // 771
// <= use block end
// ext block begin =>
// #[link(name = "Qt5Core")]
// #[link(name = "Qt5Gui")]
// #[link(name = "Qt5Widgets")]
// #[link(name = "QtInline")]
extern {
fn QGraphicsLayoutItem_Class_Size() -> c_int;
// proto: void QGraphicsLayoutItem::setSizePolicy(const QSizePolicy & policy);
fn C_ZN19QGraphicsLayoutItem13setSizePolicyERK11QSizePolicy(qthis: u64 /* *mut c_void*/, arg0: *mut c_void);
// proto: QGraphicsLayoutItem * QGraphicsLayoutItem::parentLayoutItem();
fn C_ZNK19QGraphicsLayoutItem16parentLayoutItemEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
// proto: qreal QGraphicsLayoutItem::minimumWidth();
fn C_ZNK19QGraphicsLayoutItem12minimumWidthEv(qthis: u64 /* *mut c_void*/) -> c_double;
// proto: QGraphicsItem * QGraphicsLayoutItem::graphicsItem();
fn C_ZNK19QGraphicsLayoutItem12graphicsItemEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
// proto: qreal QGraphicsLayoutItem::preferredWidth();
fn C_ZNK19QGraphicsLayoutItem14preferredWidthEv(qthis: u64 /* *mut c_void*/) -> c_double;
// proto: bool QGraphicsLayoutItem::ownedByLayout();
fn C_ZNK19QGraphicsLayoutItem13ownedByLayoutEv(qthis: u64 /* *mut c_void*/) -> c_char;
// proto: QSizeF QGraphicsLayoutItem::preferredSize();
fn C_ZNK19QGraphicsLayoutItem13preferredSizeEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
// proto: QRectF QGraphicsLayoutItem::geometry();
fn C_ZNK19QGraphicsLayoutItem8geometryEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
// proto: void QGraphicsLayoutItem::QGraphicsLayoutItem(QGraphicsLayoutItem * parent, bool isLayout);
fn C_ZN19QGraphicsLayoutItemC2EPS_b(arg0: *mut c_void, arg1: c_char) -> u64;
// proto: qreal QGraphicsLayoutItem::minimumHeight();
fn C_ZNK19QGraphicsLayoutItem13minimumHeightEv(qthis: u64 /* *mut c_void*/) -> c_double;
// proto: qreal QGraphicsLayoutItem::preferredHeight();
fn C_ZNK19QGraphicsLayoutItem15preferredHeightEv(qthis: u64 /* *mut c_void*/) -> c_double;
// proto: QSizeF QGraphicsLayoutItem::maximumSize();
fn C_ZNK19QGraphicsLayoutItem11maximumSizeEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
// proto: QSizePolicy QGraphicsLayoutItem::sizePolicy();
fn C_ZNK19QGraphicsLayoutItem10sizePolicyEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
// proto: qreal QGraphicsLayoutItem::maximumHeight();
fn C_ZNK19QGraphicsLayoutItem13maximumHeightEv(qthis: u64 /* *mut c_void*/) -> c_double;
// proto: void QGraphicsLayoutItem::setGeometry(const QRectF & rect);
fn C_ZN19QGraphicsLayoutItem11setGeometryERK6QRectF(qthis: u64 /* *mut c_void*/, arg0: *mut c_void);
// proto: void QGraphicsLayoutItem::setPreferredWidth(qreal width);
fn C_ZN19QGraphicsLayoutItem17setPreferredWidthEd(qthis: u64 /* *mut c_void*/, arg0: c_double);
// proto: void QGraphicsLayoutItem::setMaximumSize(const QSizeF & size);
fn C_ZN19QGraphicsLayoutItem14setMaximumSizeERK6QSizeF(qthis: u64 /* *mut c_void*/, arg0: *mut c_void);
// proto: qreal QGraphicsLayoutItem::maximumWidth();
fn C_ZNK19QGraphicsLayoutItem12maximumWidthEv(qthis: u64 /* *mut c_void*/) -> c_double;
// proto: void QGraphicsLayoutItem::setMinimumSize(qreal w, qreal h);
fn C_ZN19QGraphicsLayoutItem14setMinimumSizeEdd(qthis: u64 /* *mut c_void*/, arg0: c_double, arg1: c_double);
// proto: void QGraphicsLayoutItem::setMaximumHeight(qreal height);
fn C_ZN19QGraphicsLayoutItem16setMaximumHeightEd(qthis: u64 /* *mut c_void*/, arg0: c_double);
// proto: void QGraphicsLayoutItem::setMinimumSize(const QSizeF & size);
fn C_ZN19QGraphicsLayoutItem14setMinimumSizeERK6QSizeF(qthis: u64 /* *mut c_void*/, arg0: *mut c_void);
// proto: void QGraphicsLayoutItem::setPreferredSize(const QSizeF & size);
fn C_ZN19QGraphicsLayoutItem16setPreferredSizeERK6QSizeF(qthis: u64 /* *mut c_void*/, arg0: *mut c_void);
// proto: void QGraphicsLayoutItem::getContentsMargins(qreal * left, qreal * top, qreal * right, qreal * bottom);
fn C_ZNK19QGraphicsLayoutItem18getContentsMarginsEPdS0_S0_S0_(qthis: u64 /* *mut c_void*/, arg0: *mut c_double, arg1: *mut c_double, arg2: *mut c_double, arg3: *mut c_double);
// proto: void QGraphicsLayoutItem::setParentLayoutItem(QGraphicsLayoutItem * parent);
fn C_ZN19QGraphicsLayoutItem19setParentLayoutItemEPS_(qthis: u64 /* *mut c_void*/, arg0: *mut c_void);
// proto: void QGraphicsLayoutItem::setMinimumWidth(qreal width);
fn C_ZN19QGraphicsLayoutItem15setMinimumWidthEd(qthis: u64 /* *mut c_void*/, arg0: c_double);
// proto: void QGraphicsLayoutItem::setMaximumWidth(qreal width);
fn C_ZN19QGraphicsLayoutItem15setMaximumWidthEd(qthis: u64 /* *mut c_void*/, arg0: c_double);
// proto: void QGraphicsLayoutItem::updateGeometry();
fn C_ZN19QGraphicsLayoutItem14updateGeometryEv(qthis: u64 /* *mut c_void*/);
// proto: void QGraphicsLayoutItem::setPreferredHeight(qreal height);
fn C_ZN19QGraphicsLayoutItem18setPreferredHeightEd(qthis: u64 /* *mut c_void*/, arg0: c_double);
// proto: QSizeF QGraphicsLayoutItem::minimumSize();
fn C_ZNK19QGraphicsLayoutItem11minimumSizeEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
// proto: QRectF QGraphicsLayoutItem::contentsRect();
fn C_ZNK19QGraphicsLayoutItem12contentsRectEv(qthis: u64 /* *mut c_void*/) -> *mut c_void;
// proto: bool QGraphicsLayoutItem::isLayout();
fn C_ZNK19QGraphicsLayoutItem8isLayoutEv(qthis: u64 /* *mut c_void*/) -> c_char;
// proto: void QGraphicsLayoutItem::setPreferredSize(qreal w, qreal h);
fn C_ZN19QGraphicsLayoutItem16setPreferredSizeEdd(qthis: u64 /* *mut c_void*/, arg0: c_double, arg1: c_double);
// proto: void QGraphicsLayoutItem::~QGraphicsLayoutItem();
fn C_ZN19QGraphicsLayoutItemD2Ev(qthis: u64 /* *mut c_void*/);
// proto: void QGraphicsLayoutItem::setMinimumHeight(qreal height);
fn C_ZN19QGraphicsLayoutItem16setMinimumHeightEd(qthis: u64 /* *mut c_void*/, arg0: c_double);
// proto: void QGraphicsLayoutItem::setMaximumSize(qreal w, qreal h);
fn C_ZN19QGraphicsLayoutItem14setMaximumSizeEdd(qthis: u64 /* *mut c_void*/, arg0: c_double, arg1: c_double);
} // <= ext block end
// body block begin =>
// class sizeof(QGraphicsLayoutItem)=1
#[derive(Default)]
pub struct QGraphicsLayoutItem {
// qbase: None,
pub qclsinst: u64 /* *mut c_void*/,
}
impl /*struct*/ QGraphicsLayoutItem {
pub fn inheritFrom(qthis: u64 /* *mut c_void*/) -> QGraphicsLayoutItem {
return QGraphicsLayoutItem{qclsinst: qthis, ..Default::default()};
}
}
// proto: void QGraphicsLayoutItem::setSizePolicy(const QSizePolicy & policy);
impl /*struct*/ QGraphicsLayoutItem {
pub fn setSizePolicy<RetType, T: QGraphicsLayoutItem_setSizePolicy<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setSizePolicy(self);
// return 1;
}
}
pub trait QGraphicsLayoutItem_setSizePolicy<RetType> {
fn setSizePolicy(self , rsthis: & QGraphicsLayoutItem) -> RetType;
}
// proto: void QGraphicsLayoutItem::setSizePolicy(const QSizePolicy & policy);
impl<'a> /*trait*/ QGraphicsLayoutItem_setSizePolicy<()> for (&'a QSizePolicy) {
fn setSizePolicy(self , rsthis: & QGraphicsLayoutItem) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN19QGraphicsLayoutItem13setSizePolicyERK11QSizePolicy()};
let arg0 = self.qclsinst as *mut c_void;
unsafe {C_ZN19QGraphicsLayoutItem13setSizePolicyERK11QSizePolicy(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: QGraphicsLayoutItem * QGraphicsLayoutItem::parentLayoutItem();
impl /*struct*/ QGraphicsLayoutItem {
pub fn parentLayoutItem<RetType, T: QGraphicsLayoutItem_parentLayoutItem<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.parentLayoutItem(self);
// return 1;
}
}
pub trait QGraphicsLayoutItem_parentLayoutItem<RetType> {
fn parentLayoutItem(self , rsthis: & QGraphicsLayoutItem) -> RetType;
}
// proto: QGraphicsLayoutItem * QGraphicsLayoutItem::parentLayoutItem();
impl<'a> /*trait*/ QGraphicsLayoutItem_parentLayoutItem<QGraphicsLayoutItem> for () {
fn parentLayoutItem(self , rsthis: & QGraphicsLayoutItem) -> QGraphicsLayoutItem {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK19QGraphicsLayoutItem16parentLayoutItemEv()};
let mut ret = unsafe {C_ZNK19QGraphicsLayoutItem16parentLayoutItemEv(rsthis.qclsinst)};
let mut ret1 = QGraphicsLayoutItem::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: qreal QGraphicsLayoutItem::minimumWidth();
impl /*struct*/ QGraphicsLayoutItem {
pub fn minimumWidth<RetType, T: QGraphicsLayoutItem_minimumWidth<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.minimumWidth(self);
// return 1;
}
}
pub trait QGraphicsLayoutItem_minimumWidth<RetType> {
fn minimumWidth(self , rsthis: & QGraphicsLayoutItem) -> RetType;
}
// proto: qreal QGraphicsLayoutItem::minimumWidth();
impl<'a> /*trait*/ QGraphicsLayoutItem_minimumWidth<f64> for () {
fn minimumWidth(self , rsthis: & QGraphicsLayoutItem) -> f64 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK19QGraphicsLayoutItem12minimumWidthEv()};
let mut ret = unsafe {C_ZNK19QGraphicsLayoutItem12minimumWidthEv(rsthis.qclsinst)};
return ret as f64; // 1
// return 1;
}
}
// proto: QGraphicsItem * QGraphicsLayoutItem::graphicsItem();
impl /*struct*/ QGraphicsLayoutItem {
pub fn graphicsItem<RetType, T: QGraphicsLayoutItem_graphicsItem<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.graphicsItem(self);
// return 1;
}
}
pub trait QGraphicsLayoutItem_graphicsItem<RetType> {
fn graphicsItem(self , rsthis: & QGraphicsLayoutItem) -> RetType;
}
// proto: QGraphicsItem * QGraphicsLayoutItem::graphicsItem();
impl<'a> /*trait*/ QGraphicsLayoutItem_graphicsItem<QGraphicsItem> for () {
fn graphicsItem(self , rsthis: & QGraphicsLayoutItem) -> QGraphicsItem {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK19QGraphicsLayoutItem12graphicsItemEv()};
let mut ret = unsafe {C_ZNK19QGraphicsLayoutItem12graphicsItemEv(rsthis.qclsinst)};
let mut ret1 = QGraphicsItem::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: qreal QGraphicsLayoutItem::preferredWidth();
impl /*struct*/ QGraphicsLayoutItem {
pub fn preferredWidth<RetType, T: QGraphicsLayoutItem_preferredWidth<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.preferredWidth(self);
// return 1;
}
}
pub trait QGraphicsLayoutItem_preferredWidth<RetType> {
fn preferredWidth(self , rsthis: & QGraphicsLayoutItem) -> RetType;
}
// proto: qreal QGraphicsLayoutItem::preferredWidth();
impl<'a> /*trait*/ QGraphicsLayoutItem_preferredWidth<f64> for () {
fn preferredWidth(self , rsthis: & QGraphicsLayoutItem) -> f64 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK19QGraphicsLayoutItem14preferredWidthEv()};
let mut ret = unsafe {C_ZNK19QGraphicsLayoutItem14preferredWidthEv(rsthis.qclsinst)};
return ret as f64; // 1
// return 1;
}
}
// proto: bool QGraphicsLayoutItem::ownedByLayout();
impl /*struct*/ QGraphicsLayoutItem {
pub fn ownedByLayout<RetType, T: QGraphicsLayoutItem_ownedByLayout<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.ownedByLayout(self);
// return 1;
}
}
pub trait QGraphicsLayoutItem_ownedByLayout<RetType> {
fn ownedByLayout(self , rsthis: & QGraphicsLayoutItem) -> RetType;
}
// proto: bool QGraphicsLayoutItem::ownedByLayout();
impl<'a> /*trait*/ QGraphicsLayoutItem_ownedByLayout<i8> for () {
fn ownedByLayout(self , rsthis: & QGraphicsLayoutItem) -> i8 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK19QGraphicsLayoutItem13ownedByLayoutEv()};
let mut ret = unsafe {C_ZNK19QGraphicsLayoutItem13ownedByLayoutEv(rsthis.qclsinst)};
return ret as i8; // 1
// return 1;
}
}
// proto: QSizeF QGraphicsLayoutItem::preferredSize();
impl /*struct*/ QGraphicsLayoutItem {
pub fn preferredSize<RetType, T: QGraphicsLayoutItem_preferredSize<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.preferredSize(self);
// return 1;
}
}
pub trait QGraphicsLayoutItem_preferredSize<RetType> {
fn preferredSize(self , rsthis: & QGraphicsLayoutItem) -> RetType;
}
// proto: QSizeF QGraphicsLayoutItem::preferredSize();
impl<'a> /*trait*/ QGraphicsLayoutItem_preferredSize<QSizeF> for () {
fn preferredSize(self , rsthis: & QGraphicsLayoutItem) -> QSizeF {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK19QGraphicsLayoutItem13preferredSizeEv()};
let mut ret = unsafe {C_ZNK19QGraphicsLayoutItem13preferredSizeEv(rsthis.qclsinst)};
let mut ret1 = QSizeF::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: QRectF QGraphicsLayoutItem::geometry();
impl /*struct*/ QGraphicsLayoutItem {
pub fn geometry<RetType, T: QGraphicsLayoutItem_geometry<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.geometry(self);
// return 1;
}
}
pub trait QGraphicsLayoutItem_geometry<RetType> {
fn geometry(self , rsthis: & QGraphicsLayoutItem) -> RetType;
}
// proto: QRectF QGraphicsLayoutItem::geometry();
impl<'a> /*trait*/ QGraphicsLayoutItem_geometry<QRectF> for () {
fn geometry(self , rsthis: & QGraphicsLayoutItem) -> QRectF {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK19QGraphicsLayoutItem8geometryEv()};
let mut ret = unsafe {C_ZNK19QGraphicsLayoutItem8geometryEv(rsthis.qclsinst)};
let mut ret1 = QRectF::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: void QGraphicsLayoutItem::QGraphicsLayoutItem(QGraphicsLayoutItem * parent, bool isLayout);
impl /*struct*/ QGraphicsLayoutItem {
pub fn new<T: QGraphicsLayoutItem_new>(value: T) -> QGraphicsLayoutItem {
let rsthis = value.new();
return rsthis;
// return 1;
}
}
pub trait QGraphicsLayoutItem_new {
fn new(self) -> QGraphicsLayoutItem;
}
// proto: void QGraphicsLayoutItem::QGraphicsLayoutItem(QGraphicsLayoutItem * parent, bool isLayout);
impl<'a> /*trait*/ QGraphicsLayoutItem_new for (Option<&'a QGraphicsLayoutItem>, Option<i8>) {
fn new(self) -> QGraphicsLayoutItem {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN19QGraphicsLayoutItemC2EPS_b()};
let ctysz: c_int = unsafe{QGraphicsLayoutItem_Class_Size()};
let qthis_ph: u64 = unsafe{calloc(1, ctysz as usize)} as u64;
let arg0 = (if self.0.is_none() {0} else {self.0.unwrap().qclsinst}) as *mut c_void;
let arg1 = (if self.1.is_none() {false as i8} else {self.1.unwrap()}) as c_char;
let qthis: u64 = unsafe {C_ZN19QGraphicsLayoutItemC2EPS_b(arg0, arg1)};
let rsthis = QGraphicsLayoutItem{qclsinst: qthis, ..Default::default()};
return rsthis;
// return 1;
}
}
// proto: qreal QGraphicsLayoutItem::minimumHeight();
impl /*struct*/ QGraphicsLayoutItem {
pub fn minimumHeight<RetType, T: QGraphicsLayoutItem_minimumHeight<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.minimumHeight(self);
// return 1;
}
}
pub trait QGraphicsLayoutItem_minimumHeight<RetType> {
fn minimumHeight(self , rsthis: & QGraphicsLayoutItem) -> RetType;
}
// proto: qreal QGraphicsLayoutItem::minimumHeight();
impl<'a> /*trait*/ QGraphicsLayoutItem_minimumHeight<f64> for () {
fn minimumHeight(self , rsthis: & QGraphicsLayoutItem) -> f64 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK19QGraphicsLayoutItem13minimumHeightEv()};
let mut ret = unsafe {C_ZNK19QGraphicsLayoutItem13minimumHeightEv(rsthis.qclsinst)};
return ret as f64; // 1
// return 1;
}
}
// proto: qreal QGraphicsLayoutItem::preferredHeight();
impl /*struct*/ QGraphicsLayoutItem {
pub fn preferredHeight<RetType, T: QGraphicsLayoutItem_preferredHeight<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.preferredHeight(self);
// return 1;
}
}
pub trait QGraphicsLayoutItem_preferredHeight<RetType> {
fn preferredHeight(self , rsthis: & QGraphicsLayoutItem) -> RetType;
}
// proto: qreal QGraphicsLayoutItem::preferredHeight();
impl<'a> /*trait*/ QGraphicsLayoutItem_preferredHeight<f64> for () {
fn preferredHeight(self , rsthis: & QGraphicsLayoutItem) -> f64 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK19QGraphicsLayoutItem15preferredHeightEv()};
let mut ret = unsafe {C_ZNK19QGraphicsLayoutItem15preferredHeightEv(rsthis.qclsinst)};
return ret as f64; // 1
// return 1;
}
}
// proto: QSizeF QGraphicsLayoutItem::maximumSize();
impl /*struct*/ QGraphicsLayoutItem {
pub fn maximumSize<RetType, T: QGraphicsLayoutItem_maximumSize<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.maximumSize(self);
// return 1;
}
}
pub trait QGraphicsLayoutItem_maximumSize<RetType> {
fn maximumSize(self , rsthis: & QGraphicsLayoutItem) -> RetType;
}
// proto: QSizeF QGraphicsLayoutItem::maximumSize();
impl<'a> /*trait*/ QGraphicsLayoutItem_maximumSize<QSizeF> for () {
fn maximumSize(self , rsthis: & QGraphicsLayoutItem) -> QSizeF {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK19QGraphicsLayoutItem11maximumSizeEv()};
let mut ret = unsafe {C_ZNK19QGraphicsLayoutItem11maximumSizeEv(rsthis.qclsinst)};
let mut ret1 = QSizeF::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: QSizePolicy QGraphicsLayoutItem::sizePolicy();
impl /*struct*/ QGraphicsLayoutItem {
pub fn sizePolicy<RetType, T: QGraphicsLayoutItem_sizePolicy<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.sizePolicy(self);
// return 1;
}
}
pub trait QGraphicsLayoutItem_sizePolicy<RetType> {
fn sizePolicy(self , rsthis: & QGraphicsLayoutItem) -> RetType;
}
// proto: QSizePolicy QGraphicsLayoutItem::sizePolicy();
impl<'a> /*trait*/ QGraphicsLayoutItem_sizePolicy<QSizePolicy> for () {
fn sizePolicy(self , rsthis: & QGraphicsLayoutItem) -> QSizePolicy {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK19QGraphicsLayoutItem10sizePolicyEv()};
let mut ret = unsafe {C_ZNK19QGraphicsLayoutItem10sizePolicyEv(rsthis.qclsinst)};
let mut ret1 = QSizePolicy::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: qreal QGraphicsLayoutItem::maximumHeight();
impl /*struct*/ QGraphicsLayoutItem {
pub fn maximumHeight<RetType, T: QGraphicsLayoutItem_maximumHeight<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.maximumHeight(self);
// return 1;
}
}
pub trait QGraphicsLayoutItem_maximumHeight<RetType> {
fn maximumHeight(self , rsthis: & QGraphicsLayoutItem) -> RetType;
}
// proto: qreal QGraphicsLayoutItem::maximumHeight();
impl<'a> /*trait*/ QGraphicsLayoutItem_maximumHeight<f64> for () {
fn maximumHeight(self , rsthis: & QGraphicsLayoutItem) -> f64 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK19QGraphicsLayoutItem13maximumHeightEv()};
let mut ret = unsafe {C_ZNK19QGraphicsLayoutItem13maximumHeightEv(rsthis.qclsinst)};
return ret as f64; // 1
// return 1;
}
}
// proto: void QGraphicsLayoutItem::setGeometry(const QRectF & rect);
impl /*struct*/ QGraphicsLayoutItem {
pub fn setGeometry<RetType, T: QGraphicsLayoutItem_setGeometry<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setGeometry(self);
// return 1;
}
}
pub trait QGraphicsLayoutItem_setGeometry<RetType> {
fn setGeometry(self , rsthis: & QGraphicsLayoutItem) -> RetType;
}
// proto: void QGraphicsLayoutItem::setGeometry(const QRectF & rect);
impl<'a> /*trait*/ QGraphicsLayoutItem_setGeometry<()> for (&'a QRectF) {
fn setGeometry(self , rsthis: & QGraphicsLayoutItem) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN19QGraphicsLayoutItem11setGeometryERK6QRectF()};
let arg0 = self.qclsinst as *mut c_void;
unsafe {C_ZN19QGraphicsLayoutItem11setGeometryERK6QRectF(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: void QGraphicsLayoutItem::setPreferredWidth(qreal width);
impl /*struct*/ QGraphicsLayoutItem {
pub fn setPreferredWidth<RetType, T: QGraphicsLayoutItem_setPreferredWidth<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setPreferredWidth(self);
// return 1;
}
}
pub trait QGraphicsLayoutItem_setPreferredWidth<RetType> {
fn setPreferredWidth(self , rsthis: & QGraphicsLayoutItem) -> RetType;
}
// proto: void QGraphicsLayoutItem::setPreferredWidth(qreal width);
impl<'a> /*trait*/ QGraphicsLayoutItem_setPreferredWidth<()> for (f64) {
fn setPreferredWidth(self , rsthis: & QGraphicsLayoutItem) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN19QGraphicsLayoutItem17setPreferredWidthEd()};
let arg0 = self as c_double;
unsafe {C_ZN19QGraphicsLayoutItem17setPreferredWidthEd(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: void QGraphicsLayoutItem::setMaximumSize(const QSizeF & size);
impl /*struct*/ QGraphicsLayoutItem {
pub fn setMaximumSize<RetType, T: QGraphicsLayoutItem_setMaximumSize<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setMaximumSize(self);
// return 1;
}
}
pub trait QGraphicsLayoutItem_setMaximumSize<RetType> {
fn setMaximumSize(self , rsthis: & QGraphicsLayoutItem) -> RetType;
}
// proto: void QGraphicsLayoutItem::setMaximumSize(const QSizeF & size);
impl<'a> /*trait*/ QGraphicsLayoutItem_setMaximumSize<()> for (&'a QSizeF) {
fn setMaximumSize(self , rsthis: & QGraphicsLayoutItem) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN19QGraphicsLayoutItem14setMaximumSizeERK6QSizeF()};
let arg0 = self.qclsinst as *mut c_void;
unsafe {C_ZN19QGraphicsLayoutItem14setMaximumSizeERK6QSizeF(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: qreal QGraphicsLayoutItem::maximumWidth();
impl /*struct*/ QGraphicsLayoutItem {
pub fn maximumWidth<RetType, T: QGraphicsLayoutItem_maximumWidth<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.maximumWidth(self);
// return 1;
}
}
pub trait QGraphicsLayoutItem_maximumWidth<RetType> {
fn maximumWidth(self , rsthis: & QGraphicsLayoutItem) -> RetType;
}
// proto: qreal QGraphicsLayoutItem::maximumWidth();
impl<'a> /*trait*/ QGraphicsLayoutItem_maximumWidth<f64> for () {
fn maximumWidth(self , rsthis: & QGraphicsLayoutItem) -> f64 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK19QGraphicsLayoutItem12maximumWidthEv()};
let mut ret = unsafe {C_ZNK19QGraphicsLayoutItem12maximumWidthEv(rsthis.qclsinst)};
return ret as f64; // 1
// return 1;
}
}
// proto: void QGraphicsLayoutItem::setMinimumSize(qreal w, qreal h);
impl /*struct*/ QGraphicsLayoutItem {
pub fn setMinimumSize<RetType, T: QGraphicsLayoutItem_setMinimumSize<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setMinimumSize(self);
// return 1;
}
}
pub trait QGraphicsLayoutItem_setMinimumSize<RetType> {
fn setMinimumSize(self , rsthis: & QGraphicsLayoutItem) -> RetType;
}
// proto: void QGraphicsLayoutItem::setMinimumSize(qreal w, qreal h);
impl<'a> /*trait*/ QGraphicsLayoutItem_setMinimumSize<()> for (f64, f64) {
fn setMinimumSize(self , rsthis: & QGraphicsLayoutItem) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN19QGraphicsLayoutItem14setMinimumSizeEdd()};
let arg0 = self.0 as c_double;
let arg1 = self.1 as c_double;
unsafe {C_ZN19QGraphicsLayoutItem14setMinimumSizeEdd(rsthis.qclsinst, arg0, arg1)};
// return 1;
}
}
// proto: void QGraphicsLayoutItem::setMaximumHeight(qreal height);
impl /*struct*/ QGraphicsLayoutItem {
pub fn setMaximumHeight<RetType, T: QGraphicsLayoutItem_setMaximumHeight<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setMaximumHeight(self);
// return 1;
}
}
pub trait QGraphicsLayoutItem_setMaximumHeight<RetType> {
fn setMaximumHeight(self , rsthis: & QGraphicsLayoutItem) -> RetType;
}
// proto: void QGraphicsLayoutItem::setMaximumHeight(qreal height);
impl<'a> /*trait*/ QGraphicsLayoutItem_setMaximumHeight<()> for (f64) {
fn setMaximumHeight(self , rsthis: & QGraphicsLayoutItem) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN19QGraphicsLayoutItem16setMaximumHeightEd()};
let arg0 = self as c_double;
unsafe {C_ZN19QGraphicsLayoutItem16setMaximumHeightEd(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: void QGraphicsLayoutItem::setMinimumSize(const QSizeF & size);
impl<'a> /*trait*/ QGraphicsLayoutItem_setMinimumSize<()> for (&'a QSizeF) {
fn setMinimumSize(self , rsthis: & QGraphicsLayoutItem) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN19QGraphicsLayoutItem14setMinimumSizeERK6QSizeF()};
let arg0 = self.qclsinst as *mut c_void;
unsafe {C_ZN19QGraphicsLayoutItem14setMinimumSizeERK6QSizeF(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: void QGraphicsLayoutItem::setPreferredSize(const QSizeF & size);
impl /*struct*/ QGraphicsLayoutItem {
pub fn setPreferredSize<RetType, T: QGraphicsLayoutItem_setPreferredSize<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setPreferredSize(self);
// return 1;
}
}
pub trait QGraphicsLayoutItem_setPreferredSize<RetType> {
fn setPreferredSize(self , rsthis: & QGraphicsLayoutItem) -> RetType;
}
// proto: void QGraphicsLayoutItem::setPreferredSize(const QSizeF & size);
impl<'a> /*trait*/ QGraphicsLayoutItem_setPreferredSize<()> for (&'a QSizeF) {
fn setPreferredSize(self , rsthis: & QGraphicsLayoutItem) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN19QGraphicsLayoutItem16setPreferredSizeERK6QSizeF()};
let arg0 = self.qclsinst as *mut c_void;
unsafe {C_ZN19QGraphicsLayoutItem16setPreferredSizeERK6QSizeF(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: void QGraphicsLayoutItem::getContentsMargins(qreal * left, qreal * top, qreal * right, qreal * bottom);
impl /*struct*/ QGraphicsLayoutItem {
pub fn getContentsMargins<RetType, T: QGraphicsLayoutItem_getContentsMargins<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.getContentsMargins(self);
// return 1;
}
}
pub trait QGraphicsLayoutItem_getContentsMargins<RetType> {
fn getContentsMargins(self , rsthis: & QGraphicsLayoutItem) -> RetType;
}
// proto: void QGraphicsLayoutItem::getContentsMargins(qreal * left, qreal * top, qreal * right, qreal * bottom);
impl<'a> /*trait*/ QGraphicsLayoutItem_getContentsMargins<()> for (&'a mut Vec<f64>, &'a mut Vec<f64>, &'a mut Vec<f64>, &'a mut Vec<f64>) {
fn getContentsMargins(self , rsthis: & QGraphicsLayoutItem) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK19QGraphicsLayoutItem18getContentsMarginsEPdS0_S0_S0_()};
let arg0 = self.0.as_ptr() as *mut c_double;
let arg1 = self.1.as_ptr() as *mut c_double;
let arg2 = self.2.as_ptr() as *mut c_double;
let arg3 = self.3.as_ptr() as *mut c_double;
unsafe {C_ZNK19QGraphicsLayoutItem18getContentsMarginsEPdS0_S0_S0_(rsthis.qclsinst, arg0, arg1, arg2, arg3)};
// return 1;
}
}
// proto: void QGraphicsLayoutItem::setParentLayoutItem(QGraphicsLayoutItem * parent);
impl /*struct*/ QGraphicsLayoutItem {
pub fn setParentLayoutItem<RetType, T: QGraphicsLayoutItem_setParentLayoutItem<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setParentLayoutItem(self);
// return 1;
}
}
pub trait QGraphicsLayoutItem_setParentLayoutItem<RetType> {
fn setParentLayoutItem(self , rsthis: & QGraphicsLayoutItem) -> RetType;
}
// proto: void QGraphicsLayoutItem::setParentLayoutItem(QGraphicsLayoutItem * parent);
impl<'a> /*trait*/ QGraphicsLayoutItem_setParentLayoutItem<()> for (&'a QGraphicsLayoutItem) {
fn setParentLayoutItem(self , rsthis: & QGraphicsLayoutItem) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN19QGraphicsLayoutItem19setParentLayoutItemEPS_()};
let arg0 = self.qclsinst as *mut c_void;
unsafe {C_ZN19QGraphicsLayoutItem19setParentLayoutItemEPS_(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: void QGraphicsLayoutItem::setMinimumWidth(qreal width);
impl /*struct*/ QGraphicsLayoutItem {
pub fn setMinimumWidth<RetType, T: QGraphicsLayoutItem_setMinimumWidth<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setMinimumWidth(self);
// return 1;
}
}
pub trait QGraphicsLayoutItem_setMinimumWidth<RetType> {
fn setMinimumWidth(self , rsthis: & QGraphicsLayoutItem) -> RetType;
}
// proto: void QGraphicsLayoutItem::setMinimumWidth(qreal width);
impl<'a> /*trait*/ QGraphicsLayoutItem_setMinimumWidth<()> for (f64) {
fn setMinimumWidth(self , rsthis: & QGraphicsLayoutItem) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN19QGraphicsLayoutItem15setMinimumWidthEd()};
let arg0 = self as c_double;
unsafe {C_ZN19QGraphicsLayoutItem15setMinimumWidthEd(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: void QGraphicsLayoutItem::setMaximumWidth(qreal width);
impl /*struct*/ QGraphicsLayoutItem {
pub fn setMaximumWidth<RetType, T: QGraphicsLayoutItem_setMaximumWidth<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setMaximumWidth(self);
// return 1;
}
}
pub trait QGraphicsLayoutItem_setMaximumWidth<RetType> {
fn setMaximumWidth(self , rsthis: & QGraphicsLayoutItem) -> RetType;
}
// proto: void QGraphicsLayoutItem::setMaximumWidth(qreal width);
impl<'a> /*trait*/ QGraphicsLayoutItem_setMaximumWidth<()> for (f64) {
fn setMaximumWidth(self , rsthis: & QGraphicsLayoutItem) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN19QGraphicsLayoutItem15setMaximumWidthEd()};
let arg0 = self as c_double;
unsafe {C_ZN19QGraphicsLayoutItem15setMaximumWidthEd(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: void QGraphicsLayoutItem::updateGeometry();
impl /*struct*/ QGraphicsLayoutItem {
pub fn updateGeometry<RetType, T: QGraphicsLayoutItem_updateGeometry<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.updateGeometry(self);
// return 1;
}
}
pub trait QGraphicsLayoutItem_updateGeometry<RetType> {
fn updateGeometry(self , rsthis: & QGraphicsLayoutItem) -> RetType;
}
// proto: void QGraphicsLayoutItem::updateGeometry();
impl<'a> /*trait*/ QGraphicsLayoutItem_updateGeometry<()> for () {
fn updateGeometry(self , rsthis: & QGraphicsLayoutItem) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN19QGraphicsLayoutItem14updateGeometryEv()};
unsafe {C_ZN19QGraphicsLayoutItem14updateGeometryEv(rsthis.qclsinst)};
// return 1;
}
}
// proto: void QGraphicsLayoutItem::setPreferredHeight(qreal height);
impl /*struct*/ QGraphicsLayoutItem {
pub fn setPreferredHeight<RetType, T: QGraphicsLayoutItem_setPreferredHeight<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setPreferredHeight(self);
// return 1;
}
}
pub trait QGraphicsLayoutItem_setPreferredHeight<RetType> {
fn setPreferredHeight(self , rsthis: & QGraphicsLayoutItem) -> RetType;
}
// proto: void QGraphicsLayoutItem::setPreferredHeight(qreal height);
impl<'a> /*trait*/ QGraphicsLayoutItem_setPreferredHeight<()> for (f64) {
fn setPreferredHeight(self , rsthis: & QGraphicsLayoutItem) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN19QGraphicsLayoutItem18setPreferredHeightEd()};
let arg0 = self as c_double;
unsafe {C_ZN19QGraphicsLayoutItem18setPreferredHeightEd(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: QSizeF QGraphicsLayoutItem::minimumSize();
impl /*struct*/ QGraphicsLayoutItem {
pub fn minimumSize<RetType, T: QGraphicsLayoutItem_minimumSize<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.minimumSize(self);
// return 1;
}
}
pub trait QGraphicsLayoutItem_minimumSize<RetType> {
fn minimumSize(self , rsthis: & QGraphicsLayoutItem) -> RetType;
}
// proto: QSizeF QGraphicsLayoutItem::minimumSize();
impl<'a> /*trait*/ QGraphicsLayoutItem_minimumSize<QSizeF> for () {
fn minimumSize(self , rsthis: & QGraphicsLayoutItem) -> QSizeF {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK19QGraphicsLayoutItem11minimumSizeEv()};
let mut ret = unsafe {C_ZNK19QGraphicsLayoutItem11minimumSizeEv(rsthis.qclsinst)};
let mut ret1 = QSizeF::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: QRectF QGraphicsLayoutItem::contentsRect();
impl /*struct*/ QGraphicsLayoutItem {
pub fn contentsRect<RetType, T: QGraphicsLayoutItem_contentsRect<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.contentsRect(self);
// return 1;
}
}
pub trait QGraphicsLayoutItem_contentsRect<RetType> {
fn contentsRect(self , rsthis: & QGraphicsLayoutItem) -> RetType;
}
// proto: QRectF QGraphicsLayoutItem::contentsRect();
impl<'a> /*trait*/ QGraphicsLayoutItem_contentsRect<QRectF> for () {
fn contentsRect(self , rsthis: & QGraphicsLayoutItem) -> QRectF {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK19QGraphicsLayoutItem12contentsRectEv()};
let mut ret = unsafe {C_ZNK19QGraphicsLayoutItem12contentsRectEv(rsthis.qclsinst)};
let mut ret1 = QRectF::inheritFrom(ret as u64);
return ret1;
// return 1;
}
}
// proto: bool QGraphicsLayoutItem::isLayout();
impl /*struct*/ QGraphicsLayoutItem {
pub fn isLayout<RetType, T: QGraphicsLayoutItem_isLayout<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.isLayout(self);
// return 1;
}
}
pub trait QGraphicsLayoutItem_isLayout<RetType> {
fn isLayout(self , rsthis: & QGraphicsLayoutItem) -> RetType;
}
// proto: bool QGraphicsLayoutItem::isLayout();
impl<'a> /*trait*/ QGraphicsLayoutItem_isLayout<i8> for () {
fn isLayout(self , rsthis: & QGraphicsLayoutItem) -> i8 {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZNK19QGraphicsLayoutItem8isLayoutEv()};
let mut ret = unsafe {C_ZNK19QGraphicsLayoutItem8isLayoutEv(rsthis.qclsinst)};
return ret as i8; // 1
// return 1;
}
}
// proto: void QGraphicsLayoutItem::setPreferredSize(qreal w, qreal h);
impl<'a> /*trait*/ QGraphicsLayoutItem_setPreferredSize<()> for (f64, f64) {
fn setPreferredSize(self , rsthis: & QGraphicsLayoutItem) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN19QGraphicsLayoutItem16setPreferredSizeEdd()};
let arg0 = self.0 as c_double;
let arg1 = self.1 as c_double;
unsafe {C_ZN19QGraphicsLayoutItem16setPreferredSizeEdd(rsthis.qclsinst, arg0, arg1)};
// return 1;
}
}
// proto: void QGraphicsLayoutItem::~QGraphicsLayoutItem();
impl /*struct*/ QGraphicsLayoutItem {
pub fn free<RetType, T: QGraphicsLayoutItem_free<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.free(self);
// return 1;
}
}
pub trait QGraphicsLayoutItem_free<RetType> {
fn free(self , rsthis: & QGraphicsLayoutItem) -> RetType;
}
// proto: void QGraphicsLayoutItem::~QGraphicsLayoutItem();
impl<'a> /*trait*/ QGraphicsLayoutItem_free<()> for () {
fn free(self , rsthis: & QGraphicsLayoutItem) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN19QGraphicsLayoutItemD2Ev()};
unsafe {C_ZN19QGraphicsLayoutItemD2Ev(rsthis.qclsinst)};
// return 1;
}
}
// proto: void QGraphicsLayoutItem::setMinimumHeight(qreal height);
impl /*struct*/ QGraphicsLayoutItem {
pub fn setMinimumHeight<RetType, T: QGraphicsLayoutItem_setMinimumHeight<RetType>>(& self, overload_args: T) -> RetType {
return overload_args.setMinimumHeight(self);
// return 1;
}
}
pub trait QGraphicsLayoutItem_setMinimumHeight<RetType> {
fn setMinimumHeight(self , rsthis: & QGraphicsLayoutItem) -> RetType;
}
// proto: void QGraphicsLayoutItem::setMinimumHeight(qreal height);
impl<'a> /*trait*/ QGraphicsLayoutItem_setMinimumHeight<()> for (f64) {
fn setMinimumHeight(self , rsthis: & QGraphicsLayoutItem) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN19QGraphicsLayoutItem16setMinimumHeightEd()};
let arg0 = self as c_double;
unsafe {C_ZN19QGraphicsLayoutItem16setMinimumHeightEd(rsthis.qclsinst, arg0)};
// return 1;
}
}
// proto: void QGraphicsLayoutItem::setMaximumSize(qreal w, qreal h);
impl<'a> /*trait*/ QGraphicsLayoutItem_setMaximumSize<()> for (f64, f64) {
fn setMaximumSize(self , rsthis: & QGraphicsLayoutItem) -> () {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN19QGraphicsLayoutItem14setMaximumSizeEdd()};
let arg0 = self.0 as c_double;
let arg1 = self.1 as c_double;
unsafe {C_ZN19QGraphicsLayoutItem14setMaximumSizeEdd(rsthis.qclsinst, arg0, arg1)};
// return 1;
}
}
// <= body block end
|
#![cfg(target_arch = "x86_64")]
use std::arch::x86_64::*;
use crate::detail::sse::{hi_dp, hi_dp_bc, rcp_nr1, rsqrt_nr1};
use std::ops::Neg;
/// The `branch` both a line through the origin and also the principal branch of
/// the logarithm of a rotor.
///
/// The rotor branch will be most commonly constructed by taking the
/// logarithm of a normalized rotor. The branch may then be linearly scaled
/// to adjust the "strength" of the rotor, and subsequently re-exponentiated
/// to create the adjusted rotor.
///
/// !!! example
///
/// Suppose we have a rotor $r$ and we wish to produce a rotor
/// $\sqrt[4]{r}$ which performs a quarter of the rotation produced by
/// $r$. We can construct it like so:
///
/// ```c++
/// kln::branch b = r.log();
/// kln::rotor r_4 = (0.25f * b).exp();
/// ```
///
/// !!! note
///
/// The branch of a rotor is technically a `line`, but because there are
/// no translational components, the branch is given its own type for
/// efficiency.
#[derive(Copy, Clone, Debug)]
pub struct Branch {
pub p1_: __m128,
}
common_operations!(Branch, p1_);
impl Branch {
/// Construct the branch as the following multivector:
///
/// $$a \mathbf{e}_{23} + b\mathbf{e}_{31} + c\mathbf{e}_{12}$$
///
/// To convince yourself this is a line through the origin, remember that
/// such a line can be generated using the geometric product of two planes
/// through the origin.
pub fn new(a: f32, b: f32, c: f32) -> Branch {
unsafe {
Branch {
p1_: _mm_set_ps(c, b, a, 0.),
}
}
}
/// If a line is constructed as the regressive product (join) of
/// two points, the squared norm provided here is the squared
/// distance between the two points (provided the points are
/// normalized). Returns $d^2 + e^2 + f^2$.
pub fn squared_norm(self) -> f32 {
let mut out: f32 = 0.;
let dp: __m128 = hi_dp(self.p1_, self.p1_);
unsafe {
_mm_store_ss(&mut out, dp);
}
out
}
/// Returns the square root of the quantity produced by `squared_norm`.
pub fn norm(self) -> f32 {
f32::sqrt(self.squared_norm())
}
pub fn normalize(&mut self) {
unsafe {
let inv_norm: __m128;
inv_norm = rsqrt_nr1(hi_dp_bc(self.p1_, self.p1_));
self.p1_ = _mm_mul_ps(self.p1_, inv_norm);
}
}
pub fn invert(&mut self) {
let inv_norm: __m128 = rsqrt_nr1(hi_dp_bc(self.p1_, self.p1_));
unsafe {
self.p1_ = _mm_mul_ps(self.p1_, inv_norm);
self.p1_ = _mm_mul_ps(self.p1_, inv_norm);
self.p1_ = _mm_xor_ps(_mm_set_ps(-0., -0., -0., 0.), self.p1_);
}
}
pub fn inverse(self) -> Branch {
let mut out = Branch::from(self.p1_);
out.invert();
out
}
}
impl Mul<Branch> for f32 {
type Output = Branch;
#[inline]
fn mul(self, p: Branch) -> Branch {
p * self
}
}
impl Mul<Branch> for f64 {
type Output = Branch;
#[inline]
fn mul(self, p: Branch) -> Branch {
p * self as f32
}
}
impl Mul<Branch> for i32 {
type Output = Branch;
#[inline]
fn mul(self, p: Branch) -> Branch {
p * self as f32
}
}
/// Ideal line uniform inverse scale
impl<T: Into<f32>> Div<T> for Branch {
type Output = Branch;
#[inline]
fn div(self, s: T) -> Self {
unsafe { Branch::from(_mm_mul_ps(self.p1_, rcp_nr1(_mm_set1_ps(s.into())))) }
}
}
impl Branch {
/// Store m128 contents into an array of 4 floats
pub fn store(self, out: &mut f32) {
unsafe {
_mm_store_ps(&mut *out, self.p1_);
}
}
get_basis_blade_fn!(e12, e21, p1_, 3);
get_basis_blade_fn!(e31, e13, p1_, 2);
get_basis_blade_fn!(e23, e32, p1_, 1);
pub fn z(self) -> f32 {
self.e12()
}
pub fn y(self) -> f32 {
self.e31()
}
pub fn x(self) -> f32 {
self.e23()
}
}
impl Neg for Branch {
type Output = Self;
/// Unary minus
#[inline]
fn neg(self) -> Self::Output {
Self::from(unsafe { _mm_xor_ps(self.p1_, _mm_set1_ps(-0.)) })
}
}
|
#[doc = "Reader of register ODSR"]
pub type R = crate::R<u32, super::ODSR>;
#[doc = "Timer E Output 2 disable status\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum TE2ODS_A {
#[doc = "0: Output disabled in idle state"]
IDLE = 0,
#[doc = "1: Output disabled in fault state"]
FAULT = 1,
}
impl From<TE2ODS_A> for bool {
#[inline(always)]
fn from(variant: TE2ODS_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `TE2ODS`"]
pub type TE2ODS_R = crate::R<bool, TE2ODS_A>;
impl TE2ODS_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> TE2ODS_A {
match self.bits {
false => TE2ODS_A::IDLE,
true => TE2ODS_A::FAULT,
}
}
#[doc = "Checks if the value of the field is `IDLE`"]
#[inline(always)]
pub fn is_idle(&self) -> bool {
*self == TE2ODS_A::IDLE
}
#[doc = "Checks if the value of the field is `FAULT`"]
#[inline(always)]
pub fn is_fault(&self) -> bool {
*self == TE2ODS_A::FAULT
}
}
#[doc = "Timer E Output 1 disable status"]
pub type TE1ODS_A = TE2ODS_A;
#[doc = "Reader of field `TE1ODS`"]
pub type TE1ODS_R = crate::R<bool, TE2ODS_A>;
#[doc = "Timer D Output 2 disable status"]
pub type TD2ODS_A = TE2ODS_A;
#[doc = "Reader of field `TD2ODS`"]
pub type TD2ODS_R = crate::R<bool, TE2ODS_A>;
#[doc = "Timer D Output 1 disable status"]
pub type TD1ODS_A = TE2ODS_A;
#[doc = "Reader of field `TD1ODS`"]
pub type TD1ODS_R = crate::R<bool, TE2ODS_A>;
#[doc = "Timer C Output 2 disable status"]
pub type TC2ODS_A = TE2ODS_A;
#[doc = "Reader of field `TC2ODS`"]
pub type TC2ODS_R = crate::R<bool, TE2ODS_A>;
#[doc = "Timer C Output 1 disable status"]
pub type TC1ODS_A = TE2ODS_A;
#[doc = "Reader of field `TC1ODS`"]
pub type TC1ODS_R = crate::R<bool, TE2ODS_A>;
#[doc = "Timer B Output 2 disable status"]
pub type TB2ODS_A = TE2ODS_A;
#[doc = "Reader of field `TB2ODS`"]
pub type TB2ODS_R = crate::R<bool, TE2ODS_A>;
#[doc = "Timer B Output 1 disable status"]
pub type TB1ODS_A = TE2ODS_A;
#[doc = "Reader of field `TB1ODS`"]
pub type TB1ODS_R = crate::R<bool, TE2ODS_A>;
#[doc = "Timer A Output 2 disable status"]
pub type TA2ODS_A = TE2ODS_A;
#[doc = "Reader of field `TA2ODS`"]
pub type TA2ODS_R = crate::R<bool, TE2ODS_A>;
#[doc = "Timer A Output 1 disable status"]
pub type TA1ODS_A = TE2ODS_A;
#[doc = "Reader of field `TA1ODS`"]
pub type TA1ODS_R = crate::R<bool, TE2ODS_A>;
impl R {
#[doc = "Bit 9 - Timer E Output 2 disable status"]
#[inline(always)]
pub fn te2ods(&self) -> TE2ODS_R {
TE2ODS_R::new(((self.bits >> 9) & 0x01) != 0)
}
#[doc = "Bit 8 - Timer E Output 1 disable status"]
#[inline(always)]
pub fn te1ods(&self) -> TE1ODS_R {
TE1ODS_R::new(((self.bits >> 8) & 0x01) != 0)
}
#[doc = "Bit 7 - Timer D Output 2 disable status"]
#[inline(always)]
pub fn td2ods(&self) -> TD2ODS_R {
TD2ODS_R::new(((self.bits >> 7) & 0x01) != 0)
}
#[doc = "Bit 6 - Timer D Output 1 disable status"]
#[inline(always)]
pub fn td1ods(&self) -> TD1ODS_R {
TD1ODS_R::new(((self.bits >> 6) & 0x01) != 0)
}
#[doc = "Bit 5 - Timer C Output 2 disable status"]
#[inline(always)]
pub fn tc2ods(&self) -> TC2ODS_R {
TC2ODS_R::new(((self.bits >> 5) & 0x01) != 0)
}
#[doc = "Bit 4 - Timer C Output 1 disable status"]
#[inline(always)]
pub fn tc1ods(&self) -> TC1ODS_R {
TC1ODS_R::new(((self.bits >> 4) & 0x01) != 0)
}
#[doc = "Bit 3 - Timer B Output 2 disable status"]
#[inline(always)]
pub fn tb2ods(&self) -> TB2ODS_R {
TB2ODS_R::new(((self.bits >> 3) & 0x01) != 0)
}
#[doc = "Bit 2 - Timer B Output 1 disable status"]
#[inline(always)]
pub fn tb1ods(&self) -> TB1ODS_R {
TB1ODS_R::new(((self.bits >> 2) & 0x01) != 0)
}
#[doc = "Bit 1 - Timer A Output 2 disable status"]
#[inline(always)]
pub fn ta2ods(&self) -> TA2ODS_R {
TA2ODS_R::new(((self.bits >> 1) & 0x01) != 0)
}
#[doc = "Bit 0 - Timer A Output 1 disable status"]
#[inline(always)]
pub fn ta1ods(&self) -> TA1ODS_R {
TA1ODS_R::new((self.bits & 0x01) != 0)
}
}
|
use P35::PrimeIterator;
pub fn list_primes_in_range(lower: u32, upper: u32) -> Vec<u32> {
PrimeIterator::new()
.skip_while(|&p| p < lower)
.take_while(|&p| p <= upper)
.collect()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_list_primes_in_range() {
assert_eq!(
list_primes_in_range(7, 31),
vec![7, 11, 13, 17, 19, 23, 29, 31]
);
}
}
|
use otp::make_totp;
use super::error::{
NotpError,
NotpResult,
};
/// A trait that defines the functionality of a OTP to implement.
///
/// Any OTP implementation should have new to initalize the secret token and
/// generate function to get the generated 6 digit code.
pub(crate) trait OTP<T> {
fn new(token: &str) -> Self;
fn generate(
&self,
epoch: u64,
time_step: u64,
) -> NotpResult<T>;
}
/// New implementation of otp generator.
///
/// Takes token and stores it as `String`. It does not use any complex types to
/// handle token generation.
pub(crate) struct OtpGenerator {
secret: String,
}
impl OTP<u32> for OtpGenerator {
/// Returns new OTPString instance that holds `String`: token.
fn new(token: &str) -> Self {
Self {
secret: token.to_string(),
}
}
/// Generates One Time Password using given otp token.
fn generate(
&self,
epoch: u64,
time_step: u64,
) -> NotpResult<u32> {
let totp = make_totp(&self.secret, time_step, epoch as i64);
match totp {
Ok(code) => {
if code <= 99999 {
Err(NotpError::Generic(format!(
"Something unexpected happened! Wait a minute and try \
it later. The code I've generated is not 6 digit. \
Here look: {}",
code
)))
} else {
Ok(code)
}
}
Err(e) => Err(NotpError::OTPStringError(e)),
}
}
}
#[cfg(test)]
mod tests {}
|
use crate::config::CONFIG;
use async_redis_session::RedisSessionStore;
use diesel::{pg::PgConnection, r2d2::ConnectionManager};
use r2d2::Pool;
use std::str::FromStr;
use tracing::{debug, info, Level};
use tracing_subscriber::FmtSubscriber;
fn init_session_store() -> RedisSessionStore {
debug!("init session store connection");
RedisSessionStore::new(CONFIG.session.url.as_str()).unwrap()
}
type DbConnectionPool = Pool<ConnectionManager<PgConnection>>;
fn init_db_connectin_pool() -> DbConnectionPool {
let url = CONFIG.database.url.as_str();
let pool_size = CONFIG.database.pool_size;
debug!(
"init databse connection: [{}], with pool size: {}",
url, pool_size
);
let manager = ConnectionManager::<PgConnection>::new(url);
r2d2::Pool::builder()
.max_size(pool_size)
.build(manager)
.unwrap()
}
#[derive(Clone)]
pub struct AppConnections {
pub db_connections: DbConnectionPool,
pub session_store: RedisSessionStore,
}
pub fn init_appliations() -> AppConnections {
// init application width logging
let sub = FmtSubscriber::builder()
.with_max_level(Level::from_str(CONFIG.log.level.as_str()).unwrap())
.finish();
tracing::subscriber::set_global_default(sub).unwrap();
info!("logger is initiated, init_appliations");
AppConnections {
db_connections: init_db_connectin_pool(),
session_store: init_session_store(),
}
}
|
// Copyright 2021 Datafuse Labs.
//
// 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.
use std::sync::Arc;
use common_catalog::table::TableExt;
use common_exception::ErrorCode;
use common_exception::Result;
use common_meta_app::schema::DropTableByIdReq;
use common_sql::plans::DropTablePlan;
use common_storages_view::view_table::VIEW_ENGINE;
use crate::interpreters::Interpreter;
use crate::pipelines::PipelineBuildResult;
use crate::sessions::QueryContext;
use crate::sessions::TableContext;
pub struct DropTableInterpreter {
ctx: Arc<QueryContext>,
plan: DropTablePlan,
}
impl DropTableInterpreter {
pub fn try_create(ctx: Arc<QueryContext>, plan: DropTablePlan) -> Result<Self> {
Ok(DropTableInterpreter { ctx, plan })
}
}
#[async_trait::async_trait]
impl Interpreter for DropTableInterpreter {
fn name(&self) -> &str {
"DropTableInterpreter"
}
async fn execute2(&self) -> Result<PipelineBuildResult> {
let catalog_name = self.plan.catalog.as_str();
let db_name = self.plan.database.as_str();
let tbl_name = self.plan.table.as_str();
let tbl = self
.ctx
.get_table(catalog_name, db_name, tbl_name)
.await
.ok();
if let Some(tbl) = tbl {
if tbl.get_table_info().engine() == VIEW_ENGINE {
return Err(ErrorCode::TableEngineNotSupported(format!(
"{}.{} engine is VIEW that doesn't support drop, use `DROP VIEW {}.{}` instead",
&self.plan.database, &self.plan.table, &self.plan.database, &self.plan.table
)));
}
let catalog = self.ctx.get_catalog(catalog_name)?;
catalog
.drop_table_by_id(DropTableByIdReq {
if_exists: self.plan.if_exists,
tb_id: tbl.get_table_info().ident.table_id,
})
.await?;
// if `plan.all`, truncate, then purge the historical data
if self.plan.all {
let purge = true;
// the above `catalog.drop_table` operation changed the table meta version,
// thus if we do not refresh the table instance, `truncate` will fail
let latest = tbl.as_ref().refresh(self.ctx.as_ref()).await?;
latest.truncate(self.ctx.clone(), purge).await?
}
}
Ok(PipelineBuildResult::create())
}
}
|
#[doc = r"Value read from the register"]
pub struct R {
bits: u32,
}
#[doc = r"Value to write to the register"]
pub struct W {
bits: u32,
}
impl super::PCI2C {
#[doc = r"Modifies the contents of the register"]
#[inline(always)]
pub fn modify<F>(&self, f: F)
where
for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
{
let bits = self.register.get();
self.register.set(f(&R { bits }, &mut W { bits }).bits);
}
#[doc = r"Reads the contents of the register"]
#[inline(always)]
pub fn read(&self) -> R {
R {
bits: self.register.get(),
}
}
#[doc = r"Writes to the register"]
#[inline(always)]
pub fn write<F>(&self, f: F)
where
F: FnOnce(&mut W) -> &mut W,
{
self.register.set(
f(&mut W {
bits: Self::reset_value(),
})
.bits,
);
}
#[doc = r"Reset value of the register"]
#[inline(always)]
pub const fn reset_value() -> u32 {
0
}
#[doc = r"Writes the reset value to the register"]
#[inline(always)]
pub fn reset(&self) {
self.register.set(Self::reset_value())
}
}
#[doc = r"Value of the field"]
pub struct SYSCTL_PCI2C_P0R {
bits: bool,
}
impl SYSCTL_PCI2C_P0R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _SYSCTL_PCI2C_P0W<'a> {
w: &'a mut W,
}
impl<'a> _SYSCTL_PCI2C_P0W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(1 << 0);
self.w.bits |= ((value as u32) & 1) << 0;
self.w
}
}
#[doc = r"Value of the field"]
pub struct SYSCTL_PCI2C_P1R {
bits: bool,
}
impl SYSCTL_PCI2C_P1R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _SYSCTL_PCI2C_P1W<'a> {
w: &'a mut W,
}
impl<'a> _SYSCTL_PCI2C_P1W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(1 << 1);
self.w.bits |= ((value as u32) & 1) << 1;
self.w
}
}
#[doc = r"Value of the field"]
pub struct SYSCTL_PCI2C_P2R {
bits: bool,
}
impl SYSCTL_PCI2C_P2R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _SYSCTL_PCI2C_P2W<'a> {
w: &'a mut W,
}
impl<'a> _SYSCTL_PCI2C_P2W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(1 << 2);
self.w.bits |= ((value as u32) & 1) << 2;
self.w
}
}
#[doc = r"Value of the field"]
pub struct SYSCTL_PCI2C_P3R {
bits: bool,
}
impl SYSCTL_PCI2C_P3R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _SYSCTL_PCI2C_P3W<'a> {
w: &'a mut W,
}
impl<'a> _SYSCTL_PCI2C_P3W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(1 << 3);
self.w.bits |= ((value as u32) & 1) << 3;
self.w
}
}
#[doc = r"Value of the field"]
pub struct SYSCTL_PCI2C_P4R {
bits: bool,
}
impl SYSCTL_PCI2C_P4R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _SYSCTL_PCI2C_P4W<'a> {
w: &'a mut W,
}
impl<'a> _SYSCTL_PCI2C_P4W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(1 << 4);
self.w.bits |= ((value as u32) & 1) << 4;
self.w
}
}
#[doc = r"Value of the field"]
pub struct SYSCTL_PCI2C_P5R {
bits: bool,
}
impl SYSCTL_PCI2C_P5R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _SYSCTL_PCI2C_P5W<'a> {
w: &'a mut W,
}
impl<'a> _SYSCTL_PCI2C_P5W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(1 << 5);
self.w.bits |= ((value as u32) & 1) << 5;
self.w
}
}
#[doc = r"Value of the field"]
pub struct SYSCTL_PCI2C_P6R {
bits: bool,
}
impl SYSCTL_PCI2C_P6R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _SYSCTL_PCI2C_P6W<'a> {
w: &'a mut W,
}
impl<'a> _SYSCTL_PCI2C_P6W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(1 << 6);
self.w.bits |= ((value as u32) & 1) << 6;
self.w
}
}
#[doc = r"Value of the field"]
pub struct SYSCTL_PCI2C_P7R {
bits: bool,
}
impl SYSCTL_PCI2C_P7R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _SYSCTL_PCI2C_P7W<'a> {
w: &'a mut W,
}
impl<'a> _SYSCTL_PCI2C_P7W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(1 << 7);
self.w.bits |= ((value as u32) & 1) << 7;
self.w
}
}
#[doc = r"Value of the field"]
pub struct SYSCTL_PCI2C_P8R {
bits: bool,
}
impl SYSCTL_PCI2C_P8R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _SYSCTL_PCI2C_P8W<'a> {
w: &'a mut W,
}
impl<'a> _SYSCTL_PCI2C_P8W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(1 << 8);
self.w.bits |= ((value as u32) & 1) << 8;
self.w
}
}
#[doc = r"Value of the field"]
pub struct SYSCTL_PCI2C_P9R {
bits: bool,
}
impl SYSCTL_PCI2C_P9R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _SYSCTL_PCI2C_P9W<'a> {
w: &'a mut W,
}
impl<'a> _SYSCTL_PCI2C_P9W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(1 << 9);
self.w.bits |= ((value as u32) & 1) << 9;
self.w
}
}
impl R {
#[doc = r"Value of the register as raw bits"]
#[inline(always)]
pub fn bits(&self) -> u32 {
self.bits
}
#[doc = "Bit 0 - I2C Module 0 Power Control"]
#[inline(always)]
pub fn sysctl_pci2c_p0(&self) -> SYSCTL_PCI2C_P0R {
let bits = ((self.bits >> 0) & 1) != 0;
SYSCTL_PCI2C_P0R { bits }
}
#[doc = "Bit 1 - I2C Module 1 Power Control"]
#[inline(always)]
pub fn sysctl_pci2c_p1(&self) -> SYSCTL_PCI2C_P1R {
let bits = ((self.bits >> 1) & 1) != 0;
SYSCTL_PCI2C_P1R { bits }
}
#[doc = "Bit 2 - I2C Module 2 Power Control"]
#[inline(always)]
pub fn sysctl_pci2c_p2(&self) -> SYSCTL_PCI2C_P2R {
let bits = ((self.bits >> 2) & 1) != 0;
SYSCTL_PCI2C_P2R { bits }
}
#[doc = "Bit 3 - I2C Module 3 Power Control"]
#[inline(always)]
pub fn sysctl_pci2c_p3(&self) -> SYSCTL_PCI2C_P3R {
let bits = ((self.bits >> 3) & 1) != 0;
SYSCTL_PCI2C_P3R { bits }
}
#[doc = "Bit 4 - I2C Module 4 Power Control"]
#[inline(always)]
pub fn sysctl_pci2c_p4(&self) -> SYSCTL_PCI2C_P4R {
let bits = ((self.bits >> 4) & 1) != 0;
SYSCTL_PCI2C_P4R { bits }
}
#[doc = "Bit 5 - I2C Module 5 Power Control"]
#[inline(always)]
pub fn sysctl_pci2c_p5(&self) -> SYSCTL_PCI2C_P5R {
let bits = ((self.bits >> 5) & 1) != 0;
SYSCTL_PCI2C_P5R { bits }
}
#[doc = "Bit 6 - I2C Module 6 Power Control"]
#[inline(always)]
pub fn sysctl_pci2c_p6(&self) -> SYSCTL_PCI2C_P6R {
let bits = ((self.bits >> 6) & 1) != 0;
SYSCTL_PCI2C_P6R { bits }
}
#[doc = "Bit 7 - I2C Module 7 Power Control"]
#[inline(always)]
pub fn sysctl_pci2c_p7(&self) -> SYSCTL_PCI2C_P7R {
let bits = ((self.bits >> 7) & 1) != 0;
SYSCTL_PCI2C_P7R { bits }
}
#[doc = "Bit 8 - I2C Module 8 Power Control"]
#[inline(always)]
pub fn sysctl_pci2c_p8(&self) -> SYSCTL_PCI2C_P8R {
let bits = ((self.bits >> 8) & 1) != 0;
SYSCTL_PCI2C_P8R { bits }
}
#[doc = "Bit 9 - I2C Module 9 Power Control"]
#[inline(always)]
pub fn sysctl_pci2c_p9(&self) -> SYSCTL_PCI2C_P9R {
let bits = ((self.bits >> 9) & 1) != 0;
SYSCTL_PCI2C_P9R { bits }
}
}
impl W {
#[doc = r"Writes raw bits to the register"]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.bits = bits;
self
}
#[doc = "Bit 0 - I2C Module 0 Power Control"]
#[inline(always)]
pub fn sysctl_pci2c_p0(&mut self) -> _SYSCTL_PCI2C_P0W {
_SYSCTL_PCI2C_P0W { w: self }
}
#[doc = "Bit 1 - I2C Module 1 Power Control"]
#[inline(always)]
pub fn sysctl_pci2c_p1(&mut self) -> _SYSCTL_PCI2C_P1W {
_SYSCTL_PCI2C_P1W { w: self }
}
#[doc = "Bit 2 - I2C Module 2 Power Control"]
#[inline(always)]
pub fn sysctl_pci2c_p2(&mut self) -> _SYSCTL_PCI2C_P2W {
_SYSCTL_PCI2C_P2W { w: self }
}
#[doc = "Bit 3 - I2C Module 3 Power Control"]
#[inline(always)]
pub fn sysctl_pci2c_p3(&mut self) -> _SYSCTL_PCI2C_P3W {
_SYSCTL_PCI2C_P3W { w: self }
}
#[doc = "Bit 4 - I2C Module 4 Power Control"]
#[inline(always)]
pub fn sysctl_pci2c_p4(&mut self) -> _SYSCTL_PCI2C_P4W {
_SYSCTL_PCI2C_P4W { w: self }
}
#[doc = "Bit 5 - I2C Module 5 Power Control"]
#[inline(always)]
pub fn sysctl_pci2c_p5(&mut self) -> _SYSCTL_PCI2C_P5W {
_SYSCTL_PCI2C_P5W { w: self }
}
#[doc = "Bit 6 - I2C Module 6 Power Control"]
#[inline(always)]
pub fn sysctl_pci2c_p6(&mut self) -> _SYSCTL_PCI2C_P6W {
_SYSCTL_PCI2C_P6W { w: self }
}
#[doc = "Bit 7 - I2C Module 7 Power Control"]
#[inline(always)]
pub fn sysctl_pci2c_p7(&mut self) -> _SYSCTL_PCI2C_P7W {
_SYSCTL_PCI2C_P7W { w: self }
}
#[doc = "Bit 8 - I2C Module 8 Power Control"]
#[inline(always)]
pub fn sysctl_pci2c_p8(&mut self) -> _SYSCTL_PCI2C_P8W {
_SYSCTL_PCI2C_P8W { w: self }
}
#[doc = "Bit 9 - I2C Module 9 Power Control"]
#[inline(always)]
pub fn sysctl_pci2c_p9(&mut self) -> _SYSCTL_PCI2C_P9W {
_SYSCTL_PCI2C_P9W { w: self }
}
}
|
pub const CPUID_EXT_HYPERVISOR: u32 = 1 << 31;
|
use as_derive_utils::{
datastructure::{DataStructure, DataVariant, Field, FieldMap, TypeParamMap},
parse_utils::{ret_err_on, ret_err_on_peek, ParseBufferExt},
return_spanned_err, return_syn_err, spanned_err, syn_err,
utils::SynErrorExt,
};
use syn::{
parse::ParseBuffer, punctuated::Punctuated, token::Comma, Attribute, Expr, ExprLit, Ident, Lit,
Token, Type, TypeParamBound, WherePredicate,
};
use std::{collections::HashSet, mem};
use core_extensions::{matches, IteratorExt};
use proc_macro2::Span;
use crate::*;
use crate::{
attribute_parsing::contains_doc_hidden,
impl_interfacetype::{parse_impl_interfacetype, ImplInterfaceType},
parse_utils::{parse_str_as_ident, ParseBounds, ParsePunctuated},
utils::{LinearResult, SynResultExt},
};
use super::{
nonexhaustive::{
EnumInterface, ExprOrType, NonExhaustive, UncheckedNEVariant, UncheckedNonExhaustive,
UncheckedVariantConstructor,
},
prefix_types::{
AccessorOrMaybe, FirstSuffixField, OnMissingField, PrefixKind, PrefixKindCtor,
PrefixKindField,
},
reflection::{FieldAccessor, ModReflMode},
repr_attrs::{
DiscriminantRepr, Repr, ReprAttr, UncheckedReprAttr, UncheckedReprKind, REPR_ERROR_MSG,
},
};
mod kw {
syn::custom_keyword! {accessible_if}
syn::custom_keyword! {accessor_bound}
syn::custom_keyword! {assert_nonexhaustive}
syn::custom_keyword! {align}
syn::custom_keyword! {bounds}
syn::custom_keyword! {bound}
syn::custom_keyword! {Clone}
syn::custom_keyword! {C}
syn::custom_keyword! {Debug}
syn::custom_keyword! {debug_print}
syn::custom_keyword! {default}
syn::custom_keyword! {Deref}
syn::custom_keyword! {Deserialize}
syn::custom_keyword! {Display}
syn::custom_keyword! {Eq}
syn::custom_keyword! {Error}
syn::custom_keyword! {extra_checks}
syn::custom_keyword! {Hash}
syn::custom_keyword! {ident}
syn::custom_keyword! {interface}
syn::custom_keyword! {impl_InterfaceType}
syn::custom_keyword! {impl_prefix_stable_abi}
syn::custom_keyword! {kind}
syn::custom_keyword! {last_prefix_field}
syn::custom_keyword! {missing_field}
syn::custom_keyword! {module_reflection}
syn::custom_keyword! {Module}
syn::custom_keyword! {not_stableabi}
syn::custom_keyword! {Opaque}
syn::custom_keyword! {option}
syn::custom_keyword! {Ord}
syn::custom_keyword! {packed}
syn::custom_keyword! {panic}
syn::custom_keyword! {PartialEq}
syn::custom_keyword! {PartialOrd}
syn::custom_keyword! {phantom_const_param}
syn::custom_keyword! {phantom_field}
syn::custom_keyword! {phantom_type_param}
syn::custom_keyword! {prefix_bounds}
syn::custom_keyword! {prefix_bound}
syn::custom_keyword! {prefix_fields}
syn::custom_keyword! {prefix_ref}
syn::custom_keyword! {prefix_ref_docs}
syn::custom_keyword! {Prefix}
syn::custom_keyword! {pub_getter}
syn::custom_keyword! {refl}
syn::custom_keyword! {rename}
syn::custom_keyword! {size}
syn::custom_keyword! {Send}
syn::custom_keyword! {Serialize}
syn::custom_keyword! {Sync}
syn::custom_keyword! {tag}
syn::custom_keyword! {transparent}
syn::custom_keyword! {traits}
syn::custom_keyword! {unrecognized}
syn::custom_keyword! {unsafe_allow_type_macros}
syn::custom_keyword! {unsafe_change_type}
syn::custom_keyword! {unsafe_opaque_fields}
syn::custom_keyword! {unsafe_opaque_field}
syn::custom_keyword! {unsafe_sabi_opaque_fields}
syn::custom_keyword! {unsafe_sabi_opaque_field}
syn::custom_keyword! {unsafe_unconstrained}
syn::custom_keyword! {value}
syn::custom_keyword! {Value}
syn::custom_keyword! {with_boxed_constructor}
syn::custom_keyword! {with_constructor}
syn::custom_keyword! {with_field_indices}
syn::custom_keyword! {WithNonExhaustive}
syn::custom_keyword! {with}
}
pub(crate) struct StableAbiOptions<'a> {
pub(crate) debug_print: bool,
pub(crate) kind: StabilityKind<'a>,
pub(crate) repr: ReprAttr,
pub(crate) type_param_bounds: TypeParamMap<'a, ASTypeParamBound>,
pub(crate) extra_bounds: Vec<WherePredicate>,
pub(crate) tags: Option<syn::Expr>,
pub(crate) extra_checks: Option<syn::Expr>,
pub(crate) layout_ctor: FieldMap<LayoutConstructor>,
pub(crate) override_field_accessor: FieldMap<Option<FieldAccessor<'a>>>,
pub(crate) renamed_fields: FieldMap<Option<&'a Ident>>,
pub(crate) changed_types: FieldMap<Option<&'a Type>>,
pub(crate) doc_hidden_attr: Option<&'a TokenStream2>,
pub(crate) mod_refl_mode: ModReflMode<usize>,
pub(crate) impl_interfacetype: Option<ImplInterfaceType>,
pub(crate) phantom_fields: Vec<(&'a Ident, &'a Type)>,
pub(crate) phantom_type_params: Vec<&'a Type>,
pub(crate) phantom_const_params: Vec<&'a syn::Expr>,
pub(crate) const_idents: ConstIdents,
pub(crate) allow_type_macros: bool,
pub(crate) with_field_indices: bool,
}
//////////////////////
/// Identifiers of generated top-level constants.
pub struct ConstIdents {
/// The identifier of a constant where the string in MonoSharedVars will be stored.
pub(crate) strings: Ident,
}
//////////////////////
#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
pub(crate) enum ASTypeParamBound {
NoBound,
GetStaticEquivalent,
StableAbi,
}
impl Default for ASTypeParamBound {
fn default() -> Self {
ASTypeParamBound::StableAbi
}
}
//////////////////////
#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
pub(crate) enum LayoutConstructor {
Regular,
Opaque,
SabiOpaque,
}
impl LayoutConstructor {
pub(crate) fn is_opaque(self) -> bool {
matches!(self, LayoutConstructor::Opaque { .. })
}
}
impl From<ASTypeParamBound> for LayoutConstructor {
fn from(bound: ASTypeParamBound) -> Self {
match bound {
ASTypeParamBound::NoBound => LayoutConstructor::Opaque,
ASTypeParamBound::GetStaticEquivalent => LayoutConstructor::Opaque,
ASTypeParamBound::StableAbi => LayoutConstructor::Regular,
}
}
}
impl Default for LayoutConstructor {
fn default() -> Self {
LayoutConstructor::Regular
}
}
//////////////////////
pub(crate) enum StabilityKind<'a> {
Value { impl_prefix_stable_abi: bool },
Prefix(PrefixKind<'a>),
NonExhaustive(NonExhaustive<'a>),
}
impl<'a> StabilityKind<'a> {
pub(crate) fn field_accessor(
&self,
mod_refl_mode: ModReflMode<usize>,
field: &Field<'a>,
) -> FieldAccessor<'a> {
let is_public = field.is_public() && mod_refl_mode != ModReflMode::Opaque;
match (is_public, self) {
(false, _) => FieldAccessor::Opaque,
(true, StabilityKind::Value { .. }) | (true, StabilityKind::NonExhaustive { .. }) => {
FieldAccessor::Direct
}
(true, StabilityKind::Prefix(prefix)) => prefix.field_accessor(field),
}
}
}
impl<'a> StableAbiOptions<'a> {
fn new(
ds: &'a DataStructure<'a>,
mut this: StableAbiAttrs<'a>,
arenas: &'a Arenas,
) -> Result<Self, syn::Error> {
let mut phantom_fields = Vec::<(&'a Ident, &'a Type)>::new();
let repr = ReprAttr::new(this.repr)?;
let mut errors = LinearResult::ok(());
let kind = match this.kind {
_ if repr.is_repr_transparent() => {
// let field=&ds.variants[0].fields[0];
// let accessor_bound=syn::parse_str::<WherePredicate>(
// &format!("({}):__StableAbi",(&field.mutated_ty).into_token_stream())
// ).expect(concat!(file!(),"-",line!()));
// this.extra_bounds.push(accessor_bound);
StabilityKind::Value {
impl_prefix_stable_abi: false,
}
}
UncheckedStabilityKind::Value {
impl_prefix_stable_abi,
} => StabilityKind::Value {
impl_prefix_stable_abi,
},
UncheckedStabilityKind::Prefix(prefix) => PrefixKindCtor::<'a> {
arenas,
struct_name: ds.name,
first_suffix_field: this.first_suffix_field,
prefix_ref: prefix.prefix_ref,
prefix_fields: prefix.prefix_fields,
replacing_prefix_ref_docs: prefix.replacing_prefix_ref_docs,
fields: mem::replace(&mut this.prefix_kind_fields, FieldMap::empty()).map(
|fi, pk_field| {
AccessorOrMaybe::new(
fi,
this.first_suffix_field,
pk_field,
this.default_on_missing_fields.unwrap_or_default(),
)
},
),
prefix_bounds: this.prefix_bounds,
accessor_bounds: this.accessor_bounds,
}
.make()
.piped(StabilityKind::Prefix),
UncheckedStabilityKind::NonExhaustive(nonexhaustive) => {
let ne_variants = this.ne_variants;
nonexhaustive
.piped(|x| NonExhaustive::new(x, ne_variants, ds, arenas))?
.piped(StabilityKind::NonExhaustive)
}
};
match (repr.variant, ds.data_variant) {
(Repr::Transparent, DataVariant::Struct) => {}
(Repr::Transparent, _) => {
errors.push_err(syn_err!(
*repr.span,
"\nAbiStable does not suport non-struct #[repr(transparent)] types.\n"
));
}
(Repr::Int { .. }, DataVariant::Enum) => {}
(Repr::Int { .. }, _) => {
errors.push_err(syn_err!(
*repr.span,
"AbiStable does not suport non-enum #[repr(<some_integer_type>)] types."
));
}
(Repr::C { .. }, _) => {}
}
let mod_refl_mode = match this.mod_refl_mode {
Some(ModReflMode::Module) => ModReflMode::Module,
Some(ModReflMode::Opaque) => ModReflMode::Opaque,
Some(ModReflMode::DelegateDeref(())) => {
let index = phantom_fields.len();
let field_ty =
syn::parse_str::<Type>("<Self as __sabi_re::GetPointerKind >::PtrTarget")
.expect("BUG")
.piped(|x| arenas.alloc(x));
let dt = arenas.alloc(parse_str_as_ident("deref_target"));
phantom_fields.push((dt, field_ty));
[
"Self: __sabi_re::GetPointerKind",
"<Self as __sabi_re::GetPointerKind>::Target: __StableAbi",
]
.iter()
.map(|x| syn::parse_str::<WherePredicate>(x).expect("BUG"))
.extending(&mut this.extra_bounds);
ModReflMode::DelegateDeref(index)
}
None if ds.has_public_fields() => ModReflMode::Module,
None => ModReflMode::Opaque,
};
phantom_fields.extend(this.extra_phantom_fields);
phantom_fields.extend(this.phantom_type_params.iter().cloned().enumerate().map(
|(i, ty)| {
let x = format!("_phantom_ty_param_{}", i);
let name = arenas.alloc(parse_str_as_ident(&x));
(name, ty)
},
));
let doc_hidden_attr = if this.is_hidden {
Some(arenas.alloc(quote!(#[doc(hidden)])))
} else {
None
};
let const_idents = ConstIdents {
strings: parse_str_as_ident(&format!("_SHARED_VARS_STRINGS_{}", ds.name)),
};
errors.into_result()?;
Ok(StableAbiOptions {
debug_print: this.debug_print,
kind,
repr,
extra_bounds: this.extra_bounds,
type_param_bounds: this.type_param_bounds,
layout_ctor: this.layout_ctor,
renamed_fields: this.renamed_fields,
changed_types: this.changed_types,
override_field_accessor: this.override_field_accessor,
tags: this.tags,
extra_checks: this.extra_checks,
impl_interfacetype: this.impl_interfacetype,
phantom_fields,
phantom_type_params: this.phantom_type_params,
phantom_const_params: this.phantom_const_params,
allow_type_macros: this.allow_type_macros,
with_field_indices: this.with_field_indices,
const_idents,
mod_refl_mode,
doc_hidden_attr,
})
}
}
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
#[derive(Default)]
struct StableAbiAttrs<'a> {
debug_print: bool,
kind: UncheckedStabilityKind<'a>,
repr: UncheckedReprAttr,
extra_bounds: Vec<WherePredicate>,
tags: Option<syn::Expr>,
extra_checks: Option<syn::Expr>,
first_suffix_field: FirstSuffixField,
default_on_missing_fields: Option<OnMissingField<'a>>,
prefix_kind_fields: FieldMap<PrefixKindField<'a>>,
prefix_bounds: Vec<WherePredicate>,
type_param_bounds: TypeParamMap<'a, ASTypeParamBound>,
layout_ctor: FieldMap<LayoutConstructor>,
ne_variants: Vec<UncheckedNEVariant>,
override_field_accessor: FieldMap<Option<FieldAccessor<'a>>>,
renamed_fields: FieldMap<Option<&'a Ident>>,
changed_types: FieldMap<Option<&'a Type>>,
accessor_bounds: FieldMap<Vec<TypeParamBound>>,
extra_phantom_fields: Vec<(&'a Ident, &'a Type)>,
phantom_type_params: Vec<&'a Type>,
phantom_const_params: Vec<&'a syn::Expr>,
impl_interfacetype: Option<ImplInterfaceType>,
mod_refl_mode: Option<ModReflMode<()>>,
allow_type_macros: bool,
with_field_indices: bool,
is_hidden: bool,
errors: LinearResult<()>,
}
#[derive(Clone)]
enum UncheckedStabilityKind<'a> {
Value { impl_prefix_stable_abi: bool },
Prefix(UncheckedPrefixKind<'a>),
NonExhaustive(UncheckedNonExhaustive<'a>),
}
#[derive(Copy, Clone)]
struct UncheckedPrefixKind<'a> {
prefix_ref: Option<&'a Ident>,
prefix_fields: Option<&'a Ident>,
replacing_prefix_ref_docs: &'a [syn::Expr],
}
impl<'a> Default for UncheckedStabilityKind<'a> {
fn default() -> Self {
UncheckedStabilityKind::Value {
impl_prefix_stable_abi: false,
}
}
}
#[derive(Copy, Clone)]
enum ParseContext<'a> {
TypeAttr,
Variant {
variant_index: usize,
},
Field {
field_index: usize,
field: &'a Field<'a>,
},
}
/// Parses the attributes for the `StableAbi` derive macro.
pub(crate) fn parse_attrs_for_stable_abi<'a, I>(
attrs: I,
ds: &'a DataStructure<'a>,
arenas: &'a Arenas,
) -> Result<StableAbiOptions<'a>, syn::Error>
where
I: IntoIterator<Item = &'a Attribute>,
{
let mut this = StableAbiAttrs::default();
this.layout_ctor = FieldMap::defaulted(ds);
this.prefix_kind_fields = FieldMap::defaulted(ds);
this.renamed_fields = FieldMap::defaulted(ds);
this.override_field_accessor = FieldMap::defaulted(ds);
this.accessor_bounds = FieldMap::defaulted(ds);
this.changed_types = FieldMap::defaulted(ds);
this.ne_variants.resize(
ds.variants.len(),
UncheckedNEVariant {
constructor: None,
is_hidden: false,
},
);
this.type_param_bounds = TypeParamMap::defaulted(ds);
parse_inner(&mut this, attrs, ParseContext::TypeAttr, arenas);
for (variant_index, variant) in ds.variants.iter().enumerate() {
parse_inner(
&mut this,
variant.attrs,
ParseContext::Variant { variant_index },
arenas,
);
for (field_index, field) in variant.fields.iter().enumerate() {
parse_inner(
&mut this,
field.attrs,
ParseContext::Field { field, field_index },
arenas,
);
}
}
this.errors.take()?;
StableAbiOptions::new(ds, this, arenas)
}
/// Parses an individual attribute
fn parse_inner<'a, I>(
this: &mut StableAbiAttrs<'a>,
attrs: I,
pctx: ParseContext<'a>,
arenas: &'a Arenas,
) where
I: IntoIterator<Item = &'a Attribute>,
{
for attr in attrs {
if attr.path.is_ident("sabi") {
attr.parse_args_with(|input: &'_ ParseBuffer<'_>| {
input.for_each_separated(Token!(,), |input| {
parse_sabi_attr(this, pctx, input, arenas)
})
})
} else if attr.path.is_ident("doc") {
(|| -> syn::Result<()> {
let is_hidden =
syn::parse::Parser::parse2(contains_doc_hidden, attr.tokens.clone())?;
match pctx {
ParseContext::TypeAttr { .. } => {
this.is_hidden = is_hidden;
}
ParseContext::Variant { variant_index, .. } => {
this.ne_variants[variant_index].is_hidden = is_hidden;
}
ParseContext::Field { .. } => {}
}
Ok(())
})()
} else if attr.path.is_ident("repr") {
fn parse_int_arg(input: &'_ ParseBuffer<'_>) -> Result<u32, syn::Error> {
input.parse_paren_buffer()?.parse_int::<u32>()
}
attr.parse_args_with(|input: &'_ ParseBuffer<'_>| {
input.for_each_separated(Token!(,), |input| {
let span = input.span();
if input.check_parse(kw::C)? {
this.repr.set_repr_kind(UncheckedReprKind::C, span)
} else if input.check_parse(kw::transparent)? {
this.repr
.set_repr_kind(UncheckedReprKind::Transparent, span)
} else if input.check_parse(kw::align)? {
this.repr.set_aligned(parse_int_arg(input)?)
} else if input.check_parse(kw::packed)? {
if input.peek(syn::token::Paren) {
this.repr.set_packed(Some(parse_int_arg(input)?))
} else {
this.repr.set_packed(None)
}
} else if let Some(dr) = DiscriminantRepr::from_parser(input) {
this.repr.set_discriminant_repr(dr, span)
} else {
Err(syn_err!(
span,
"repr attribute not currently recognized by this macro.{}",
REPR_ERROR_MSG
))
}?;
Ok(())
})
})
} else {
Ok(())
}
.combine_into_err(&mut this.errors);
}
}
/// Parses the contents of a `#[sabi( .. )]` attribute.
fn parse_sabi_attr<'a>(
this: &mut StableAbiAttrs<'a>,
pctx: ParseContext<'a>,
input: &'_ ParseBuffer<'_>,
arenas: &'a Arenas,
) -> Result<(), syn::Error> {
fn make_err(input: &ParseBuffer) -> syn::Error {
input.error("unrecognized attribute")
}
if let ParseContext::TypeAttr = pctx {
fn parse_pred(input: &ParseBuffer) -> Result<WherePredicate, syn::Error> {
let input = input.parse_paren_buffer()?;
ret_err_on_peek! {input, syn::Lit, "where predicate", "literal"}
input
.parse::<WherePredicate>()
.map_err(|e| e.prepend_msg("while parsing where predicate: "))
}
fn parse_preds(
input: &ParseBuffer<'_>,
) -> Result<Punctuated<WherePredicate, Comma>, syn::Error> {
let input = input.parse_paren_buffer()?;
ret_err_on_peek! {input, syn::Lit, "where predicates", "literal"}
match input.parse::<ParsePunctuated<WherePredicate, Comma>>() {
Ok(x) => Ok(x.list),
Err(e) => Err(e.prepend_msg("while parsing where predicates: ")),
}
}
if input.check_parse(kw::bound)? {
this.extra_bounds.push(parse_pred(input)?);
} else if input.check_parse(kw::prefix_bound)? {
this.prefix_bounds.push(parse_pred(input)?);
} else if input.check_parse(kw::bounds)? {
this.extra_bounds.extend(parse_preds(input)?);
} else if input.check_parse(kw::prefix_bounds)? {
this.prefix_bounds.extend(parse_preds(input)?);
} else if input.check_parse(kw::phantom_field)? {
input.parse_paren_with(|input| {
let fname = arenas.alloc(input.parse::<Ident>()?);
let _ = input.parse::<Token!(:)>()?;
let ty = arenas.alloc(input.parse_type()?);
this.extra_phantom_fields.push((fname, ty));
Ok(())
})?;
} else if input.check_parse(kw::phantom_type_param)? {
input.parse::<Token!(=)>()?;
let ty = arenas.alloc(input.parse_type()?);
this.phantom_type_params.push(ty);
} else if input.check_parse(kw::phantom_const_param)? {
input.parse::<Token!(=)>()?;
let constant = arenas.alloc(input.parse_expr()?);
ret_err_on! {
matches!(constant, syn::Expr::Lit(ExprLit{lit: Lit::Str{..}, ..})),
syn::spanned::Spanned::span(constant),
"`impl StableAbi + Eq + Debug` expression",
"string literal",
}
this.phantom_const_params.push(constant);
} else if let Some(tag_token) = input.peek_parse(kw::tag)? {
input.parse::<Token!(=)>()?;
ret_err_on_peek! {
input,
syn::Lit,
"`abi_stable::type_layout::Tag` expression",
"literal",
}
let bound = input.parse_expr()?;
if this.tags.is_some() {
return_syn_err!(
tag_token.span,
"\
Cannot specify multiple tags,\
you must choose whether you want array or set semantics \
when adding more tags.\n\
\n\
For multiple elements you can do:\n\
\n\
- `tag![[ tag0,tag1 ]]` or `Tag::arr(&[ tag0,tag1 ])` :\n\
\tThis will require that the tags match exactly between \
interface and implementation.\n\
\n\
- `tag!{{ tag0,tag1 }}` or `Tag::set(&[ tag0,tag1 ])` :\n\
\tThis will require that the tags in the interface are \
a subset of the implementation.\n\
",
);
}
this.tags = Some(bound);
} else if let Some(ec_token) = input.peek_parse(kw::extra_checks)? {
input.parse::<Token!(=)>()?;
ret_err_on_peek! {input, syn::Lit, "`impl ExtraChecks` expression", "literal"}
let bound = input.parse_expr()?;
if this.extra_checks.is_some() {
return_syn_err!(
ec_token.span,
"cannot use the `#[sabi(extra_checks=\"\")]` \
attribute multiple times,\
"
);
}
this.extra_checks = Some(bound);
} else if input.check_parse(kw::missing_field)? {
let on_missing = &mut this.default_on_missing_fields;
if on_missing.is_some() {
return Err(
input.error("Cannot use this attribute multiple times on the same type")
);
}
*on_missing = Some(input.parse_paren_with(|i| parse_missing_field(i, arenas))?);
} else if input.check_parse(kw::kind)? {
input.parse_paren_with(|input| {
if input.check_parse(kw::Value)? {
this.kind = UncheckedStabilityKind::Value {
impl_prefix_stable_abi: false,
};
} else if input.check_parse(kw::Prefix)? {
if input.peek(syn::token::Paren) {
let prefix = input
.parse_paren_with(|input| parse_prefix_type_list(input, arenas))?;
this.kind = UncheckedStabilityKind::Prefix(prefix);
} else {
let prefix = parse_prefix_type_list(input, arenas)?;
this.kind = UncheckedStabilityKind::Prefix(prefix);
}
} else if input.check_parse(kw::WithNonExhaustive)? {
let nonexhaustive =
input.parse_paren_with(|input| parse_non_exhaustive_list(input, arenas))?;
this.kind = UncheckedStabilityKind::NonExhaustive(nonexhaustive);
} else {
return Err(input.error("invalid #[kind(..)] attribute"));
}
Ok(())
})?;
} else if input.check_parse(kw::debug_print)? {
this.debug_print = true;
} else if input.check_parse(kw::module_reflection)? {
input
.parse_paren_buffer()?
.for_each_separated(Token!(,), |input| {
if this.mod_refl_mode.is_some() {
return Err(input.error("Cannot use this attribute multiple times"));
}
if input.check_parse(kw::Module)? {
this.mod_refl_mode = Some(ModReflMode::Module);
} else if input.check_parse(kw::Opaque)? {
this.mod_refl_mode = Some(ModReflMode::Opaque);
} else if input.check_parse(kw::Deref)? {
this.mod_refl_mode = Some(ModReflMode::DelegateDeref(()));
} else {
return Err(input.error("invalid #[module_reflection(..)] attribute."));
}
Ok(())
})?;
} else if input.check_parse(kw::not_stableabi)? {
input
.parse_paren_buffer()?
.for_each_separated(Token!(,), |input| {
let type_param = input.parse::<Ident>().map_err(|_| {
input.error(
"\
invalid #[not_stableabi(..)] attribute\
(it must be the identifier of a type parameter).\
",
)
})?;
*this.type_param_bounds.get_mut(&type_param)? =
ASTypeParamBound::GetStaticEquivalent;
Ok(())
})?;
} else if input.check_parse(kw::unsafe_unconstrained)? {
input
.parse_paren_buffer()?
.for_each_separated(Token!(,), |input| {
let type_param = input.parse::<Ident>().map_err(|_| {
input.error(
"\
invalid #[unsafe_unconstrained(..)] attribute\
(it must be the identifier of a type parameter).\
",
)
})?;
*this.type_param_bounds.get_mut(&type_param)? = ASTypeParamBound::NoBound;
Ok(())
})?;
} else if let Some(attr_ident) = input.peek_parse(kw::impl_InterfaceType)? {
if this.impl_interfacetype.is_some() {
return_spanned_err!(attr_ident, "Cannot use this attribute multiple times")
}
let content = input.parse_paren_buffer()?;
this.impl_interfacetype = Some(parse_impl_interfacetype(&content)?);
} else if input.check_parse(kw::with_constructor)? {
this.ne_variants
.iter_mut()
.for_each(|x| x.constructor = Some(UncheckedVariantConstructor::Regular));
} else if input.check_parse(kw::with_boxed_constructor)? {
this.ne_variants
.iter_mut()
.for_each(|x| x.constructor = Some(UncheckedVariantConstructor::Boxed));
} else if input.check_parse(kw::unsafe_opaque_fields)? {
this.layout_ctor
.iter_mut()
.for_each(|(_, x)| *x = LayoutConstructor::Opaque);
} else if input.check_parse(kw::unsafe_sabi_opaque_fields)? {
this.layout_ctor
.iter_mut()
.for_each(|(_, x)| *x = LayoutConstructor::SabiOpaque);
} else if input.check_parse(kw::unsafe_allow_type_macros)? {
this.allow_type_macros = true;
} else if input.check_parse(kw::with_field_indices)? {
this.with_field_indices = true;
} else if input.check_parse(kw::impl_prefix_stable_abi)? {
this.kind = UncheckedStabilityKind::Value {
impl_prefix_stable_abi: true,
};
} else {
return Err(make_err(input));
}
} else if let ParseContext::Variant { variant_index } = pctx {
if input.check_parse(kw::with_constructor)? {
this.ne_variants[variant_index].constructor =
Some(UncheckedVariantConstructor::Regular);
} else if input.check_parse(kw::with_boxed_constructor)? {
this.ne_variants[variant_index].constructor = Some(UncheckedVariantConstructor::Boxed);
} else {
return Err(make_err(input));
}
} else if let ParseContext::Field { field, field_index } = pctx {
if input.check_parse(kw::unsafe_opaque_field)? {
this.layout_ctor[field] = LayoutConstructor::Opaque;
} else if input.check_parse(kw::unsafe_sabi_opaque_field)? {
this.layout_ctor[field] = LayoutConstructor::SabiOpaque;
} else if input.check_parse(kw::last_prefix_field)? {
let field_pos = field_index + 1;
this.first_suffix_field = FirstSuffixField { field_pos };
} else if input.check_parse(kw::rename)? {
input.parse::<Token!(=)>()?;
let renamed = input.parse::<Ident>()?.piped(|x| arenas.alloc(x));
this.renamed_fields.insert(field, Some(renamed));
} else if input.check_parse(kw::unsafe_change_type)? {
input.parse::<Token!(=)>()?;
let changed_type = input.parse_type()?.piped(|x| arenas.alloc(x));
this.changed_types.insert(field, Some(changed_type));
} else if input.check_parse(kw::accessible_if)? {
input.parse::<Token!(=)>()?;
let expr = input.parse_expr()?;
if let Expr::Lit(ExprLit { lit, .. }) = &expr {
ret_err_on! {
!matches!(lit, Lit::Bool{..}),
syn::spanned::Spanned::span(&expr),
"`bool` expression",
"non-bool literal",
}
}
let expr = arenas.alloc(expr);
this.prefix_kind_fields[field].accessible_if = Some(expr);
} else if input.check_parse(kw::accessor_bound)? {
input.parse::<Token!(=)>()?;
let bound = input.parse::<ParseBounds>()?.list;
this.accessor_bounds[field].extend(bound);
} else if input.check_parse(kw::bound)? {
input.parse::<Token!(=)>()?;
let bounds = input.parse::<ParseBounds>()?.list;
let preds = where_predicate_from(field.ty.clone(), bounds);
this.extra_bounds.push(preds);
} else if input.check_parse(kw::missing_field)? {
let on_missing_field =
input.parse_paren_with(|input| parse_missing_field(input, arenas))?;
let on_missing = &mut this.prefix_kind_fields[field].on_missing;
if on_missing.is_some() {
return Err(
input.error("Cannot use this attribute multiple times on the same field")
);
}
*on_missing = Some(on_missing_field);
} else if input.check_parse(kw::refl)? {
input.parse_paren_with(|input| parse_refl_field(this, field, input, arenas))?;
} else {
return Err(make_err(input));
}
}
Ok(())
}
/// Parses the `#[sabi(refl = ...)` attribute.
fn parse_refl_field<'a>(
this: &mut StableAbiAttrs<'a>,
field: &'a Field<'a>,
input: &ParseBuffer,
arenas: &'a Arenas,
) -> Result<(), syn::Error> {
input.for_each_separated(Token!(,), |input| {
if input.check_parse(kw::pub_getter)? {
input.parse::<Token!(=)>()?;
let function = arenas.alloc(input.parse::<Ident>()?);
this.override_field_accessor[field] = Some(FieldAccessor::Method {
name: Some(function),
});
} else {
return Err(input.error("invalid #[sabi(refl(..))] attribute"));
}
Ok(())
})
}
/// Parses the contents of #[sabi(missing_field( ... ))]
fn parse_missing_field<'a>(
input: &ParseBuffer,
arenas: &'a Arenas,
) -> Result<OnMissingField<'a>, syn::Error> {
const ATTRIBUTE_MSG: &str = "
Valid Attributes:
`#[sabi(missing_field(panic))]`
This panics if the field doesn't exist.
`#[sabi(missing_field(option))]`
This returns Some(field_value) if the field exists,None if the field doesn't exist.
This is the default.
`#[sabi(missing_field(with=\"somefunction\"))]`
This returns `somefunction()` if the field doesn't exist.
`#[sabi(missing_field(value=\"some_expression\"))]`
This returns `(some_expression)` if the field doesn't exist.
`#[sabi(missing_field(default))]`
This returns `Default::default` if the field doesn't exist.
";
if input.check_parse(kw::option)? {
Ok(OnMissingField::ReturnOption)
} else if input.check_parse(kw::panic)? {
Ok(OnMissingField::Panic)
} else if input.check_parse(kw::default)? {
Ok(OnMissingField::Default_)
} else if input.check_parse(kw::with)? {
input.parse::<Token!(=)>()?;
let function = input.parse::<syn::Path>()?.piped(|i| arenas.alloc(i));
Ok(OnMissingField::With { function })
} else if input.check_parse(kw::value)? {
input.parse::<Token!(=)>()?;
let value = input.parse_expr()?.piped(|i| arenas.alloc(i));
Ok(OnMissingField::Value { value })
} else if input.is_empty() {
Err(syn_err!(
input.span(),
"Error:Expected one attribute inside `missing_field(..)`\n{}",
ATTRIBUTE_MSG
))
} else {
Err(syn_err!(
input.span(),
"Invalid attribute.\n{}",
ATTRIBUTE_MSG,
))
}
}
/// Parses the contents of #[sabi(kind(Prefix( ... )))]
fn parse_prefix_type_list<'a>(
input: &ParseBuffer,
arenas: &'a Arenas,
) -> Result<UncheckedPrefixKind<'a>, syn::Error> {
let mut prefix_ref = None;
let mut prefix_fields = None;
let mut replacing_prefix_ref_docs = Vec::new();
input.for_each_separated(Token!(,), |input| {
if input.check_parse(kw::prefix_ref)? {
input.parse::<Token!(=)>()?;
prefix_ref = Some(arenas.alloc(input.parse::<Ident>()?));
} else if input.check_parse(kw::prefix_ref_docs)? {
input.parse::<Token!(=)>()?;
replacing_prefix_ref_docs.push(input.parse_expr()?);
} else if input.check_parse(kw::prefix_fields)? {
input.parse::<Token!(=)>()?;
prefix_fields = Some(arenas.alloc(input.parse::<Ident>()?));
} else {
return Err(input.error(
"invalid #[sabi(kind(Prefix( )))] attribute, it must be one of:\n\
- prefix_ref = NameOfPrefixPointerType\n\
- prefix_fields = NameOfPrefixFieldsStruct\n\
",
));
}
Ok(())
})?;
Ok(UncheckedPrefixKind {
prefix_ref,
prefix_fields,
replacing_prefix_ref_docs: arenas.alloc(replacing_prefix_ref_docs),
})
}
/// Parses the contents of #[sabi(kind(WithNonExhaustive( ... )))]
fn parse_non_exhaustive_list<'a>(
input: &ParseBuffer,
arenas: &'a Arenas,
) -> Result<UncheckedNonExhaustive<'a>, syn::Error> {
let trait_set_strs = [
"Clone",
"Display",
"Debug",
"Eq",
"PartialEq",
"Ord",
"PartialOrd",
"Hash",
"Deserialize",
"Serialize",
"Send",
"Sync",
"Error",
];
let trait_set = trait_set_strs
.iter()
.map(|e| arenas.alloc(Ident::new(e, Span::call_site())))
.collect::<HashSet<&'a Ident>>();
let trait_err = |trait_ident: &Ident| -> syn::Error {
spanned_err!(
trait_ident,
"Invalid trait in #[sabi(kind(WithNonExhaustive(traits())))].\n\
Valid traits:\n\t{}\
",
trait_set_strs.join("\n\t")
)
};
fn both_err(span: Span) -> syn::Error {
syn_err!(
span,
"Cannot use both `interface=\"...\"` and `traits(...)`"
)
}
let mut this = UncheckedNonExhaustive::default();
let mut errors = LinearResult::ok(());
input.for_each_separated(Token!(,), |input| {
fn parse_expr_or_type<'a>(
input: &ParseBuffer,
arenas: &'a Arenas,
) -> Result<ExprOrType<'a>, syn::Error> {
if input.peek(syn::LitInt) {
Ok(ExprOrType::Int(input.parse_int::<usize>()?))
} else if input.peek(syn::token::Brace) {
let expr = input.parse::<syn::Expr>()?;
Ok(ExprOrType::Expr(arenas.alloc(expr)))
} else {
ret_err_on_peek! {
input,
syn::LitStr,
"either integer literal or type",
"string literal",
}
Ok(ExprOrType::Type(arenas.alloc(input.parse_type()?)))
}
}
if input.check_parse(kw::align)? {
input.parse::<Token!(=)>()?;
this.alignment = Some(parse_expr_or_type(input, arenas)?);
} else if input.check_parse(kw::size)? {
input.parse::<Token!(=)>()?;
this.size = Some(parse_expr_or_type(input, arenas)?);
} else if input.check_parse(kw::assert_nonexhaustive)? {
if input.peek(syn::token::Paren) {
input
.parse_paren_buffer()?
.for_each_separated(Token!(,), |input| {
let ty = arenas.alloc(input.parse_type()?);
this.assert_nonexh.push(ty);
Ok(())
})?;
} else {
input.parse::<Token!(=)>()?;
let ty = arenas.alloc(input.parse_type()?);
this.assert_nonexh.push(ty);
}
} else if let Some(in_token) = input.peek_parse(kw::interface)? {
input.parse::<Token!(=)>()?;
let ty = arenas.alloc(input.parse_type()?);
if this.enum_interface.is_some() {
return Err(both_err(in_token.span));
}
this.enum_interface = Some(EnumInterface::Old(ty));
} else if let Some(traits_token) = input.peek_parse(kw::traits)? {
let enum_interface = match &mut this.enum_interface {
Some(EnumInterface::New(x)) => x,
Some(EnumInterface::Old { .. }) => {
return Err(both_err(traits_token.span));
}
x @ None => {
*x = Some(EnumInterface::New(Default::default()));
match x {
Some(EnumInterface::New(x)) => x,
_ => unreachable!(),
}
}
};
input
.parse_paren_buffer()?
.for_each_separated(Token!(,), |input| {
let ident = input.parse::<Ident>()?;
let is_impld = if input.check_parse(Token!(=))? {
input.parse::<syn::LitBool>()?.value
} else {
true
};
match trait_set.get(&ident) {
Some(&trait_ident) => {
if is_impld {
&mut enum_interface.impld
} else {
&mut enum_interface.unimpld
}
.push(trait_ident);
}
None => errors.push_err(trait_err(&ident)),
}
Ok(())
})?;
} else {
return Err(input.error("invalid #[sabi(kind(WithNonExhaustive(....)))] attribute"));
}
Ok(())
})?;
errors.into_result().map(|_| this)
}
////////////////////////////////////////////////////////////////////////////////
fn where_predicate_from(
ty: syn::Type,
bounds: Punctuated<TypeParamBound, syn::token::Add>,
) -> syn::WherePredicate {
let x = syn::PredicateType {
lifetimes: None,
bounded_ty: ty,
colon_token: Default::default(),
bounds,
};
syn::WherePredicate::Type(x)
}
|
// Copyright 2021 Datafuse Labs.
//
// 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.
use std::fmt::Display;
use std::marker::PhantomData;
use std::ops::Deref;
use std::ops::RangeBounds;
use common_meta_stoerr::MetaStorageError;
use common_meta_types::anyerror::AnyError;
use common_meta_types::Change;
use common_meta_types::SeqV;
use sled::transaction::ConflictableTransactionError;
use sled::transaction::TransactionResult;
use sled::transaction::TransactionalTree;
use sled::IVec;
use tracing::debug;
use tracing::warn;
use crate::sled::transaction::TransactionError;
use crate::store::Store;
use crate::SledBytesError;
use crate::SledKeySpace;
/// Get a ref to the key or to the value.
///
/// It is used as an abstract representation of key/value used in the sled store.
pub trait SledAsRef<K, V> {
fn as_key(&self) -> &K;
fn as_value(&self) -> &V;
}
impl<K, V> SledAsRef<K, V> for (K, V) {
fn as_key(&self) -> &K {
&self.0
}
fn as_value(&self) -> &V {
&self.1
}
}
/// SledTree is a wrapper of sled::Tree that provides access of more than one key-value
/// types.
/// A `SledKVType` defines a key-value type to be stored.
/// The key type `K` must be serializable with order preserved, i.e. impl trait `SledOrderedSerde`.
/// The value type `V` can be any serialize impl, i.e. for most cases, to impl trait `SledSerde`.
#[derive(Debug, Clone)]
pub struct SledTree {
pub name: String,
/// Whether to fsync after an write operation.
/// With sync==false, it WONT fsync even when user tell it to sync.
/// This is only used for testing when fsync is quite slow.
/// E.g. File::sync_all takes 10 ~ 30 ms on a Mac.
/// See: https://github.com/drmingdrmer/sledtest/blob/500929ab0b89afe547143a38fde6fe85d88f1f80/src/ben_sync.rs
sync: bool,
pub tree: sled::Tree,
}
/// A key-value item stored in sled store.
pub struct SledItem<KV: SledKeySpace> {
key: IVec,
value: IVec,
_p: PhantomData<KV>,
}
impl<KV: SledKeySpace> SledItem<KV> {
pub fn new(key: IVec, value: IVec) -> Self {
//
Self {
key,
value,
_p: Default::default(),
}
}
pub fn key(&self) -> Result<KV::K, SledBytesError> {
KV::deserialize_key(&self.key)
}
pub fn value(&self) -> Result<KV::V, SledBytesError> {
KV::deserialize_value(&self.value)
}
pub fn kv(&self) -> Result<(KV::K, KV::V), SledBytesError> {
let k = self.key()?;
let v = self.value()?;
Ok((k, v))
}
}
#[allow(clippy::type_complexity)]
impl SledTree {
/// Open SledTree
pub fn open<N: AsRef<[u8]> + Display>(
db: &sled::Db,
tree_name: N,
sync: bool,
) -> Result<Self, MetaStorageError> {
// During testing, every tree name must be unique.
if cfg!(test) {
let x = tree_name.as_ref();
let x = &x[0..5];
assert_eq!(x, b"test-");
}
let t = db.open_tree(&tree_name)?;
debug!("SledTree opened tree: {}", tree_name);
let rl = SledTree {
name: tree_name.to_string(),
sync,
tree: t,
};
Ok(rl)
}
/// Borrows the SledTree and creates a wrapper with access limited to a specified key space `KV`.
pub fn key_space<KV: SledKeySpace>(&self) -> AsKeySpace<KV> {
AsKeySpace::<KV> {
inner: self,
phantom: PhantomData,
}
}
/// Returns a vec of key-value paris:
pub fn export(&self) -> Result<Vec<Vec<Vec<u8>>>, std::io::Error> {
let it = self.tree.iter();
let mut kvs = Vec::new();
for rkv in it {
let (k, v) = rkv?;
kvs.push(vec![k.to_vec(), v.to_vec()]);
}
Ok(kvs)
}
pub fn txn<T>(
&self,
sync: bool,
f: impl Fn(TransactionSledTree<'_>) -> Result<T, MetaStorageError>,
) -> Result<T, MetaStorageError> {
let sync = sync && self.sync;
let result: TransactionResult<T, MetaStorageError> = self.tree.transaction(move |tree| {
let txn_sled_tree = TransactionSledTree::new(tree);
let r = f(txn_sled_tree);
match r {
Ok(r) => {
if sync {
tree.flush();
}
Ok(r)
}
Err(meta_sto_err) => {
warn!("txn error: {:?}", meta_sto_err);
match &meta_sto_err {
MetaStorageError::BytesError(_e) => {
Err(ConflictableTransactionError::Abort(meta_sto_err))
}
MetaStorageError::SledError(_e) => {
Err(ConflictableTransactionError::Abort(meta_sto_err))
}
MetaStorageError::TransactionConflict => {
Err(ConflictableTransactionError::Conflict)
}
MetaStorageError::SnapshotError(_e) => {
Err(ConflictableTransactionError::Abort(meta_sto_err))
}
}
}
}
});
match result {
Ok(x) => Ok(x),
Err(txn_err) => match txn_err {
TransactionError::Abort(meta_sto_err) => Err(meta_sto_err),
TransactionError::Storage(sto_err) => {
Err(MetaStorageError::SledError(AnyError::new(&sto_err)))
}
},
}
}
/// Retrieve the value of key.
pub(crate) fn get<KV: SledKeySpace>(
&self,
key: &KV::K,
) -> Result<Option<KV::V>, MetaStorageError> {
let got = self.tree.get(KV::serialize_key(key)?)?;
let v = match got {
None => None,
Some(v) => Some(KV::deserialize_value(v)?),
};
Ok(v)
}
/// Delete kvs that are in `range`.
#[tracing::instrument(level = "debug", skip(self, range))]
pub(crate) async fn range_remove<KV, R>(
&self,
range: R,
flush: bool,
) -> Result<(), MetaStorageError>
where
KV: SledKeySpace,
R: RangeBounds<KV::K>,
{
let mut batch = sled::Batch::default();
// Convert K range into sled::IVec range
let sled_range = KV::serialize_range(&range)?;
for item in self.tree.range(sled_range) {
let (k, _) = item?;
batch.remove(k);
}
self.tree.apply_batch(batch)?;
self.flush_async(flush).await?;
Ok(())
}
/// Get key-values in `range`
pub(crate) fn range<KV, R>(
&self,
range: R,
) -> Result<
impl DoubleEndedIterator<Item = Result<SledItem<KV>, MetaStorageError>>,
MetaStorageError,
>
where
KV: SledKeySpace,
R: RangeBounds<KV::K>,
{
// Convert K range into sled::IVec range
let range = KV::serialize_range(&range)?;
let it = self.tree.range(range);
let it = it.map(move |item| {
let (k, v) = item?;
let item = SledItem::new(k, v);
Ok(item)
});
Ok(it)
}
/// Get key-values in with the same prefix
pub(crate) fn scan_prefix<KV>(
&self,
prefix: &KV::K,
) -> Result<Vec<(KV::K, KV::V)>, MetaStorageError>
where
KV: SledKeySpace,
{
let mut res = vec![];
let pref = KV::serialize_key(prefix)?;
for item in self.tree.scan_prefix(pref) {
let (k, v) = item?;
let key = KV::deserialize_key(k)?;
let value = KV::deserialize_value(v)?;
res.push((key, value));
}
Ok(res)
}
/// Append many key-values into SledTree.
pub(crate) async fn append<KV, T>(&self, kvs: &[T]) -> Result<(), MetaStorageError>
where
KV: SledKeySpace,
T: SledAsRef<KV::K, KV::V>,
{
let mut batch = sled::Batch::default();
for t in kvs.iter() {
let key = t.as_key();
let value = t.as_value();
let k = KV::serialize_key(key)?;
let v = KV::serialize_value(value)?;
batch.insert(k, v);
}
self.tree.apply_batch(batch)?;
self.flush_async(true).await?;
Ok(())
}
/// Insert a single kv.
/// Returns the last value if it is set.
pub(crate) async fn insert<KV>(
&self,
key: &KV::K,
value: &KV::V,
) -> Result<Option<KV::V>, MetaStorageError>
where
KV: SledKeySpace,
{
let k = KV::serialize_key(key)?;
let v = KV::serialize_value(value)?;
let prev = self.tree.insert(k, v)?;
let prev = match prev {
None => None,
Some(x) => Some(KV::deserialize_value(x)?),
};
self.flush_async(true).await?;
Ok(prev)
}
/// Build a string describing the range for a range operation.
#[allow(dead_code)]
fn range_message<KV, R>(&self, range: &R) -> String
where
KV: SledKeySpace,
R: RangeBounds<KV::K>,
{
format!(
"{}:{}/[{:?}, {:?}]",
self.name,
KV::NAME,
range.start_bound(),
range.end_bound()
)
}
#[tracing::instrument(level = "debug", skip(self))]
async fn flush_async(&self, flush: bool) -> Result<(), MetaStorageError> {
if flush && self.sync {
self.tree.flush_async().await?;
}
Ok(())
}
}
#[derive(Clone)]
pub struct TransactionSledTree<'a> {
pub txn_tree: &'a TransactionalTree,
/// The changes that are collected during transaction execution.
pub changes: Vec<Change<Vec<u8>, String>>,
}
impl<'a> TransactionSledTree<'a> {
pub fn new(txn_tree: &'a TransactionalTree) -> Self {
Self {
txn_tree,
changes: vec![],
}
}
pub fn key_space<KV: SledKeySpace>(&self) -> TxnKeySpace<KV> {
TxnKeySpace::<KV> {
inner: self,
phantom: PhantomData,
}
}
/// Push a **change** that is applied to `key`.
///
/// It does nothing if `prev == result`
pub fn push_change(&mut self, key: impl ToString, prev: Option<SeqV>, result: Option<SeqV>) {
if prev == result {
return;
}
self.changes
.push(Change::new(prev, result).with_id(key.to_string()))
}
}
/// It borrows the internal SledTree with access limited to a specified namespace `KV`.
pub struct AsKeySpace<'a, KV: SledKeySpace> {
inner: &'a SledTree,
phantom: PhantomData<KV>,
}
pub struct TxnKeySpace<'a, KV: SledKeySpace> {
inner: &'a TransactionSledTree<'a>,
phantom: PhantomData<KV>,
}
impl<'a, KV: SledKeySpace> Store<KV> for TxnKeySpace<'a, KV> {
type Error = MetaStorageError;
fn insert(&self, key: &KV::K, value: &KV::V) -> Result<Option<KV::V>, Self::Error> {
let k = KV::serialize_key(key)?;
let v = KV::serialize_value(value)?;
let prev = self.txn_tree.insert(k, v)?;
match prev {
Some(v) => Ok(Some(KV::deserialize_value(v)?)),
None => Ok(None),
}
}
fn get(&self, key: &KV::K) -> Result<Option<KV::V>, Self::Error> {
let k = KV::serialize_key(key)?;
let got = self.txn_tree.get(k)?;
match got {
Some(v) => Ok(Some(KV::deserialize_value(v)?)),
None => Ok(None),
}
}
fn remove(&self, key: &KV::K) -> Result<Option<KV::V>, Self::Error> {
let k = KV::serialize_key(key)?;
let removed = self.txn_tree.remove(k)?;
match removed {
Some(v) => Ok(Some(KV::deserialize_value(v)?)),
None => Ok(None),
}
}
}
/// Some methods that take `&TransactionSledTree` as parameter need to be called
/// in subTree method, since subTree(aka: AsTxnKeySpace) already ref to `TransactionSledTree`
/// we impl deref here to fetch inner `&TransactionSledTree`.
/// # Example:
///
/// ```
/// fn txn_incr_seq(&self, key: &str, txn_tree: &TransactionSledTree) {}
///
/// fn sub_txn_tree_do_update<'s, KS>(&'s self, sub_tree: &AsTxnKeySpace<'s, KS>) {
/// seq_kv_value.seq = self.txn_incr_seq(KS::NAME, &*sub_tree);
/// sub_tree.insert(key, &seq_kv_value);
/// }
/// ```
impl<'a, KV: SledKeySpace> Deref for TxnKeySpace<'a, KV> {
type Target = &'a TransactionSledTree<'a>;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
#[allow(clippy::type_complexity)]
impl<'a, KV: SledKeySpace> AsKeySpace<'a, KV> {
pub fn get(&self, key: &KV::K) -> Result<Option<KV::V>, MetaStorageError> {
self.inner.get::<KV>(key)
}
pub fn last(&self) -> Result<Option<(KV::K, KV::V)>, MetaStorageError> {
let mut it = self.inner.range::<KV, _>(..)?.rev();
let last = it.next();
let last = match last {
None => return Ok(None),
Some(x) => x,
};
let kv = last?.kv()?;
Ok(Some(kv))
}
pub async fn range_remove<R>(&self, range: R, flush: bool) -> Result<(), MetaStorageError>
where R: RangeBounds<KV::K> {
self.inner.range_remove::<KV, R>(range, flush).await
}
pub fn range<R>(
&self,
range: R,
) -> Result<
impl DoubleEndedIterator<Item = Result<SledItem<KV>, MetaStorageError>>,
MetaStorageError,
>
where
R: RangeBounds<KV::K>,
{
self.inner.range::<KV, R>(range)
}
pub fn scan_prefix(&self, prefix: &KV::K) -> Result<Vec<(KV::K, KV::V)>, MetaStorageError> {
self.inner.scan_prefix::<KV>(prefix)
}
pub fn range_values<R>(&self, range: R) -> Result<Vec<KV::V>, MetaStorageError>
where R: RangeBounds<KV::K> {
let it = self.inner.range::<KV, R>(range)?;
let mut res = vec![];
for r in it {
let item = r?;
let v = item.value()?;
res.push(v);
}
Ok(res)
}
pub async fn append<T>(&self, kvs: &[T]) -> Result<(), MetaStorageError>
where T: SledAsRef<KV::K, KV::V> {
self.inner.append::<KV, _>(kvs).await
}
pub async fn insert(
&self,
key: &KV::K,
value: &KV::V,
) -> Result<Option<KV::V>, MetaStorageError> {
self.inner.insert::<KV>(key, value).await
}
}
|
use crate::palette::{BaseScale, Palette};
use mottle::style::FontStyle;
use mottle::theme::Scope::*;
use mottle::theme::ThemeBuilder;
pub(crate) fn add_rules(builder: &mut ThemeBuilder, palette: &Palette) {
workspace_colors(builder, palette);
syntax_highlighting(builder, palette);
}
fn workspace_colors(builder: &mut ThemeBuilder, palette: &Palette) {
builder.add_workspace_rule("editor.background", palette.base(BaseScale::Bg));
builder.add_workspace_rules(
&["editor.foreground", "foreground"],
palette.base(BaseScale::Fg),
);
builder.add_workspace_rule(
"editor.lineHighlightBackground",
palette.base(BaseScale::LightBg),
);
builder.add_workspace_rule(
"editorLineNumber.foreground",
palette.base(BaseScale::DarkFg),
);
builder.add_workspace_rule(
"editorLineNumber.activeForeground",
palette.base(BaseScale::Fg),
);
builder.add_workspace_rule(
"editorOverviewRuler.border",
palette.base(BaseScale::BrightBg),
);
builder.add_workspace_rule(
"editor.selectionBackground",
palette.base(BaseScale::BrightBg),
);
builder.add_workspace_rule("sideBar.background", palette.base(BaseScale::DarkBg));
builder.add_workspace_rule("sideBar.border", palette.base(BaseScale::DarkestBg));
builder.add_workspace_rule("activityBar.background", palette.base(BaseScale::DarkBg));
builder.add_workspace_rule("activityBar.foreground", palette.base(BaseScale::Fg));
builder.add_workspace_rule("activityBar.border", palette.base(BaseScale::DarkestBg));
builder.add_workspace_rule(
"activityBar.inactiveForeground",
palette.base(BaseScale::DarkFg),
);
builder.add_workspace_rule("tab.activeForeground", palette.base(BaseScale::Fg));
builder.add_workspace_rule("tab.activeBorderTop", palette.ui_blue());
builder.add_workspace_rule("tab.inactiveForeground", palette.base(BaseScale::DarkFg));
builder.add_workspace_rule("tab.inactiveBackground", palette.base(BaseScale::DarkerBg));
builder.add_workspace_rule(
"editorGroupHeader.tabsBackground",
palette.base(BaseScale::DarkerBg),
);
builder.add_workspace_rule(
"editorGroupHeader.noTabsBackground",
palette.base(BaseScale::LightBg),
);
builder.add_workspace_rule("editorGroup.border", palette.base(BaseScale::DarkestBg));
builder.add_workspace_rule("list.focusBackground", palette.ui_blue());
builder.add_workspace_rules(
&[
"list.inactiveFocusBackground",
"list.inactiveSelectionBackground",
],
Palette::TRANSPARENT,
);
builder.add_workspace_rules(
&["list.focusForeground", "list.activeSelectionForeground"],
palette.base(BaseScale::Fg),
);
builder.add_workspace_rule("list.hoverBackground", Palette::TRANSPARENT);
builder.add_workspace_rule("list.focusOutline", Palette::TRANSPARENT);
builder.add_workspace_rule("editorWidget.background", palette.base(BaseScale::DarkBg));
builder.add_workspace_rule("editorWidget.border", palette.base(BaseScale::DarkestBg));
builder.add_workspace_rule("panel.border", palette.base(BaseScale::DarkestBg));
builder.add_workspace_rule("statusBar.background", palette.base(BaseScale::DarkerBg));
builder.add_workspace_rule("statusBar.foreground", palette.base(BaseScale::FadedFg));
builder.add_workspace_rule("statusBar.border", palette.base(BaseScale::DarkestBg));
builder.add_workspace_rule(
"rust_analyzer.inlayHints.foreground",
palette.base(BaseScale::DarkFg),
);
}
fn syntax_highlighting(builder: &mut ThemeBuilder, palette: &Palette) {
builder.add_rules(
&[
Semantic("keyword"),
Textmate("keyword"),
Textmate("storage"),
Textmate("variable.language.this"),
// sizeof() in C
Textmate("keyword.operator.sizeof"),
],
(palette.pink(), FontStyle::Bold),
);
builder.add_rules(
&[
Semantic("variable"),
Semantic("parameter"),
Semantic("function"),
Semantic("method"),
Semantic("property"),
Semantic("enumMember"),
Textmate("variable"),
Textmate("constant"),
Textmate("entity"),
Textmate("support.type.property-name"),
],
palette.teal(),
);
builder.add_rules(
&[
Semantic("type"),
Semantic("class"),
Semantic("struct"),
Semantic("enum"),
Semantic("interface"),
Semantic("union"),
Semantic("typeAlias"),
Semantic("typeParameter"),
Textmate("entity.name.type"),
Textmate("storage.type.java"),
Textmate("storage.type.cs"),
],
palette.light_teal(),
);
builder.add_rules(
&[
Semantic("variable.library"),
Semantic("parameter.library"),
Semantic("function.library"),
Semantic("method.library"),
Semantic("property.library"),
Semantic("enumMember.library"),
],
palette.purple(),
);
builder.add_rules(
&[
Semantic("type.library"),
Semantic("class.library"),
Semantic("struct.library"),
Semantic("enum.library"),
Semantic("interface.library"),
Semantic("union.library"),
Semantic("typeAlias.library"),
Semantic("annotation"),
],
palette.light_purple(),
);
builder.add_rules(
&[
Semantic("variable.defaultLibrary"),
Semantic("parameter.defaultLibrary"),
Semantic("function.defaultLibrary"),
Semantic("method.defaultLibrary"),
Semantic("arithmetic"),
Semantic("bitwise"),
Semantic("logical"),
Semantic("comparison"),
Semantic("operator.controlFlow"), // ?
Semantic("property.defaultLibrary"),
Semantic("enumMember.defaultLibrary"),
Semantic("boolean"),
Textmate("constant.language"),
Textmate("support.function"),
Textmate("keyword.operator.arithmetic"),
Textmate("keyword.operator.increment"),
Textmate("keyword.operator.decrement"),
Textmate("keyword.operator.increment-decrement"),
Textmate("keyword.operator.bitwise"),
Textmate("keyword.operator.logical"),
Textmate("keyword.operator.comparison"),
],
palette.green(),
);
builder.add_rules(
&[
Semantic("type.defaultLibrary"),
Semantic("class.defaultLibrary"),
Semantic("struct.defaultLibrary"),
Semantic("enum.defaultLibrary"),
Semantic("interface.defaultLibrary"),
Semantic("union.defaultLibrary"),
Semantic("typeAlias.defaultLibrary"),
Semantic("builtinType"),
Textmate("keyword.type"),
Textmate("storage.type.primitive"),
Textmate("storage.type.built-in"),
Textmate("entity.name.type.numeric"),
Textmate("entity.name.type.primitive"),
Textmate("storage.type.numeric.go"),
Textmate("storage.type.byte.go"),
Textmate("storage.type.boolean.go"),
Textmate("storage.type.string.go"),
Textmate("storage.type.uintptr.go"),
Textmate("storage.type.error.go"),
Textmate("storage.type.rune.go"),
Textmate("storage.type.annotation"),
],
palette.light_green(),
);
builder.add_rules(
&[
Semantic("variable.declaration"),
Semantic("parameter.declaration"),
Semantic("function.declaration"),
Semantic("method.declaration"),
Semantic("property.declaration"),
Semantic("enumMember.declaration"),
],
palette.blue(),
);
builder.add_rules(
&[
Semantic("type.declaration"),
Semantic("class.declaration"),
Semantic("struct.declaration"),
Semantic("enum.declaration"),
Semantic("interface.declaration"),
Semantic("union.declaration"),
Semantic("typeAlias.declaration"),
Semantic("typeParameter.declaration"),
],
palette.light_blue(),
);
builder.add_rules(
&[
Semantic("number"),
Semantic("character"),
Textmate("constant.numeric"),
],
palette.yellow(),
);
builder.add_rules(
&[
Semantic("string"),
Textmate("string"),
Textmate("punctuation.definition.string"),
],
palette.red(),
);
builder.add_rules(
&[
Semantic("namespace"),
Textmate("entity.name.type.namespace"),
Textmate("storage.modifier.import"),
Textmate("storage.modifier.package"),
],
palette.base(BaseScale::Fg),
);
builder.add_rules(
&[
Semantic("attribute.attribute"),
Semantic("macro.attribute"),
Semantic("generic.attribute"),
],
palette.base(BaseScale::Fg),
);
builder.add_rules(
&[
Semantic("formatSpecifier"),
Semantic("escapeSequence"),
Textmate("constant.character.escape"),
Textmate("punctuation.definition.interpolation"),
Textmate("constant.other.placeholder"),
],
palette.base(BaseScale::Fg),
);
builder.add_rule(Semantic("macro"), palette.orange());
builder.add_rule(Semantic("lifetime"), (palette.orange(), FontStyle::Italic));
builder.add_rules(&[Semantic("comment"), Textmate("comment")], FontStyle::Bold);
builder.add_rules(
&[
Textmate("punctuation"),
Textmate("keyword.operator"),
// closure parameter ‘|’s are highlighted
// as a binary ‘or’ without this
Textmate("keyword.operator.logical.rust"),
Textmate("storage.modifier.pointer"),
Textmate("storage.modifier.array"),
],
palette.base(BaseScale::Fg),
);
builder.add_rule(Semantic("*.mutable"), FontStyle::Underline);
builder.add_rule(
Semantic("unresolvedReference"),
(palette.red(), FontStyle::Underline),
);
builder.add_rule(
Textmate("entity.name.section.markdown"),
(palette.base(BaseScale::Fg), FontStyle::Bold),
);
builder.add_rules(
&[
Textmate("fenced_code.block.language"),
Textmate("punctuation.definition.bold.markdown"),
Textmate("punctuation.definition.constant.markdown"),
Textmate("punctuation.definition.constant.begin.markdown"),
Textmate("punctuation.definition.constant.end.markdown"),
Textmate("punctuation.definition.heading.markdown"),
Textmate("punctuation.definition.italic.markdown"),
Textmate("punctuation.definition.list.begin.markdown"),
Textmate("punctuation.definition.markdown"),
Textmate("punctuation.definition.metadata.markdown"),
Textmate("punctuation.definition.quote.begin.markdown"),
Textmate("punctuation.definition.quote.markdown"),
Textmate("punctuation.definition.raw.markdown"),
Textmate("punctuation.definition.string.begin.markdown"),
Textmate("punctuation.definition.string.end.markdown"),
Textmate("punctuation.separator.key-value.markdown"),
Textmate("markup.heading.setext"),
],
palette.teal(),
);
builder.add_rules(
&[
Textmate("markup.inline.raw.string.markdown"),
Textmate("markup.fenced_code.block.markdown"),
Textmate("markup.raw.block.markdown"),
],
palette.light_purple(),
);
builder.add_rules(
&[
Textmate("string.other.link.title.markdown"),
Textmate("constant.other.reference.link.markdown"),
],
palette.base(BaseScale::Fg),
);
builder.add_rule(Textmate("markup.italic.markdown"), FontStyle::Italic);
builder.add_rule(Textmate("markup.bold.markdown"), FontStyle::Bold);
}
|
pub type IWsbApplicationAsync = *mut ::core::ffi::c_void;
pub type IWsbApplicationBackupSupport = *mut ::core::ffi::c_void;
pub type IWsbApplicationRestoreSupport = *mut ::core::ffi::c_void;
#[doc = "*Required features: `\"Win32_System_ServerBackup\"`*"]
pub const WSBAPP_ASYNC_IN_PROGRESS: ::windows_sys::core::HRESULT = 7995396i32;
#[doc = "*Required features: `\"Win32_System_ServerBackup\"`*"]
pub const WSB_MAX_OB_STATUS_ENTRY: u32 = 5u32;
#[doc = "*Required features: `\"Win32_System_ServerBackup\"`*"]
pub const WSB_MAX_OB_STATUS_VALUE_TYPE_PAIR: u32 = 5u32;
#[doc = "*Required features: `\"Win32_System_ServerBackup\"`*"]
pub type WSB_OB_STATUS_ENTRY_PAIR_TYPE = i32;
#[doc = "*Required features: `\"Win32_System_ServerBackup\"`*"]
pub const WSB_OB_ET_UNDEFINED: WSB_OB_STATUS_ENTRY_PAIR_TYPE = 0i32;
#[doc = "*Required features: `\"Win32_System_ServerBackup\"`*"]
pub const WSB_OB_ET_STRING: WSB_OB_STATUS_ENTRY_PAIR_TYPE = 1i32;
#[doc = "*Required features: `\"Win32_System_ServerBackup\"`*"]
pub const WSB_OB_ET_NUMBER: WSB_OB_STATUS_ENTRY_PAIR_TYPE = 2i32;
#[doc = "*Required features: `\"Win32_System_ServerBackup\"`*"]
pub const WSB_OB_ET_DATETIME: WSB_OB_STATUS_ENTRY_PAIR_TYPE = 3i32;
#[doc = "*Required features: `\"Win32_System_ServerBackup\"`*"]
pub const WSB_OB_ET_TIME: WSB_OB_STATUS_ENTRY_PAIR_TYPE = 4i32;
#[doc = "*Required features: `\"Win32_System_ServerBackup\"`*"]
pub const WSB_OB_ET_SIZE: WSB_OB_STATUS_ENTRY_PAIR_TYPE = 5i32;
#[doc = "*Required features: `\"Win32_System_ServerBackup\"`*"]
pub const WSB_OB_ET_MAX: WSB_OB_STATUS_ENTRY_PAIR_TYPE = 6i32;
#[repr(C)]
#[doc = "*Required features: `\"Win32_System_ServerBackup\"`, `\"Win32_Foundation\"`*"]
#[cfg(feature = "Win32_Foundation")]
pub struct WSB_OB_REGISTRATION_INFO {
pub m_wszResourceDLL: ::windows_sys::core::PWSTR,
pub m_guidSnapinId: ::windows_sys::core::GUID,
pub m_dwProviderName: u32,
pub m_dwProviderIcon: u32,
pub m_bSupportsRemoting: super::super::Foundation::BOOLEAN,
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::marker::Copy for WSB_OB_REGISTRATION_INFO {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for WSB_OB_REGISTRATION_INFO {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[doc = "*Required features: `\"Win32_System_ServerBackup\"`*"]
pub struct WSB_OB_STATUS_ENTRY {
pub m_dwIcon: u32,
pub m_dwStatusEntryName: u32,
pub m_dwStatusEntryValue: u32,
pub m_cValueTypePair: u32,
pub m_rgValueTypePair: *mut WSB_OB_STATUS_ENTRY_VALUE_TYPE_PAIR,
}
impl ::core::marker::Copy for WSB_OB_STATUS_ENTRY {}
impl ::core::clone::Clone for WSB_OB_STATUS_ENTRY {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[doc = "*Required features: `\"Win32_System_ServerBackup\"`*"]
pub struct WSB_OB_STATUS_ENTRY_VALUE_TYPE_PAIR {
pub m_wszObStatusEntryPairValue: ::windows_sys::core::PWSTR,
pub m_ObStatusEntryPairType: WSB_OB_STATUS_ENTRY_PAIR_TYPE,
}
impl ::core::marker::Copy for WSB_OB_STATUS_ENTRY_VALUE_TYPE_PAIR {}
impl ::core::clone::Clone for WSB_OB_STATUS_ENTRY_VALUE_TYPE_PAIR {
fn clone(&self) -> Self {
*self
}
}
#[repr(C)]
#[doc = "*Required features: `\"Win32_System_ServerBackup\"`*"]
pub struct WSB_OB_STATUS_INFO {
pub m_guidSnapinId: ::windows_sys::core::GUID,
pub m_cStatusEntry: u32,
pub m_rgStatusEntry: *mut WSB_OB_STATUS_ENTRY,
}
impl ::core::marker::Copy for WSB_OB_STATUS_INFO {}
impl ::core::clone::Clone for WSB_OB_STATUS_INFO {
fn clone(&self) -> Self {
*self
}
}
|
#[macro_use]
mod common;
use common::util::*;
static UTIL_NAME: &'static str = "cp";
static TEST_HELLO_WORLD_SOURCE: &'static str = "hello_world.txt";
static TEST_HELLO_WORLD_DEST: &'static str = "copy_of_hello_world.txt";
#[test]
fn test_cp_cp() {
let (at, mut ucmd) = testing(UTIL_NAME);
// Invoke our binary to make the copy.
let result = ucmd.arg(TEST_HELLO_WORLD_SOURCE)
.arg(TEST_HELLO_WORLD_DEST)
.run();
// Check that the exit code represents a successful copy.
let exit_success = result.success;
assert_eq!(exit_success, true);
// Check the content of the destination file that was copied.
assert_eq!(at.read(TEST_HELLO_WORLD_DEST), "Hello, World!\n");
}
|
use crate::prelude::*;
use std::os::raw::c_void;
use std::ptr;
#[repr(C)]
#[derive(Debug)]
pub struct VkSemaphoreCreateInfo {
pub sType: VkStructureType,
pub pNext: *const c_void,
pub flags: VkSemaphoreCreateFlagBits,
}
impl VkSemaphoreCreateInfo {
pub fn new<T>(flags: T) -> Self
where
T: Into<VkSemaphoreCreateFlagBits>,
{
VkSemaphoreCreateInfo {
sType: VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
pNext: ptr::null(),
flags: flags.into(),
}
}
}
|
use core::char;
use core::fmt::{self, Write};
use uefi::status;
use uefi::text::TextInputKey;
pub struct Stdout;
impl Write for Stdout {
fn write_str(&mut self, string: &str) -> Result<(), fmt::Error> {
let uefi = unsafe { &mut *::UEFI };
for c in string.chars() {
let _ = (uefi.ConsoleOut.OutputString)(uefi.ConsoleOut, [c as u16, 0].as_ptr());
if c == '\n' {
let _ = (uefi.ConsoleOut.OutputString)(uefi.ConsoleOut, ['\r' as u16, 0].as_ptr());
}
}
Ok(())
}
}
pub fn _print(args: fmt::Arguments) {
Stdout.write_fmt(args).unwrap();
}
pub fn wait_key() -> Result<char, status::Error> {
let uefi = unsafe { &mut *::UEFI };
let mut index = 0;
(uefi.BootServices.WaitForEvent)(1, &uefi.ConsoleIn.WaitForKey, &mut index)?;
let mut input = TextInputKey {
ScanCode: 0,
UnicodeChar: 0
};
(uefi.ConsoleIn.ReadKeyStroke)(uefi.ConsoleIn, &mut input)?;
Ok(unsafe {
char::from_u32_unchecked(input.UnicodeChar as u32)
})
}
|
#[doc = r"Register block"]
#[repr(C)]
pub struct RegisterBlock {
#[doc = "0x00 - Provides support for rebooting the FPGA. You can select which of the four images to reboot to, just be sure to OR the image number with ``0xac``. For example, to reboot to the bootloader (image 0), write ``0xac``` to this register."]
pub ctrl: CTRL,
_reserved1: [u8; 3usize],
#[doc = "0x04 - Bits 24-31 of `REBOOT_ADDR`. This sets the reset vector for the VexRiscv. This address will be used whenever the CPU is reset, for example through a debug bridge. You should update this address whenever you load a new program, to enable the debugger to run ``mon reset``"]
pub addr3: ADDR3,
_reserved2: [u8; 3usize],
#[doc = "0x08 - Bits 16-23 of `REBOOT_ADDR`."]
pub addr2: ADDR2,
_reserved3: [u8; 3usize],
#[doc = "0x0c - Bits 8-15 of `REBOOT_ADDR`."]
pub addr1: ADDR1,
_reserved4: [u8; 3usize],
#[doc = "0x10 - Bits 0-7 of `REBOOT_ADDR`."]
pub addr0: ADDR0,
}
#[doc = "Provides support for rebooting the FPGA. You can select which of the four images to reboot to, just be sure to OR the image number with ``0xac``. For example, to reboot to the bootloader (image 0), write ``0xac``` to this register.\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about avaliable fields see [ctrl](ctrl) module"]
pub type CTRL = crate::Reg<u8, _CTRL>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _CTRL;
#[doc = "`read()` method returns [ctrl::R](ctrl::R) reader structure"]
impl crate::Readable for CTRL {}
#[doc = "`write(|w| ..)` method takes [ctrl::W](ctrl::W) writer structure"]
impl crate::Writable for CTRL {}
#[doc = "Provides support for rebooting the FPGA. You can select which of the four images to reboot to, just be sure to OR the image number with ``0xac``. For example, to reboot to the bootloader (image 0), write ``0xac``` to this register."]
pub mod ctrl;
#[doc = "Bits 24-31 of `REBOOT_ADDR`. This sets the reset vector for the VexRiscv. This address will be used whenever the CPU is reset, for example through a debug bridge. You should update this address whenever you load a new program, to enable the debugger to run ``mon reset``\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about avaliable fields see [addr3](addr3) module"]
pub type ADDR3 = crate::Reg<u8, _ADDR3>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _ADDR3;
#[doc = "`read()` method returns [addr3::R](addr3::R) reader structure"]
impl crate::Readable for ADDR3 {}
#[doc = "`write(|w| ..)` method takes [addr3::W](addr3::W) writer structure"]
impl crate::Writable for ADDR3 {}
#[doc = "Bits 24-31 of `REBOOT_ADDR`. This sets the reset vector for the VexRiscv. This address will be used whenever the CPU is reset, for example through a debug bridge. You should update this address whenever you load a new program, to enable the debugger to run ``mon reset``"]
pub mod addr3;
#[doc = "Bits 16-23 of `REBOOT_ADDR`.\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about avaliable fields see [addr2](addr2) module"]
pub type ADDR2 = crate::Reg<u8, _ADDR2>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _ADDR2;
#[doc = "`read()` method returns [addr2::R](addr2::R) reader structure"]
impl crate::Readable for ADDR2 {}
#[doc = "`write(|w| ..)` method takes [addr2::W](addr2::W) writer structure"]
impl crate::Writable for ADDR2 {}
#[doc = "Bits 16-23 of `REBOOT_ADDR`."]
pub mod addr2;
#[doc = "Bits 8-15 of `REBOOT_ADDR`.\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about avaliable fields see [addr1](addr1) module"]
pub type ADDR1 = crate::Reg<u8, _ADDR1>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _ADDR1;
#[doc = "`read()` method returns [addr1::R](addr1::R) reader structure"]
impl crate::Readable for ADDR1 {}
#[doc = "`write(|w| ..)` method takes [addr1::W](addr1::W) writer structure"]
impl crate::Writable for ADDR1 {}
#[doc = "Bits 8-15 of `REBOOT_ADDR`."]
pub mod addr1;
#[doc = "Bits 0-7 of `REBOOT_ADDR`.\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about avaliable fields see [addr0](addr0) module"]
pub type ADDR0 = crate::Reg<u8, _ADDR0>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _ADDR0;
#[doc = "`read()` method returns [addr0::R](addr0::R) reader structure"]
impl crate::Readable for ADDR0 {}
#[doc = "`write(|w| ..)` method takes [addr0::W](addr0::W) writer structure"]
impl crate::Writable for ADDR0 {}
#[doc = "Bits 0-7 of `REBOOT_ADDR`."]
pub mod addr0;
|
use super::*;
use std::io::Cursor;
fn test(data: &str, expected_frame_counts: &[usize]) {
let mut frame_counts = vec![];
let cursor = Cursor::new(data.as_bytes());
each_trace(cursor, |frames| {
frame_counts.push(frames.len());
});
assert_eq!(expected_frame_counts, &frame_counts[..]);
}
#[test]
fn test_run_1() {
let data = r"
# ========
# captured on: Thu Jun 4 05:50:02 2015
# hostname : lunch-box
# os release : 3.13.0-52-generic
# perf version : 3.13.11-ckt18
# arch : x86_64
# nrcpus online : 16
# nrcpus avail : 16
# cpudesc : Intel(R) Xeon(R) CPU E5-2680 0 @ 2.70GHz
# cpuid : GenuineIntel,6,45,7
# total memory : 16355712 kB
# cmdline : /usr/lib/linux-tools-3.13.0-52/perf record -F 99 -g ./mach build -v -p script
# event : name = cycles, type = 0, config = 0x0, config1 = 0x0, config2 = 0x0, excl_usr = 0, excl_kern = 0, excl_host = 0, excl_guest = 1, precise_ip = 0, attr_mmap2 = 0, attr_mmap = 1, attr_mmap_data = 0
# HEADER_CPU_TOPOLOGY info available, use -I to display
# HEADER_NUMA_TOPOLOGY info available, use -I to display
# pmu mappings: cpu = 4, software = 1, uncore_pcu = 15, tracepoint = 2, uncore_imc_0 = 17, uncore_imc_1 = 18, uncore_imc_2 = 19, uncore_imc_3 = 20, uncore_qpi_0 = 21, uncore_qpi_1 = 22, uncore_cbox_0 = 7, uncore_cbox_1 = 8, uncore_cbox_2 = 9, uncore_cbox_3 = 10, uncore_cbox_4 = 11, uncore_cbox_5 = 12, uncore_cbox_6 = 13, uncore_cbox_7 = 14, uncore_ha = 16, uncore_r2pcie = 23, uncore_r3qpi_0 = 24, uncore_r3qpi_1 = 25, breakpoint = 5, uncore_ubox = 6
# ========
#
:18830 18830 2552105.017823: cycles:
ffffffff8104f45a [unknown] ([kernel.kallsyms])
ffffffff8102f9ac [unknown] ([kernel.kallsyms])
ffffffff81029c04 [unknown] ([kernel.kallsyms])
ffffffff81142de7 [unknown] ([kernel.kallsyms])
ffffffff81143f70 [unknown] ([kernel.kallsyms])
ffffffff81146360 [unknown] ([kernel.kallsyms])
ffffffff811c527f [unknown] ([kernel.kallsyms])
ffffffff811c5c91 [unknown] ([kernel.kallsyms])
ffffffff812156b8 [unknown] ([kernel.kallsyms])
ffffffff811c43cf [unknown] ([kernel.kallsyms])
ffffffff812139c5 [unknown] ([kernel.kallsyms])
ffffffff811c43cf [unknown] ([kernel.kallsyms])
ffffffff811c5947 [unknown] ([kernel.kallsyms])
ffffffff811c5e16 [unknown] ([kernel.kallsyms])
ffffffff817336a9 [unknown] ([kernel.kallsyms])
7f10408df337 [unknown] ([unknown])
:18830 18830 2552105.017830: cycles:
ffffffff8104f45a [unknown] ([kernel.kallsyms])
ffffffff8102f9ac [unknown] ([kernel.kallsyms])
ffffffff81029c04 [unknown] ([kernel.kallsyms])
ffffffff81142de7 [unknown] ([kernel.kallsyms])
ffffffff81143f70 [unknown] ([kernel.kallsyms])
ffffffff81146360 [unknown] ([kernel.kallsyms])
ffffffff811c527f [unknown] ([kernel.kallsyms])
ffffffff811c5c91 [unknown] ([kernel.kallsyms])
ffffffff812156b8 [unknown] ([kernel.kallsyms])
ffffffff811c43cf [unknown] ([kernel.kallsyms])
ffffffff812139c5 [unknown] ([kernel.kallsyms])
ffffffff811c43cf [unknown] ([kernel.kallsyms])
ffffffff811c5947 [unknown] ([kernel.kallsyms])
ffffffff811c5e16 [unknown] ([kernel.kallsyms])
ffffffff817336a9 [unknown] ([kernel.kallsyms])
7f10408df337 [unknown] ([unknown])";
test(data, &[16, 16]);
}
|
use time::{format_description::FormatItem, macros::format_description, Date};
use crate::{InputValueError, InputValueResult, Scalar, ScalarType, Value};
const DATE_FORMAT: &[FormatItem<'_>] = format_description!("[year]-[month]-[day]");
/// ISO 8601 calendar date without timezone.
/// Format: %Y-%m-%d
///
/// # Examples
///
/// * `1994-11-13`
/// * `2000-02-24`
#[Scalar(internal, name = "Date")]
impl ScalarType for Date {
fn parse(value: Value) -> InputValueResult<Self> {
match &value {
Value::String(s) => Ok(Self::parse(s, &DATE_FORMAT)?),
_ => Err(InputValueError::expected_type(value)),
}
}
fn to_value(&self) -> Value {
Value::String(
self.format(&DATE_FORMAT)
.unwrap_or_else(|e| panic!("Failed to format `Date`: {}", e)),
)
}
}
#[cfg(test)]
mod tests {
use time::{macros::date, Date};
use crate::{ScalarType, Value};
#[test]
fn test_date_to_value() {
let cases = [
(date!(1994 - 11 - 13), "1994-11-13"),
(date!(2000 - 01 - 24), "2000-01-24"),
];
for (value, expected) in cases {
let value = value.to_value();
if let Value::String(s) = value {
assert_eq!(s, expected);
} else {
panic!(
"Unexpected Value type when formatting PrimitiveDateTime: {:?}",
value
);
}
}
}
#[test]
fn test_date_parse() {
let cases = [
("1994-11-13", date!(1994 - 11 - 13)),
("2000-01-24", date!(2000 - 01 - 24)),
];
for (value, expected) in cases {
let value = Value::String(value.to_string());
let parsed = <Date as ScalarType>::parse(value).unwrap();
assert_eq!(parsed, expected);
}
}
}
|
pub mod general_category;
pub mod script_values;
/// This is an ordered combination
/// of the General Category and
/// Binary Properties for checking
/// the lone unicode class escape
pub static GC_AND_BP: &[&str] = &[
"AHex",
"ASCII",
"ASCII_Hex_Digit",
"Alpha",
"Alphabetic",
"Any",
"Assigned",
"Bidi_C",
"Bidi_Control",
"Bidi_M",
"Bidi_Mirrored",
"C",
"CI",
"CWCF",
"CWCM",
"CWKCF",
"CWL",
"CWT",
"CWU",
"Case_Ignorable",
"CasedCased",
"Cased_Letter",
"Cc",
"Cf",
"Changes_When_Casefolded",
"Changes_When_Casemapped",
"Changes_When_Lowercased",
"Changes_When_NFKC_Casefolded",
"Changes_When_Titlecased",
"Changes_When_Uppercased",
"Close_Punctuation",
"Cn",
"Co",
"Combining_Mark",
"Connector_Punctuation",
"Control",
"Cs",
"Currency_Symbol",
"DI",
"Dash",
"Dash_Punctuation",
"Decimal_Number",
"Default_Ignorable_Code_Point",
"Dep",
"Deprecated",
"Dia",
"Diacritic",
"Emoji",
"Emoji_Component",
"Emoji_Modifier",
"Emoji_Modifier_Base",
"Emoji_Presentation",
"Enclosing_Mark",
"Ext",
"Extended_Pictographic",
"Extender",
"Final_Punctuation",
"Format",
"Gr_Base",
"Gr_Ext",
"Grapheme_Base",
"Grapheme_Extend",
"Hex",
"Hex_Digit",
"IDC",
"IDS",
"IDSB",
"IDST",
"IDS_Binary_Operator",
"IDS_Trinary_Operator",
"ID_Continue",
"ID_Start",
"Ideo",
"Ideographic",
"Initial_Punctuation",
"Join_C",
"Join_Control",
"L",
"LC",
"LOE",
"Letter",
"Letter_Number",
"Line_Separator",
"Ll",
"Lm",
"Lo",
"Logical_Order_Exception",
"Lower",
"Lowercase",
"Lowercase_Letter",
"Lt",
"Lu",
"M",
"Mark",
"Math",
"Math_Symbol",
"Mc",
"Me",
"Mn",
"Modifier_Letter",
"Modifier_Symbol",
"N",
"NChar",
"Nd",
"Nl",
"No",
"Noncharacter_Code_Point",
"Nonspacing_Mark",
"Number",
"Open_Punctuation",
"Other",
"Other_Letter",
"Other_Number",
"Other_Punctuation",
"Other_Symbol",
"P",
"Paragraph_Separator",
"Pat_Syn",
"Pat_WS",
"Pattern_Syntax",
"Pattern_White_Space",
"Pc",
"Pd",
"Pe",
"Pf",
"Pi",
"Po",
"Private_Use",
"Ps",
"Punctuation",
"QMark",
"Quotation_Mark",
"RI",
"Radical",
"Regional_Indicator",
"S",
"SD",
"STerm",
"Sc",
"Sentence_Terminal",
"Separator",
"Sk",
"Sm",
"So",
"Soft_Dotted",
"Space_Separator",
"Spacing_Mark",
"Surrogate",
"Symbol",
"Term",
"Terminal_Punctuation",
"Titlecase_Letter",
"UIdeo",
"Unassigned",
"Unified_Ideograph",
"Upper",
"Uppercase",
"Uppercase_Letter",
"VS",
"Variation_Selector",
"White_Space",
"XIDC",
"XIDS",
"XID_Continue",
"XID_Start",
"Z",
"Zl",
"Zp",
"Zs",
"cntrl",
"digit",
"punct",
"space",
];
|
/*
Project Euler Problem 3:
The prime factors of 13195 are 5, 7, 13 and 29.
What is the largest prime factor of the number 600851475143 ?
*/
fn is_prime(x: i64) -> bool {
if x == 2 || x == 3 {
return true;
} else if x % 2 == 0 || x % 3 == 0 {
return false;
}
let (mut i, mut w) = (5i64, 2i64);
while i * i <= x {
if x % i == 0 {
return false;
}
i += w;
w = 6 - w;
}
return true;
}
fn main() {
let x: i64 = 600851475143;
for i in (0..((x as f64).sqrt() as i64)).rev() {
if x % i == 0 && is_prime(i) {
println!("{:?}", i);
return;
}
}
} |
#[link(wasm_import_module = "wapc")]
extern {
fn __console_log(ptr: *const u8, len: usize);
fn __guest_request(op_ptr: *mut u8, ptr: *mut u8);
fn __guest_response(ptr: *const u8, len: usize);
}
#[no_mangle]
extern fn __guest_call(op_len: i32, msg_len: i32) -> i32 {
let mut op_buf = vec![0; op_len as _];
let mut msg_buf = vec![0; msg_len as _];
unsafe {
__guest_request(op_buf.as_mut_ptr(), msg_buf.as_mut_ptr());
}
let op = String::from_utf8(op_buf).unwrap_or(String::default());
let payload = String::from_utf8(msg_buf).unwrap_or(String::default());
let log_msg = format!("called operation={}, payload={}", op, payload);
unsafe {
__console_log(log_msg.as_ptr(), log_msg.len());
}
let res = format!("response-{}-{}", op, payload);
unsafe {
__guest_response(res.as_ptr(), res.len());
}
1
}
|
pub mod camera;
pub mod color;
pub mod consts;
pub mod outputbuffer;
pub mod ray;
pub mod rng;
pub mod vector;
|
#[macro_use]
extern crate slog;
extern crate slog_json;
extern crate slog_term;
extern crate time;
use std::fs::File;
use slog::Drain;
#[allow(dead_code)]
struct User {
username: String,
logger: slog::Logger,
}
type Waldo = String;
type DatabaseError = String;
impl User {
fn new(username: &str, logger: &slog::Logger) -> Self {
User {
username: username.to_string(),
logger: logger.new(o!("username" => username.to_string())),
}
}
fn sign_in(&self) {
info!(self.logger, "User signed in");
}
fn find_waldo(&self) -> Option<Waldo> {
match read_database(&self.username) {
Ok(waldo) => {
info!(self.logger, "Found Waldo");
Some(waldo)
}
Err(error) => {
error!(self.logger, "Failed to find Waldo"; "error" => error);
None
}
}
}
}
fn read_database(username: &str) -> Result<String, DatabaseError> {
Err(format!("{}: Not this time", username))
}
fn main() {
println!("24 Days of Rust vol. 2 - slog");
let decorator = slog_term::PlainSyncDecorator::new(std::io::stderr());
let drain = slog_term::FullFormat::new(decorator).build().fuse();
let root_logger = slog::Logger::root(drain, o!("version" => "0.5"));
info!(root_logger, "Application started";
"started_at" => format!("{}", time::now().rfc3339()));
let user = User::new("zbyszek", &root_logger);
user.sign_in();
let _ = user.find_waldo();
let console_drain = slog_term::FullFormat::new(
slog_term::PlainSyncDecorator::new(std::io::stdout()),
).build()
.fuse();
let file = File::create("app.log").expect("Couldn't open log file");
let file_drain = slog_term::FullFormat::new(slog_term::PlainSyncDecorator::new(file))
.build()
.fuse();
let logger = slog::Logger::root(slog::Duplicate::new(console_drain, file_drain).fuse(), o!());
warn!(logger, "not_enough_resources"; "resource" => "cat pictures");
}
|
//! WeakAddr example
//!
//! With a weak address you can register an client actor's addrs with a
//! service and still get cleaned up correctly when the client actor is
//! stopped. Alternatively you'd have to check if the client's mailbox
//! is still open.
use std::time::{Duration, Instant};
use actix::{prelude::*, Actor, Context, WeakAddr};
#[derive(Message, Debug)]
#[rtype(result = "()")]
pub struct TimePing(Instant);
#[derive(Message, Debug)]
#[rtype(result = "()")]
pub struct RegisterForTime(pub WeakAddr<Client>);
#[derive(Debug, Default)]
pub struct TimeService {
clients: Vec<WeakAddr<Client>>,
}
impl TimeService {
fn send_tick(&mut self, _ctx: &mut Context<Self>) {
for client in self.clients.iter() {
if let Some(client) = client.upgrade() {
client.do_send(TimePing(Instant::now()));
println!("⏰ sent ping to client {:?}", client);
} else {
println!("⏰ client can no longer be upgraded");
}
}
// gc
self.clients = self
.clients
.drain(..)
.filter(|c| c.upgrade().is_some())
.collect();
println!("⏰ service has {} clients", self.clients.len());
}
}
impl Actor for TimeService {
type Context = Context<Self>;
fn started(&mut self, ctx: &mut Self::Context) {
println!("⏰ starting TimeService");
ctx.run_interval(Duration::from_millis(1_000), Self::send_tick);
}
fn stopping(&mut self, _ctx: &mut Self::Context) -> Running {
println!("⏰ stopping TimeService");
Running::Stop
}
fn stopped(&mut self, _ctx: &mut Self::Context) {
println!("⏰ stopped TimeService");
}
}
impl Handler<RegisterForTime> for TimeService {
type Result = ();
fn handle(
&mut self,
RegisterForTime(client): RegisterForTime,
_ctx: &mut Self::Context,
) -> Self::Result {
println!("⏰ received registration");
self.clients.push(client);
}
}
impl Supervised for TimeService {}
impl SystemService for TimeService {}
#[derive(Debug, Default)]
pub struct Client;
impl Actor for Client {
type Context = Context<Self>;
fn started(&mut self, ctx: &mut Self::Context) {
println!("🐰 starting Client");
TimeService::from_registry()
.send(RegisterForTime(ctx.address().downgrade()))
.into_actor(self)
.then(|_, _slf, _| fut::ready(()))
.spawn(ctx);
}
fn stopping(&mut self, _ctx: &mut Self::Context) -> Running {
println!("🐰 stopping Client");
Running::Stop
}
fn stopped(&mut self, _ctx: &mut Self::Context) {
println!("🐰 stopped Client");
}
}
impl Handler<TimePing> for Client {
type Result = ();
fn handle(&mut self, msg: TimePing, _ctx: &mut Self::Context) -> Self::Result {
println!("🐰 client received ping: {:?}", msg);
}
}
#[actix::main]
async fn main() {
{
println!("🎩 creating client client");
let _client = Client.start();
println!("🎩 press Ctrl-C to stop client");
tokio::signal::ctrl_c().await.unwrap();
println!("🎩 Ctrl-C received, stopping client");
}
tokio::signal::ctrl_c().await.unwrap();
println!("🎩 Ctrl-C received, shutting down");
System::current().stop();
}
|
#[macro_use]
extern crate clap;
extern crate simple_logger;
extern crate toml;
#[macro_use]
extern crate log;
#[macro_use]
extern crate lazy_static;
#[macro_use]
extern crate failure_derive;
extern crate failure;
extern crate actix_web;
//extern crate futures;
#[macro_use]
mod priv_macro;
pub mod cfg;
mod cli;
mod exit;
mod logging;
mod srv;
// Daemon Entry
pub mod daemon;
// Client Entry
pub mod client;
|
use std::cmp;
use std::collections::HashSet;
#[allow(dead_code)]
fn length_of_longest_substring(s: String) -> i32 {
let mut char_next_indices = [0usize; 256]; // 256 ASCII chars
let mut i = 0usize;
let mut result = 0usize;
for (j, letter) in s.char_indices() {
i = cmp::max(i, char_next_indices[letter as usize]);
char_next_indices[letter as usize] = j + 1;
result = cmp::max(result, j - i + 1);
}
result as i32
}
#[allow(dead_code)]
fn length_of_longest_substring_naive(s: String) -> i32 {
let mut result = 0usize;
for i in 0..s.len() {
let longest_window = (i..s.len())
.map(|j| &s[i..j + 1])
.take_while(|&w| is_unique(w))
.last();
if let Some(window) = longest_window {
result = cmp::max(result, window.len())
}
}
result as i32
}
fn is_unique(string: &str) -> bool {
let mut seen = HashSet::new();
string.chars().all(|c| seen.insert(c))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_length_of_longest_substring_naive() {
apply_tests(length_of_longest_substring_naive);
}
#[test]
fn test_is_unique() {
assert_eq!(is_unique(" "), true);
assert_eq!(is_unique("ada"), false);
}
#[test]
fn test_length_of_longest_substring() {
apply_tests(length_of_longest_substring);
}
fn apply_tests<F: Fn(String) -> i32>(fun: F) {
assert_eq!(fun("abcabcbb".to_string()), 3);
assert_eq!(fun("bbbbb".to_string()), 1);
assert_eq!(fun("pwwkew".to_string()), 3);
assert_eq!(fun(" ".to_string()), 1);
}
}
|
#![cfg_attr(not(feature = "std"), no_std)]
pub use self::debtpool::SDP;
use ink_lang as ink;
#[ink::contract]
mod debtpool {
#[cfg(not(feature = "ink-as-dependency"))]
use ink_storage::{
collections::HashMap as StorageHashMap,
Lazy,
};
#[cfg(not(feature = "ink-as-dependency"))]
use ink_env::call::FromAccountId;
use aggregator::ExchangePrices;
use whitelist::Whitelist;
#[ink(storage)]
pub struct SDP {
/// Mapping from asset to amount of asset that is in debt pool.
asset_amounts: StorageHashMap<AccountId, Balance>,
/// Mapping from user and asset to amount of asset that is in debt pool.
user_asset_amounts: StorageHashMap<(AccountId, AccountId), Balance>,
/// Mapping from user to debt ratio.
user_debt_ratios: StorageHashMap<AccountId, u128>,
exchange_prices: Lazy<ExchangePrices>,
asset_whitelist: Lazy<Whitelist>,
owner: AccountId,
operator: AccountId,
}
impl SDP {
#[ink(constructor)]
pub fn new(aggregator_account: AccountId, whitelist_account: AccountId) -> Self {
let exchange_prices: ExchangePrices = FromAccountId::from_account_id(aggregator_account);
let asset_whitelist: Whitelist = FromAccountId::from_account_id(whitelist_account);
Self {
asset_amounts: StorageHashMap::new(),
user_asset_amounts: StorageHashMap::new(),
user_debt_ratios: StorageHashMap::new(),
exchange_prices: Lazy::new(exchange_prices),
asset_whitelist: Lazy::new(asset_whitelist),
owner: Self::env().caller(),
operator: Self::env().caller(),
}
}
#[ink(message)]
pub fn get_asset_amount(&self, asset: AccountId) -> Balance {
assert!(self.asset_whitelist.is_effective_synthetic_asset(asset));
self.asset_amounts.get(&asset).copied().unwrap_or(0)
}
#[ink(message)]
pub fn get_asset_value(&self, asset: AccountId) -> u128 {
let amount = self.get_asset_amount(asset);
self.calc_asset_value(asset, amount)
}
/// Returns the total value of assets.
#[ink(message)]
pub fn get_asset_total_value(&self) -> u128 {
let mut total: u128 = 0;
for (asset, amount) in self.asset_amounts.iter() {
total += self.calc_asset_value(*asset, *amount);
}
total
}
#[ink(message)]
pub fn get_user_asset_amount(&self, user: AccountId, asset: AccountId) -> Balance {
assert_ne!(user, Default::default());
assert!(self.asset_whitelist.is_effective_synthetic_asset(asset));
if user != self.env().caller() {
self.is_owner();
}
self.user_asset_amounts.get(&(user, asset)).copied().unwrap_or(0)
}
#[ink(message)]
pub fn get_user_asset_total_value(&self, user: AccountId) -> u128 {
assert_ne!(user, Default::default());
if user != self.env().caller() {
self.is_owner();
}
let mut total: u128 = 0;
for (asset, _) in self.asset_amounts.iter() {
let amount = self.user_asset_amounts.get(&(user, *asset)).copied().unwrap_or(0);
if amount != 0 {
total += self.calc_asset_value(*asset, amount);
}
}
total
}
fn calc_asset_value(&self, asset: AccountId, amount: Balance) -> u128 {
self.exchange_prices.get_price(asset) * amount
}
#[ink(message)]
pub fn get_user_profit(&self, user: AccountId) -> i128 {
assert_eq!(user, self.env().caller());
self.get_user_asset_total_value(user) as i128 -
(self.get_asset_total_value() * self.get_user_debt_ratio(user)) as i128 / 10000
}
/// Returns the debt ratio for the specified `user`.
///
/// Returns `0` if the user is non-existent.
#[ink(message)]
pub fn get_user_debt_ratio(&self, user: AccountId) -> u128 {
assert_ne!(user, Default::default());
if user != self.env().caller() {
self.is_owner();
}
self.user_debt_ratios.get(&user).copied().unwrap_or(0)
}
#[ink(message)]
pub fn join(&mut self, user: AccountId, collateral_asset: AccountId, collateral_amount:Balance,
synthetic_asset: AccountId, synthetic_amount: Balance) {
self.is_operator();
assert_ne!(user, Default::default());
assert!(self.asset_whitelist.is_effective_collateral_asset(collateral_asset));
assert!(self.asset_whitelist.is_effective_synthetic_asset(synthetic_asset));
assert!(collateral_amount > 0);
assert!(synthetic_amount > 0);
let leverage_ratio = (self.exchange_prices.get_price(synthetic_asset) * synthetic_amount)
/ (self.exchange_prices.get_price(collateral_asset) * collateral_amount);
let (min, max) = self.asset_whitelist.get_leverage_ratio();
assert!(leverage_ratio >= min.into());
assert!(leverage_ratio <= max.into());
if self.asset_amounts.is_empty() {
self.asset_amounts.insert(synthetic_asset, synthetic_amount);
self.user_asset_amounts.insert((user, synthetic_asset), synthetic_amount);
self.user_debt_ratios.insert(user, 10000);
} else {
let old_amount = self.asset_amounts.get(&synthetic_asset).copied().unwrap_or(0);
self.asset_amounts.insert(synthetic_asset, old_amount + synthetic_amount);
let old_amount = self.user_asset_amounts.get(&(user, synthetic_asset)).copied().unwrap_or(0);
self.user_asset_amounts.insert((user, synthetic_asset), old_amount + synthetic_amount);
let old_total_value = self.get_asset_total_value();
let join_asset_value = self.calc_asset_value(synthetic_asset, synthetic_amount);
let new_total_value = old_total_value + join_asset_value;
self.calc_debt_ratio(old_total_value, new_total_value);
self.user_debt_ratios.insert(user, (join_asset_value * 10000) / new_total_value);
}
}
#[ink(message)]
pub fn swap_in_sdp(&mut self, user: AccountId, old_asset: AccountId, new_asset: AccountId,
swap_amount: Balance) {
assert_ne!(user, Default::default());
assert!(self.asset_whitelist.is_effective_synthetic_asset(old_asset));
assert!(self.asset_whitelist.is_effective_synthetic_asset(new_asset));
assert!(swap_amount > 0);
let old_amount = self.asset_amounts.get(&old_asset).copied().unwrap_or(0);
assert!(old_amount >= swap_amount);
self.asset_amounts.insert(old_asset, old_amount - swap_amount);
let new_swap_amount = (self.exchange_prices.get_price(old_asset) * swap_amount)
/ self.exchange_prices.get_price(new_asset);
let new_amount = self.asset_amounts.get(&new_asset).copied().unwrap_or(0);
self.asset_amounts.insert(new_asset, new_amount + new_swap_amount);
let old_amount = self.user_asset_amounts.get(&(user, old_asset)).copied().unwrap_or(0);
assert!(old_amount >= swap_amount);
self.user_asset_amounts.insert((user, old_asset), old_amount - swap_amount);
let new_amount = self.user_asset_amounts.get(&(user, new_asset)).copied().unwrap_or(0);
self.user_asset_amounts.insert((user, new_asset), new_amount + new_swap_amount);
}
#[ink(message)]
pub fn swap_not_in_sdp(&mut self, old_asset: AccountId, new_asset: AccountId,
swap_amount: Balance) {
assert!(self.asset_whitelist.is_effective_synthetic_asset(old_asset));
assert!(self.asset_whitelist.is_effective_synthetic_asset(new_asset));
assert!(swap_amount > 0);
let old_amount = self.asset_amounts.get(&old_asset).copied().unwrap_or(0);
assert!(old_amount >= swap_amount);
self.asset_amounts.insert(old_asset, old_amount - swap_amount);
let new_swap_amount = (self.exchange_prices.get_price(old_asset) * swap_amount)
/ self.exchange_prices.get_price(new_asset);
let new_amount = self.asset_amounts.get(&new_asset).copied().unwrap_or(0);
self.asset_amounts.insert(new_asset, new_amount + new_swap_amount);
}
pub fn withdraw(&mut self, asset: AccountId, amount: Balance) {
assert!(self.asset_whitelist.is_effective_synthetic_asset(asset));
assert!(amount > 0);
let old_total_value = self.get_asset_total_value();
// self.asset_amounts
// .entry(asset)
// .and_modify(|old_amounte| *old_amount -= amount)
// .or_insert(by);
// TODO: Remove assets amount
// TODO: Remove debt ratio
let new_total_value = self.get_asset_total_value();
self.calc_debt_ratio(old_total_value, new_total_value);
}
/// Calculate the debt ratio.
fn calc_debt_ratio(&mut self, old_total_value: u128, new_total_value: u128) {
if new_total_value == 0 { return; }
for (_, debt_ratio) in self.user_debt_ratios.iter_mut() {
*debt_ratio = (old_total_value * (*debt_ratio)) / new_total_value;
}
}
#[ink(message)]
pub fn transfer_ownership(&mut self, new_owner: AccountId) {
self.is_owner();
assert_ne!(new_owner, Default::default());
self.owner = new_owner;
}
fn is_owner(&self) {
assert_eq!(self.owner, self.env().caller());
}
#[ink(message)]
pub fn transfer_operator(&mut self, new_operator: AccountId) {
self.is_owner();
assert_ne!(new_operator, Default::default());
self.operator = new_operator;
}
fn is_operator(&self) {
assert_eq!(self.operator, self.env().caller());
}
}
} |
use libc;
use libc::toupper;
use crate::clist::*;
use crate::mailimf::*;
use crate::mailimf_types::*;
use crate::mailmime_decode::*;
use crate::mailmime_disposition::*;
use crate::mailmime_types::*;
use crate::x::*;
pub const MAILMIME_COMPOSITE_TYPE_EXTENSION: libc::c_uint = 3;
pub const MAILMIME_COMPOSITE_TYPE_MULTIPART: libc::c_uint = 2;
pub const MAILMIME_COMPOSITE_TYPE_MESSAGE: libc::c_uint = 1;
pub const MAILMIME_COMPOSITE_TYPE_ERROR: libc::c_uint = 0;
pub const MAILMIME_TYPE_COMPOSITE_TYPE: libc::c_uint = 2;
pub const MAILMIME_TYPE_DISCRETE_TYPE: libc::c_uint = 1;
pub const MAILMIME_TYPE_ERROR: libc::c_uint = 0;
pub const FIELD_STATE_L: libc::c_uint = 3;
pub const FIELD_STATE_D: libc::c_uint = 2;
pub const FIELD_STATE_T: libc::c_uint = 1;
pub const FIELD_STATE_START: libc::c_uint = 0;
pub const MAILMIME_DISCRETE_TYPE_EXTENSION: libc::c_uint = 6;
pub const MAILMIME_DISCRETE_TYPE_APPLICATION: libc::c_uint = 5;
pub const MAILMIME_DISCRETE_TYPE_VIDEO: libc::c_uint = 4;
pub const MAILMIME_DISCRETE_TYPE_AUDIO: libc::c_uint = 3;
pub const MAILMIME_DISCRETE_TYPE_IMAGE: libc::c_uint = 2;
pub const MAILMIME_DISCRETE_TYPE_TEXT: libc::c_uint = 1;
pub const MAILMIME_DISCRETE_TYPE_ERROR: libc::c_uint = 0;
pub unsafe fn mailmime_content_parse(
mut message: *const libc::c_char,
mut length: size_t,
mut indx: *mut size_t,
mut result: *mut *mut mailmime_content,
) -> libc::c_int {
let mut current_block: u64;
let mut cur_token: size_t = 0;
let mut type_0: *mut mailmime_type = 0 as *mut mailmime_type;
let mut subtype: *mut libc::c_char = 0 as *mut libc::c_char;
let mut parameters_list: *mut clist = 0 as *mut clist;
let mut content: *mut mailmime_content = 0 as *mut mailmime_content;
let mut r: libc::c_int = 0;
let mut res: libc::c_int = 0;
cur_token = *indx;
mailimf_cfws_parse(message, length, &mut cur_token);
type_0 = 0 as *mut mailmime_type;
r = mailmime_type_parse(message, length, &mut cur_token, &mut type_0);
if r != MAILIMF_NO_ERROR as libc::c_int {
res = r
} else {
r = mailimf_unstrict_char_parse(
message,
length,
&mut cur_token,
'/' as i32 as libc::c_char,
);
match r {
0 => {
r = mailimf_cfws_parse(message, length, &mut cur_token);
if r != MAILIMF_NO_ERROR as libc::c_int && r != MAILIMF_ERROR_PARSE as libc::c_int {
res = r;
current_block = 10242373397628622958;
} else {
r = mailmime_subtype_parse(message, length, &mut cur_token, &mut subtype);
if r != MAILIMF_NO_ERROR as libc::c_int {
res = r;
current_block = 10242373397628622958;
} else {
current_block = 1109700713171191020;
}
}
}
1 => {
subtype = strdup(b"unknown\x00" as *const u8 as *const libc::c_char);
current_block = 1109700713171191020;
}
_ => {
res = r;
current_block = 10242373397628622958;
}
}
match current_block {
1109700713171191020 => {
parameters_list = clist_new();
if parameters_list.is_null() {
res = MAILIMF_ERROR_MEMORY as libc::c_int
} else {
loop {
let mut final_token: size_t = 0;
let mut parameter: *mut mailmime_parameter = 0 as *mut mailmime_parameter;
final_token = cur_token;
r = mailimf_unstrict_char_parse(
message,
length,
&mut cur_token,
';' as i32 as libc::c_char,
);
if r != MAILIMF_NO_ERROR as libc::c_int {
cur_token = final_token;
current_block = 12497913735442871383;
break;
} else {
r = mailimf_cfws_parse(message, length, &mut cur_token);
if r != MAILIMF_NO_ERROR as libc::c_int
&& r != MAILIMF_ERROR_PARSE as libc::c_int
{
res = r;
current_block = 6276274620003476740;
break;
} else {
r = mailmime_parameter_parse(
message,
length,
&mut cur_token,
&mut parameter,
);
if r == MAILIMF_NO_ERROR as libc::c_int {
r = clist_insert_after(
parameters_list,
(*parameters_list).last,
parameter as *mut libc::c_void,
);
if !(r < 0i32) {
continue;
}
mailmime_parameter_free(parameter);
res = MAILIMF_ERROR_MEMORY as libc::c_int;
current_block = 5731074241326334034;
break;
} else if r == MAILIMF_ERROR_PARSE as libc::c_int {
cur_token = final_token;
current_block = 12497913735442871383;
break;
} else {
res = r;
current_block = 6276274620003476740;
break;
}
}
}
}
match current_block {
6276274620003476740 => {}
_ => {
match current_block {
12497913735442871383 => {
content =
mailmime_content_new(type_0, subtype, parameters_list);
if content.is_null() {
res = MAILIMF_ERROR_MEMORY as libc::c_int
} else {
*result = content;
*indx = cur_token;
return MAILIMF_NO_ERROR as libc::c_int;
}
}
_ => {}
}
clist_foreach(
parameters_list,
::std::mem::transmute::<
Option<unsafe fn(_: *mut mailmime_parameter) -> ()>,
clist_func,
>(Some(mailmime_parameter_free)),
0 as *mut libc::c_void,
);
clist_free(parameters_list);
}
}
}
mailmime_subtype_free(subtype);
}
_ => {}
}
mailmime_type_free(type_0);
}
return res;
}
pub unsafe fn mailmime_parameter_parse(
mut message: *const libc::c_char,
mut length: size_t,
mut indx: *mut size_t,
mut result: *mut *mut mailmime_parameter,
) -> libc::c_int {
let mut attribute: *mut libc::c_char = 0 as *mut libc::c_char;
let mut value: *mut libc::c_char = 0 as *mut libc::c_char;
let mut parameter: *mut mailmime_parameter = 0 as *mut mailmime_parameter;
let mut cur_token: size_t = 0;
let mut r: libc::c_int = 0;
let mut res: libc::c_int = 0;
cur_token = *indx;
r = mailmime_attribute_parse(message, length, &mut cur_token, &mut attribute);
if r != MAILIMF_NO_ERROR as libc::c_int {
res = r
} else {
r = mailimf_unstrict_char_parse(
message,
length,
&mut cur_token,
'=' as i32 as libc::c_char,
);
if r != MAILIMF_NO_ERROR as libc::c_int {
res = r
} else {
r = mailimf_cfws_parse(message, length, &mut cur_token);
if r != MAILIMF_NO_ERROR as libc::c_int && r != MAILIMF_ERROR_PARSE as libc::c_int {
res = r
} else {
r = mailmime_value_parse(message, length, &mut cur_token, &mut value);
if r != MAILIMF_NO_ERROR as libc::c_int {
res = r
} else {
parameter = mailmime_parameter_new(attribute, value);
if parameter.is_null() {
res = MAILIMF_ERROR_MEMORY as libc::c_int;
mailmime_value_free(value);
} else {
*result = parameter;
*indx = cur_token;
return MAILIMF_NO_ERROR as libc::c_int;
}
}
}
}
mailmime_attribute_free(attribute);
}
return res;
}
pub unsafe fn mailmime_value_parse(
mut message: *const libc::c_char,
mut length: size_t,
mut indx: *mut size_t,
mut result: *mut *mut libc::c_char,
) -> libc::c_int {
let mut r: libc::c_int = 0;
r = mailimf_atom_parse(message, length, indx, result);
if r == MAILIMF_ERROR_PARSE as libc::c_int {
r = mailimf_quoted_string_parse(message, length, indx, result)
}
if r != MAILIMF_NO_ERROR as libc::c_int {
return r;
}
return MAILIMF_NO_ERROR as libc::c_int;
}
/*
* libEtPan! -- a mail stuff library
*
* Copyright (C) 2001, 2005 - DINH Viet Hoa
* 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 libEtPan! project 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 AUTHORS 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 AUTHORS 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.
*/
/*
* $Id: mailmime.c,v 1.29 2011/01/06 00:09:52 hoa Exp $
*/
/*
RFC 2045
RFC 2046
RFC 2047
RFC 2048
RFC 2049
RFC 2231
RFC 2387
RFC 2424
RFC 2557
RFC 2183 Content-Disposition
RFC 1766 Language
*/
unsafe fn mailmime_attribute_parse(
mut message: *const libc::c_char,
mut length: size_t,
mut indx: *mut size_t,
mut result: *mut *mut libc::c_char,
) -> libc::c_int {
return mailmime_token_parse(message, length, indx, result);
}
unsafe fn mailmime_token_parse(
mut message: *const libc::c_char,
mut length: size_t,
mut indx: *mut size_t,
mut token: *mut *mut libc::c_char,
) -> libc::c_int {
return mailimf_custom_string_parse(message, length, indx, token, Some(is_token));
}
unsafe fn is_token(mut ch: libc::c_char) -> libc::c_int {
let mut uch: libc::c_uchar = ch as libc::c_uchar;
if uch as libc::c_int > 0x7fi32 {
return 0i32;
}
if uch as libc::c_int == ' ' as i32 {
return 0i32;
}
if 0 != is_tspecials(ch) {
return 0i32;
}
return 1i32;
}
unsafe fn is_tspecials(mut ch: libc::c_char) -> libc::c_int {
match ch as libc::c_int {
40 | 41 | 60 | 62 | 64 | 44 | 59 | 58 | 92 | 34 | 47 | 91 | 93 | 63 | 61 => return 1i32,
_ => return 0i32,
};
}
unsafe fn mailmime_subtype_parse(
mut message: *const libc::c_char,
mut length: size_t,
mut indx: *mut size_t,
mut result: *mut *mut libc::c_char,
) -> libc::c_int {
return mailmime_extension_token_parse(message, length, indx, result);
}
pub unsafe fn mailmime_extension_token_parse(
mut message: *const libc::c_char,
mut length: size_t,
mut indx: *mut size_t,
mut result: *mut *mut libc::c_char,
) -> libc::c_int {
return mailmime_token_parse(message, length, indx, result);
}
unsafe fn mailmime_type_parse(
mut message: *const libc::c_char,
mut length: size_t,
mut indx: *mut size_t,
mut result: *mut *mut mailmime_type,
) -> libc::c_int {
let mut discrete_type: *mut mailmime_discrete_type = 0 as *mut mailmime_discrete_type;
let mut composite_type: *mut mailmime_composite_type = 0 as *mut mailmime_composite_type;
let mut cur_token: size_t = 0;
let mut mime_type: *mut mailmime_type = 0 as *mut mailmime_type;
let mut type_0: libc::c_int = 0;
let mut res: libc::c_int = 0;
let mut r: libc::c_int = 0;
cur_token = *indx;
discrete_type = 0 as *mut mailmime_discrete_type;
composite_type = 0 as *mut mailmime_composite_type;
type_0 = MAILMIME_TYPE_ERROR as libc::c_int;
r = mailmime_composite_type_parse(message, length, &mut cur_token, &mut composite_type);
if r == MAILIMF_NO_ERROR as libc::c_int {
type_0 = MAILMIME_TYPE_COMPOSITE_TYPE as libc::c_int
}
if r == MAILIMF_ERROR_PARSE as libc::c_int {
r = mailmime_discrete_type_parse(message, length, &mut cur_token, &mut discrete_type);
if r == MAILIMF_NO_ERROR as libc::c_int {
type_0 = MAILMIME_TYPE_DISCRETE_TYPE as libc::c_int
}
}
if r != MAILIMF_NO_ERROR as libc::c_int {
res = r
} else {
mime_type = mailmime_type_new(type_0, discrete_type, composite_type);
if mime_type.is_null() {
res = r;
if !discrete_type.is_null() {
mailmime_discrete_type_free(discrete_type);
}
if !composite_type.is_null() {
mailmime_composite_type_free(composite_type);
}
} else {
*result = mime_type;
*indx = cur_token;
return MAILIMF_NO_ERROR as libc::c_int;
}
}
return res;
}
unsafe fn mailmime_discrete_type_parse(
mut message: *const libc::c_char,
mut length: size_t,
mut indx: *mut size_t,
mut result: *mut *mut mailmime_discrete_type,
) -> libc::c_int {
let mut extension: *mut libc::c_char = 0 as *mut libc::c_char;
let mut type_0: libc::c_int = 0;
let mut discrete_type: *mut mailmime_discrete_type = 0 as *mut mailmime_discrete_type;
let mut cur_token: size_t = 0;
let mut r: libc::c_int = 0;
let mut res: libc::c_int = 0;
cur_token = *indx;
extension = 0 as *mut libc::c_char;
type_0 = MAILMIME_DISCRETE_TYPE_ERROR as libc::c_int;
r = mailimf_token_case_insensitive_len_parse(
message,
length,
&mut cur_token,
b"text\x00" as *const u8 as *const libc::c_char as *mut libc::c_char,
strlen(b"text\x00" as *const u8 as *const libc::c_char),
);
if r == MAILIMF_NO_ERROR as libc::c_int {
type_0 = MAILMIME_DISCRETE_TYPE_TEXT as libc::c_int
}
if r == MAILIMF_ERROR_PARSE as libc::c_int {
r = mailimf_token_case_insensitive_len_parse(
message,
length,
&mut cur_token,
b"image\x00" as *const u8 as *const libc::c_char as *mut libc::c_char,
strlen(b"image\x00" as *const u8 as *const libc::c_char),
);
if r == MAILIMF_NO_ERROR as libc::c_int {
type_0 = MAILMIME_DISCRETE_TYPE_IMAGE as libc::c_int
}
}
if r == MAILIMF_ERROR_PARSE as libc::c_int {
r = mailimf_token_case_insensitive_len_parse(
message,
length,
&mut cur_token,
b"audio\x00" as *const u8 as *const libc::c_char as *mut libc::c_char,
strlen(b"audio\x00" as *const u8 as *const libc::c_char),
);
if r == MAILIMF_NO_ERROR as libc::c_int {
type_0 = MAILMIME_DISCRETE_TYPE_AUDIO as libc::c_int
}
}
if r == MAILIMF_ERROR_PARSE as libc::c_int {
r = mailimf_token_case_insensitive_len_parse(
message,
length,
&mut cur_token,
b"video\x00" as *const u8 as *const libc::c_char as *mut libc::c_char,
strlen(b"video\x00" as *const u8 as *const libc::c_char),
);
if r == MAILIMF_NO_ERROR as libc::c_int {
type_0 = MAILMIME_DISCRETE_TYPE_VIDEO as libc::c_int
}
}
if r == MAILIMF_ERROR_PARSE as libc::c_int {
r = mailimf_token_case_insensitive_len_parse(
message,
length,
&mut cur_token,
b"application\x00" as *const u8 as *const libc::c_char as *mut libc::c_char,
strlen(b"application\x00" as *const u8 as *const libc::c_char),
);
if r == MAILIMF_NO_ERROR as libc::c_int {
type_0 = MAILMIME_DISCRETE_TYPE_APPLICATION as libc::c_int
}
}
if r == MAILIMF_ERROR_PARSE as libc::c_int {
r = mailmime_extension_token_parse(message, length, &mut cur_token, &mut extension);
if r == MAILIMF_NO_ERROR as libc::c_int {
type_0 = MAILMIME_DISCRETE_TYPE_EXTENSION as libc::c_int
}
}
if r != MAILIMF_NO_ERROR as libc::c_int {
res = r
} else {
discrete_type = mailmime_discrete_type_new(type_0, extension);
if discrete_type.is_null() {
res = MAILIMF_ERROR_MEMORY as libc::c_int;
mailmime_extension_token_free(extension);
} else {
*result = discrete_type;
*indx = cur_token;
return MAILIMF_NO_ERROR as libc::c_int;
}
}
return res;
}
unsafe fn mailmime_composite_type_parse(
mut message: *const libc::c_char,
mut length: size_t,
mut indx: *mut size_t,
mut result: *mut *mut mailmime_composite_type,
) -> libc::c_int {
let mut extension_token: *mut libc::c_char = 0 as *mut libc::c_char;
let mut type_0: libc::c_int = 0;
let mut ct: *mut mailmime_composite_type = 0 as *mut mailmime_composite_type;
let mut cur_token: size_t = 0;
let mut r: libc::c_int = 0;
let mut res: libc::c_int = 0;
cur_token = *indx;
extension_token = 0 as *mut libc::c_char;
type_0 = MAILMIME_COMPOSITE_TYPE_ERROR as libc::c_int;
r = mailimf_token_case_insensitive_len_parse(
message,
length,
&mut cur_token,
b"message\x00" as *const u8 as *const libc::c_char as *mut libc::c_char,
strlen(b"message\x00" as *const u8 as *const libc::c_char),
);
if r == MAILIMF_NO_ERROR as libc::c_int {
type_0 = MAILMIME_COMPOSITE_TYPE_MESSAGE as libc::c_int
}
if r == MAILIMF_ERROR_PARSE as libc::c_int {
r = mailimf_token_case_insensitive_len_parse(
message,
length,
&mut cur_token,
b"multipart\x00" as *const u8 as *const libc::c_char as *mut libc::c_char,
strlen(b"multipart\x00" as *const u8 as *const libc::c_char),
);
if r == MAILIMF_NO_ERROR as libc::c_int {
type_0 = MAILMIME_COMPOSITE_TYPE_MULTIPART as libc::c_int
}
}
if r != MAILIMF_NO_ERROR as libc::c_int {
res = r
} else {
ct = mailmime_composite_type_new(type_0, extension_token);
if ct.is_null() {
res = MAILIMF_ERROR_MEMORY as libc::c_int;
if !extension_token.is_null() {
mailmime_extension_token_free(extension_token);
}
} else {
*result = ct;
*indx = cur_token;
return MAILIMF_NO_ERROR as libc::c_int;
}
}
return res;
}
pub unsafe fn mailmime_description_parse(
mut message: *const libc::c_char,
mut length: size_t,
mut indx: *mut size_t,
mut result: *mut *mut libc::c_char,
) -> libc::c_int {
return mailimf_custom_string_parse(message, length, indx, result, Some(is_text));
}
unsafe fn is_text(mut ch: libc::c_char) -> libc::c_int {
let mut uch: libc::c_uchar = ch as libc::c_uchar;
if (uch as libc::c_int) < 1i32 {
return 0i32;
}
if uch as libc::c_int == 10i32 || uch as libc::c_int == 13i32 {
return 0i32;
}
return 1i32;
}
pub unsafe fn mailmime_location_parse(
mut message: *const libc::c_char,
mut length: size_t,
mut indx: *mut size_t,
mut result: *mut *mut libc::c_char,
) -> libc::c_int {
return mailimf_custom_string_parse(message, length, indx, result, Some(is_text));
}
pub unsafe fn mailmime_encoding_parse(
mut message: *const libc::c_char,
mut length: size_t,
mut indx: *mut size_t,
mut result: *mut *mut mailmime_mechanism,
) -> libc::c_int {
return mailmime_mechanism_parse(message, length, indx, result);
}
unsafe fn mailmime_mechanism_parse(
mut message: *const libc::c_char,
mut length: size_t,
mut indx: *mut size_t,
mut result: *mut *mut mailmime_mechanism,
) -> libc::c_int {
let mut token: *mut libc::c_char = 0 as *mut libc::c_char;
let mut type_0: libc::c_int = 0;
let mut mechanism: *mut mailmime_mechanism = 0 as *mut mailmime_mechanism;
let mut cur_token: size_t = 0;
let mut r: libc::c_int = 0;
let mut res: libc::c_int = 0;
cur_token = *indx;
type_0 = MAILMIME_MECHANISM_ERROR as libc::c_int;
token = 0 as *mut libc::c_char;
r = mailimf_token_case_insensitive_len_parse(
message,
length,
&mut cur_token,
b"7bit\x00" as *const u8 as *const libc::c_char as *mut libc::c_char,
strlen(b"7bit\x00" as *const u8 as *const libc::c_char),
);
if r == MAILIMF_NO_ERROR as libc::c_int {
type_0 = MAILMIME_MECHANISM_7BIT as libc::c_int
}
if r == MAILIMF_ERROR_PARSE as libc::c_int {
r = mailimf_token_case_insensitive_len_parse(
message,
length,
&mut cur_token,
b"8bit\x00" as *const u8 as *const libc::c_char as *mut libc::c_char,
strlen(b"8bit\x00" as *const u8 as *const libc::c_char),
);
if r == MAILIMF_NO_ERROR as libc::c_int {
type_0 = MAILMIME_MECHANISM_8BIT as libc::c_int
}
}
if r == MAILIMF_ERROR_PARSE as libc::c_int {
r = mailimf_token_case_insensitive_len_parse(
message,
length,
&mut cur_token,
b"binary\x00" as *const u8 as *const libc::c_char as *mut libc::c_char,
strlen(b"binary\x00" as *const u8 as *const libc::c_char),
);
if r == MAILIMF_NO_ERROR as libc::c_int {
type_0 = MAILMIME_MECHANISM_BINARY as libc::c_int
}
}
if r == MAILIMF_ERROR_PARSE as libc::c_int {
r = mailimf_token_case_insensitive_len_parse(
message,
length,
&mut cur_token,
b"quoted-printable\x00" as *const u8 as *const libc::c_char as *mut libc::c_char,
strlen(b"quoted-printable\x00" as *const u8 as *const libc::c_char),
);
if r == MAILIMF_NO_ERROR as libc::c_int {
type_0 = MAILMIME_MECHANISM_QUOTED_PRINTABLE as libc::c_int
}
}
if r == MAILIMF_ERROR_PARSE as libc::c_int {
r = mailimf_token_case_insensitive_len_parse(
message,
length,
&mut cur_token,
b"base64\x00" as *const u8 as *const libc::c_char as *mut libc::c_char,
strlen(b"base64\x00" as *const u8 as *const libc::c_char),
);
if r == MAILIMF_NO_ERROR as libc::c_int {
type_0 = MAILMIME_MECHANISM_BASE64 as libc::c_int
}
}
if r == MAILIMF_ERROR_PARSE as libc::c_int {
r = mailmime_token_parse(message, length, &mut cur_token, &mut token);
if r == MAILIMF_NO_ERROR as libc::c_int {
type_0 = MAILMIME_MECHANISM_TOKEN as libc::c_int
}
}
if r != MAILIMF_NO_ERROR as libc::c_int {
res = r
} else {
mechanism = mailmime_mechanism_new(type_0, token);
if mechanism.is_null() {
res = MAILIMF_ERROR_MEMORY as libc::c_int;
if !token.is_null() {
mailmime_token_free(token);
}
} else {
*result = mechanism;
*indx = cur_token;
return MAILIMF_NO_ERROR as libc::c_int;
}
}
return res;
}
pub unsafe fn mailmime_field_parse(
mut field: *mut mailimf_optional_field,
mut result: *mut *mut mailmime_field,
) -> libc::c_int {
let mut name: *mut libc::c_char = 0 as *mut libc::c_char;
let mut value: *mut libc::c_char = 0 as *mut libc::c_char;
let mut guessed_type: libc::c_int = 0;
let mut cur_token: size_t = 0;
let mut content: *mut mailmime_content = 0 as *mut mailmime_content;
let mut encoding: *mut mailmime_mechanism = 0 as *mut mailmime_mechanism;
let mut id: *mut libc::c_char = 0 as *mut libc::c_char;
let mut description: *mut libc::c_char = 0 as *mut libc::c_char;
let mut version: uint32_t = 0;
let mut mime_field: *mut mailmime_field = 0 as *mut mailmime_field;
let mut language: *mut mailmime_language = 0 as *mut mailmime_language;
let mut disposition: *mut mailmime_disposition = 0 as *mut mailmime_disposition;
let mut location: *mut libc::c_char = 0 as *mut libc::c_char;
let mut res: libc::c_int = 0;
let mut r: libc::c_int = 0;
name = (*field).fld_name;
value = (*field).fld_value;
cur_token = 0i32 as size_t;
content = 0 as *mut mailmime_content;
encoding = 0 as *mut mailmime_mechanism;
id = 0 as *mut libc::c_char;
description = 0 as *mut libc::c_char;
version = 0i32 as uint32_t;
disposition = 0 as *mut mailmime_disposition;
language = 0 as *mut mailmime_language;
location = 0 as *mut libc::c_char;
guessed_type = guess_field_type(name);
match guessed_type {
1 => {
if strcasecmp(
name,
b"Content-Type\x00" as *const u8 as *const libc::c_char,
) != 0i32
{
return MAILIMF_ERROR_PARSE as libc::c_int;
}
let mut cur_token_0: size_t = 0i32 as size_t;
let mut decoded_value: *mut libc::c_char = 0 as *mut libc::c_char;
r = mailmime_encoded_phrase_parse(
b"us-ascii\x00" as *const u8 as *const libc::c_char,
value,
strlen(value),
&mut cur_token_0,
b"utf-8\x00" as *const u8 as *const libc::c_char,
&mut decoded_value,
);
if r != MAILIMF_NO_ERROR as libc::c_int {
cur_token_0 = 0i32 as size_t;
r = mailmime_content_parse(value, strlen(value), &mut cur_token_0, &mut content)
} else {
cur_token_0 = 0i32 as size_t;
r = mailmime_content_parse(
decoded_value,
strlen(decoded_value),
&mut cur_token_0,
&mut content,
);
free(decoded_value as *mut libc::c_void);
}
if r != MAILIMF_NO_ERROR as libc::c_int {
return r;
}
}
2 => {
if strcasecmp(
name,
b"Content-Transfer-Encoding\x00" as *const u8 as *const libc::c_char,
) != 0i32
{
return MAILIMF_ERROR_PARSE as libc::c_int;
}
r = mailmime_encoding_parse(value, strlen(value), &mut cur_token, &mut encoding);
if r != MAILIMF_NO_ERROR as libc::c_int {
return r;
}
}
3 => {
if strcasecmp(name, b"Content-ID\x00" as *const u8 as *const libc::c_char) != 0i32 {
return MAILIMF_ERROR_PARSE as libc::c_int;
}
r = mailmime_id_parse(value, strlen(value), &mut cur_token, &mut id);
if r != MAILIMF_NO_ERROR as libc::c_int {
return r;
}
}
4 => {
if strcasecmp(
name,
b"Content-Description\x00" as *const u8 as *const libc::c_char,
) != 0i32
{
return MAILIMF_ERROR_PARSE as libc::c_int;
}
r = mailmime_description_parse(value, strlen(value), &mut cur_token, &mut description);
if r != MAILIMF_NO_ERROR as libc::c_int {
return r;
}
}
5 => {
if strcasecmp(
name,
b"MIME-Version\x00" as *const u8 as *const libc::c_char,
) != 0i32
{
return MAILIMF_ERROR_PARSE as libc::c_int;
}
r = mailmime_version_parse(value, strlen(value), &mut cur_token, &mut version);
if r != MAILIMF_NO_ERROR as libc::c_int {
return r;
}
}
6 => {
if strcasecmp(
name,
b"Content-Disposition\x00" as *const u8 as *const libc::c_char,
) != 0i32
{
return MAILIMF_ERROR_PARSE as libc::c_int;
}
r = mailmime_disposition_parse(value, strlen(value), &mut cur_token, &mut disposition);
if r != MAILIMF_NO_ERROR as libc::c_int {
return r;
}
}
7 => {
if strcasecmp(
name,
b"Content-Language\x00" as *const u8 as *const libc::c_char,
) != 0i32
{
return MAILIMF_ERROR_PARSE as libc::c_int;
}
r = mailmime_language_parse(value, strlen(value), &mut cur_token, &mut language);
if r != MAILIMF_NO_ERROR as libc::c_int {
return r;
}
}
8 => {
if strcasecmp(
name,
b"Content-Location\x00" as *const u8 as *const libc::c_char,
) != 0i32
{
return MAILIMF_ERROR_PARSE as libc::c_int;
}
r = mailmime_location_parse(value, strlen(value), &mut cur_token, &mut location);
if r != MAILIMF_NO_ERROR as libc::c_int {
return r;
}
}
_ => return MAILIMF_ERROR_PARSE as libc::c_int,
}
mime_field = mailmime_field_new(
guessed_type,
content,
encoding,
id,
description,
version,
disposition,
language,
location,
);
if mime_field.is_null() {
res = MAILIMF_ERROR_MEMORY as libc::c_int;
if !location.is_null() {
mailmime_location_free(location);
}
if !language.is_null() {
mailmime_language_free(language);
}
if !content.is_null() {
mailmime_content_free(content);
}
if !encoding.is_null() {
mailmime_encoding_free(encoding);
}
if !id.is_null() {
mailmime_id_free(id);
}
if !description.is_null() {
mailmime_description_free(description);
}
return res;
} else {
*result = mime_field;
return MAILIMF_NO_ERROR as libc::c_int;
};
}
pub unsafe fn mailmime_language_parse(
mut message: *const libc::c_char,
mut length: size_t,
mut indx: *mut size_t,
mut result: *mut *mut mailmime_language,
) -> libc::c_int {
let mut current_block: u64;
let mut cur_token: size_t = 0;
let mut r: libc::c_int = 0;
let mut res: libc::c_int = 0;
let mut list: *mut clist = 0 as *mut clist;
let mut language: *mut mailmime_language = 0 as *mut mailmime_language;
cur_token = *indx;
list = clist_new();
if list.is_null() {
res = MAILIMF_ERROR_MEMORY as libc::c_int
} else {
loop {
let mut atom: *mut libc::c_char = 0 as *mut libc::c_char;
r = mailimf_unstrict_char_parse(
message,
length,
&mut cur_token,
',' as i32 as libc::c_char,
);
if r == MAILIMF_NO_ERROR as libc::c_int {
r = mailimf_atom_parse(message, length, &mut cur_token, &mut atom);
if r == MAILIMF_NO_ERROR as libc::c_int {
r = clist_insert_after(list, (*list).last, atom as *mut libc::c_void);
if !(r < 0i32) {
continue;
}
mailimf_atom_free(atom);
res = MAILIMF_ERROR_MEMORY as libc::c_int;
current_block = 14533943604180559553;
break;
} else {
/* do nothing */
if r == MAILIMF_ERROR_PARSE as libc::c_int {
current_block = 6669252993407410313;
break;
}
res = r;
current_block = 11601180562230609130;
break;
}
} else {
/* do nothing */
if r == MAILIMF_ERROR_PARSE as libc::c_int {
current_block = 6669252993407410313;
break;
}
res = r;
current_block = 11601180562230609130;
break;
}
}
match current_block {
11601180562230609130 => {}
_ => {
match current_block {
6669252993407410313 => {
language = mailmime_language_new(list);
if language.is_null() {
res = MAILIMF_ERROR_MEMORY as libc::c_int
} else {
*result = language;
*indx = cur_token;
return MAILIMF_NO_ERROR as libc::c_int;
}
}
_ => {}
}
clist_foreach(
list,
::std::mem::transmute::<
Option<unsafe fn(_: *mut libc::c_char) -> ()>,
clist_func,
>(Some(mailimf_atom_free)),
0 as *mut libc::c_void,
);
clist_free(list);
}
}
}
return res;
}
pub unsafe fn mailmime_version_parse(
mut message: *const libc::c_char,
mut length: size_t,
mut indx: *mut size_t,
mut result: *mut uint32_t,
) -> libc::c_int {
let mut cur_token: size_t = 0;
let mut hi: uint32_t = 0;
let mut low: uint32_t = 0;
let mut version: uint32_t = 0;
let mut r: libc::c_int = 0;
cur_token = *indx;
r = mailimf_number_parse(message, length, &mut cur_token, &mut hi);
if r != MAILIMF_NO_ERROR as libc::c_int {
return r;
}
r = mailimf_unstrict_char_parse(message, length, &mut cur_token, '.' as i32 as libc::c_char);
if r != MAILIMF_NO_ERROR as libc::c_int {
return r;
}
r = mailimf_cfws_parse(message, length, &mut cur_token);
if r != MAILIMF_NO_ERROR as libc::c_int && r != MAILIMF_ERROR_PARSE as libc::c_int {
return r;
}
r = mailimf_number_parse(message, length, &mut cur_token, &mut low);
if r != MAILIMF_NO_ERROR as libc::c_int {
return r;
}
version = (hi << 16i32).wrapping_add(low);
*result = version;
*indx = cur_token;
return MAILIMF_NO_ERROR as libc::c_int;
}
pub unsafe fn mailmime_id_parse(
mut message: *const libc::c_char,
mut length: size_t,
mut indx: *mut size_t,
mut result: *mut *mut libc::c_char,
) -> libc::c_int {
return mailimf_msg_id_parse(message, length, indx, result);
}
unsafe fn guess_field_type(mut name: *mut libc::c_char) -> libc::c_int {
let mut state: libc::c_int = 0;
if *name as libc::c_int == 'M' as i32 {
return MAILMIME_FIELD_VERSION as libc::c_int;
}
if strncasecmp(
name,
b"Content-\x00" as *const u8 as *const libc::c_char,
8i32 as libc::size_t,
) != 0i32
{
return MAILMIME_FIELD_NONE as libc::c_int;
}
name = name.offset(8isize);
state = FIELD_STATE_START as libc::c_int;
loop {
match state {
0 => {
match toupper(*name as libc::c_uchar as libc::c_int) as libc::c_char as libc::c_int
{
84 => state = FIELD_STATE_T as libc::c_int,
73 => return MAILMIME_FIELD_ID as libc::c_int,
68 => state = FIELD_STATE_D as libc::c_int,
76 => state = FIELD_STATE_L as libc::c_int,
_ => return MAILMIME_FIELD_NONE as libc::c_int,
}
}
1 => {
match toupper(*name as libc::c_uchar as libc::c_int) as libc::c_char as libc::c_int
{
89 => return MAILMIME_FIELD_TYPE as libc::c_int,
82 => return MAILMIME_FIELD_TRANSFER_ENCODING as libc::c_int,
_ => return MAILMIME_FIELD_NONE as libc::c_int,
}
}
2 => {
match toupper(*name as libc::c_uchar as libc::c_int) as libc::c_char as libc::c_int
{
69 => return MAILMIME_FIELD_DESCRIPTION as libc::c_int,
73 => return MAILMIME_FIELD_DISPOSITION as libc::c_int,
_ => return MAILMIME_FIELD_NONE as libc::c_int,
}
}
3 => {
match toupper(*name as libc::c_uchar as libc::c_int) as libc::c_char as libc::c_int
{
65 => return MAILMIME_FIELD_LANGUAGE as libc::c_int,
79 => return MAILMIME_FIELD_LOCATION as libc::c_int,
_ => return MAILMIME_FIELD_NONE as libc::c_int,
}
}
_ => {}
}
name = name.offset(1isize)
}
}
pub unsafe fn mailmime_fields_parse(
mut fields: *mut mailimf_fields,
mut result: *mut *mut mailmime_fields,
) -> libc::c_int {
let mut current_block: u64;
let mut cur: *mut clistiter = 0 as *mut clistiter;
let mut mime_fields: *mut mailmime_fields = 0 as *mut mailmime_fields;
let mut list: *mut clist = 0 as *mut clist;
let mut r: libc::c_int = 0;
let mut res: libc::c_int = 0;
list = clist_new();
if list.is_null() {
res = MAILIMF_ERROR_MEMORY as libc::c_int
} else {
cur = (*(*fields).fld_list).first;
loop {
if cur.is_null() {
current_block = 1109700713171191020;
break;
}
let mut field: *mut mailimf_field = 0 as *mut mailimf_field;
let mut mime_field: *mut mailmime_field = 0 as *mut mailmime_field;
field = (if !cur.is_null() {
(*cur).data
} else {
0 as *mut libc::c_void
}) as *mut mailimf_field;
if (*field).fld_type == MAILIMF_FIELD_OPTIONAL_FIELD as libc::c_int {
r = mailmime_field_parse((*field).fld_data.fld_optional_field, &mut mime_field);
if r == MAILIMF_NO_ERROR as libc::c_int {
r = clist_insert_after(list, (*list).last, mime_field as *mut libc::c_void);
if r < 0i32 {
mailmime_field_free(mime_field);
res = MAILIMF_ERROR_MEMORY as libc::c_int;
current_block = 17592539310030730040;
break;
}
} else if !(r == MAILIMF_ERROR_PARSE as libc::c_int) {
/* do nothing */
res = r;
current_block = 17592539310030730040;
break;
}
}
cur = if !cur.is_null() {
(*cur).next
} else {
0 as *mut clistcell
}
}
match current_block {
1109700713171191020 => {
if (*list).first.is_null() {
res = MAILIMF_ERROR_PARSE as libc::c_int
} else {
mime_fields = mailmime_fields_new(list);
if mime_fields.is_null() {
res = MAILIMF_ERROR_MEMORY as libc::c_int
} else {
*result = mime_fields;
return MAILIMF_NO_ERROR as libc::c_int;
}
}
}
_ => {}
}
clist_foreach(
list,
::std::mem::transmute::<Option<unsafe fn(_: *mut mailmime_field) -> ()>, clist_func>(
Some(mailmime_field_free),
),
0 as *mut libc::c_void,
);
clist_free(list);
}
return res;
}
|
#[doc = "Reader of register DC9"]
pub type R = crate::R<u32, super::DC9>;
#[doc = "Reader of field `ADC0DC0`"]
pub type ADC0DC0_R = crate::R<bool, bool>;
#[doc = "Reader of field `ADC0DC1`"]
pub type ADC0DC1_R = crate::R<bool, bool>;
#[doc = "Reader of field `ADC0DC2`"]
pub type ADC0DC2_R = crate::R<bool, bool>;
#[doc = "Reader of field `ADC0DC3`"]
pub type ADC0DC3_R = crate::R<bool, bool>;
#[doc = "Reader of field `ADC0DC4`"]
pub type ADC0DC4_R = crate::R<bool, bool>;
#[doc = "Reader of field `ADC0DC5`"]
pub type ADC0DC5_R = crate::R<bool, bool>;
#[doc = "Reader of field `ADC0DC6`"]
pub type ADC0DC6_R = crate::R<bool, bool>;
#[doc = "Reader of field `ADC0DC7`"]
pub type ADC0DC7_R = crate::R<bool, bool>;
#[doc = "Reader of field `ADC1DC0`"]
pub type ADC1DC0_R = crate::R<bool, bool>;
#[doc = "Reader of field `ADC1DC1`"]
pub type ADC1DC1_R = crate::R<bool, bool>;
#[doc = "Reader of field `ADC1DC2`"]
pub type ADC1DC2_R = crate::R<bool, bool>;
#[doc = "Reader of field `ADC1DC3`"]
pub type ADC1DC3_R = crate::R<bool, bool>;
#[doc = "Reader of field `ADC1DC4`"]
pub type ADC1DC4_R = crate::R<bool, bool>;
#[doc = "Reader of field `ADC1DC5`"]
pub type ADC1DC5_R = crate::R<bool, bool>;
#[doc = "Reader of field `ADC1DC6`"]
pub type ADC1DC6_R = crate::R<bool, bool>;
#[doc = "Reader of field `ADC1DC7`"]
pub type ADC1DC7_R = crate::R<bool, bool>;
impl R {
#[doc = "Bit 0 - ADC0 DC0 Present"]
#[inline(always)]
pub fn adc0dc0(&self) -> ADC0DC0_R {
ADC0DC0_R::new((self.bits & 0x01) != 0)
}
#[doc = "Bit 1 - ADC0 DC1 Present"]
#[inline(always)]
pub fn adc0dc1(&self) -> ADC0DC1_R {
ADC0DC1_R::new(((self.bits >> 1) & 0x01) != 0)
}
#[doc = "Bit 2 - ADC0 DC2 Present"]
#[inline(always)]
pub fn adc0dc2(&self) -> ADC0DC2_R {
ADC0DC2_R::new(((self.bits >> 2) & 0x01) != 0)
}
#[doc = "Bit 3 - ADC0 DC3 Present"]
#[inline(always)]
pub fn adc0dc3(&self) -> ADC0DC3_R {
ADC0DC3_R::new(((self.bits >> 3) & 0x01) != 0)
}
#[doc = "Bit 4 - ADC0 DC4 Present"]
#[inline(always)]
pub fn adc0dc4(&self) -> ADC0DC4_R {
ADC0DC4_R::new(((self.bits >> 4) & 0x01) != 0)
}
#[doc = "Bit 5 - ADC0 DC5 Present"]
#[inline(always)]
pub fn adc0dc5(&self) -> ADC0DC5_R {
ADC0DC5_R::new(((self.bits >> 5) & 0x01) != 0)
}
#[doc = "Bit 6 - ADC0 DC6 Present"]
#[inline(always)]
pub fn adc0dc6(&self) -> ADC0DC6_R {
ADC0DC6_R::new(((self.bits >> 6) & 0x01) != 0)
}
#[doc = "Bit 7 - ADC0 DC7 Present"]
#[inline(always)]
pub fn adc0dc7(&self) -> ADC0DC7_R {
ADC0DC7_R::new(((self.bits >> 7) & 0x01) != 0)
}
#[doc = "Bit 16 - ADC1 DC0 Present"]
#[inline(always)]
pub fn adc1dc0(&self) -> ADC1DC0_R {
ADC1DC0_R::new(((self.bits >> 16) & 0x01) != 0)
}
#[doc = "Bit 17 - ADC1 DC1 Present"]
#[inline(always)]
pub fn adc1dc1(&self) -> ADC1DC1_R {
ADC1DC1_R::new(((self.bits >> 17) & 0x01) != 0)
}
#[doc = "Bit 18 - ADC1 DC2 Present"]
#[inline(always)]
pub fn adc1dc2(&self) -> ADC1DC2_R {
ADC1DC2_R::new(((self.bits >> 18) & 0x01) != 0)
}
#[doc = "Bit 19 - ADC1 DC3 Present"]
#[inline(always)]
pub fn adc1dc3(&self) -> ADC1DC3_R {
ADC1DC3_R::new(((self.bits >> 19) & 0x01) != 0)
}
#[doc = "Bit 20 - ADC1 DC4 Present"]
#[inline(always)]
pub fn adc1dc4(&self) -> ADC1DC4_R {
ADC1DC4_R::new(((self.bits >> 20) & 0x01) != 0)
}
#[doc = "Bit 21 - ADC1 DC5 Present"]
#[inline(always)]
pub fn adc1dc5(&self) -> ADC1DC5_R {
ADC1DC5_R::new(((self.bits >> 21) & 0x01) != 0)
}
#[doc = "Bit 22 - ADC1 DC6 Present"]
#[inline(always)]
pub fn adc1dc6(&self) -> ADC1DC6_R {
ADC1DC6_R::new(((self.bits >> 22) & 0x01) != 0)
}
#[doc = "Bit 23 - ADC1 DC7 Present"]
#[inline(always)]
pub fn adc1dc7(&self) -> ADC1DC7_R {
ADC1DC7_R::new(((self.bits >> 23) & 0x01) != 0)
}
}
|
/**
* If you use the VADER sentiment analysis tools, please cite:
* Hutto, C.J. & Gilbert, E.E. (2014). VADER: A Parsimonious Rule-based Model for
* Sentiment Analysis of Social Media Text. Eighth International Conference on
* Weblogs and Social Media (ICWSM-14). Ann Arbor, MI, June 2014.
**/
#[macro_use] extern crate maplit;
#[macro_use] extern crate lazy_static;
extern crate regex;
extern crate unicase;
use std::cmp::min;
use std::collections::{HashMap, HashSet};
use regex::Regex;
use unicase::UniCase;
#[cfg(test)]
mod tests;
//empirically derived constants for scaling/amplifying sentiments
const B_INCR: f64 = 0.293;
const B_DECR: f64 = -0.293;
const C_INCR: f64 = 0.733;
const NEGATION_SCALAR: f64 = -0.740;
//sentiment increases for text with question or exclamation marks
const QMARK_INCR: f64 = 0.180;
const EMARK_INCR: f64 = 0.292;
//Maximum amount of question or question marks before their contribution to sentiment is
//disregarded
const MAX_EMARK: i32 = 4;
const MAX_QMARK: i32 = 3;
const MAX_QMARK_INCR: f64 = 0.96;
const NORMALIZATION_ALPHA: f64 = 15.0;
static RAW_LEXICON: &'static str = include_str!("resources/vader_lexicon.txt");
static RAW_EMOJI_LEXICON: &'static str = include_str!("resources/emoji_utf8_lexicon.txt");
lazy_static! {
static ref NEGATION_TOKENS: HashSet<UniCase<&'static str>> = convert_args!(hashset!(
"aint", "arent", "cannot", "cant", "couldnt", "darent", "didnt", "doesnt",
"ain't", "aren't", "can't", "couldn't", "daren't", "didn't", "doesn't",
"dont", "hadnt", "hasnt", "havent", "isnt", "mightnt", "mustnt", "neither",
"don't", "hadn't", "hasn't", "haven't", "isn't", "mightn't", "mustn't",
"neednt", "needn't", "never", "none", "nope", "nor", "not", "nothing", "nowhere",
"oughtnt", "shant", "shouldnt", "uhuh", "wasnt", "werent",
"oughtn't", "shan't", "shouldn't", "uh-uh", "wasn't", "weren't",
"without", "wont", "wouldnt", "won't", "wouldn't", "rarely", "seldom", "despite"));
static ref BOOSTER_DICT: HashMap<UniCase<&'static str>, f64> = convert_args!(hashmap!(
"absolutely"=> B_INCR, "amazingly"=> B_INCR, "awfully"=> B_INCR,
"completely"=> B_INCR, "considerable"=> B_INCR, "considerably"=> B_INCR,
"decidedly"=> B_INCR, "deeply"=> B_INCR, "effing"=> B_INCR, "enormous"=> B_INCR, "enormously"=> B_INCR,
"entirely"=> B_INCR, "especially"=> B_INCR, "exceptional"=> B_INCR, "exceptionally"=> B_INCR,
"extreme"=> B_INCR, "extremely"=> B_INCR,
"fabulously"=> B_INCR, "flipping"=> B_INCR, "flippin"=> B_INCR, "frackin"=> B_INCR, "fracking"=> B_INCR,
"fricking"=> B_INCR, "frickin"=> B_INCR, "frigging"=> B_INCR, "friggin"=> B_INCR, "fully"=> B_INCR,
"fuckin"=> B_INCR, "fucking"=> B_INCR, "fuggin"=> B_INCR, "fugging"=> B_INCR,
"greatly"=> B_INCR, "hella"=> B_INCR, "highly"=> B_INCR, "hugely"=> B_INCR,
"incredible"=> B_INCR, "incredibly"=> B_INCR, "intensely"=> B_INCR,
"major"=> B_INCR, "majorly"=> B_INCR, "more"=> B_INCR, "most"=> B_INCR, "particularly"=> B_INCR,
"purely"=> B_INCR, "quite"=> B_INCR, "really"=> B_INCR, "remarkably"=> B_INCR,
"so"=> B_INCR, "substantially"=> B_INCR,
"thoroughly"=> B_INCR, "total"=> B_INCR, "totally"=> B_INCR, "tremendous"=> B_INCR, "tremendously"=> B_INCR,
"uber"=> B_INCR, "unbelievably"=> B_INCR, "unusually"=> B_INCR, "utter"=> B_INCR, "utterly"=> B_INCR,
"very"=> B_INCR,
"almost"=> B_DECR, "barely"=> B_DECR, "hardly"=> B_DECR, "just enough"=> B_DECR,
"kind of"=> B_DECR, "kinda"=> B_DECR, "kindof"=> B_DECR, "kind-of"=> B_DECR,
"less"=> B_DECR, "little"=> B_DECR, "marginal"=> B_DECR, "marginally"=> B_DECR,
"occasional"=> B_DECR, "occasionally"=> B_DECR, "partly"=> B_DECR,
"scarce"=> B_DECR, "scarcely"=> B_DECR, "slight"=> B_DECR, "slightly"=> B_DECR, "somewhat"=> B_DECR,
"sort of"=> B_DECR, "sorta"=> B_DECR, "sortof"=> B_DECR, "sort-of"=> B_DECR
));
/**
* These dicts were used in some WIP or planned features in the original
* I may implement them later if I can understand how they're intended to work
**/
// // check for sentiment laden idioms that do not contain lexicon words (future work, not yet implemented)
// static ref SENTIMENT_LADEN_IDIOMS: HashMap<&'static str, f64> = hashmap![
// "cut the mustard" => 2.0, "hand to mouth" => -2.0,
// "back handed" => -2.0, "blow smoke" => -2.0, "blowing smoke" => -2.0,
// "upper hand" => 1.0, "break a leg" => 2.0,
// "cooking with gas" => 2.0, "in the black" => 2.0, "in the red" => -2.0,
// "on the ball" => 2.0, "under the weather" => -2.0];
// check for special case idioms containing lexicon words
static ref SPECIAL_CASE_IDIOMS: HashMap<UniCase<&'static str>, f64> = convert_args!(hashmap!(
"the shit" => 3.0, "the bomb" => 3.0, "bad ass" => 1.5, "badass" => 1.5, "yeah right" => -2.0,
"kiss of death" => -1.5, "to die for" => 3.0));
static ref ALL_CAPS_RE: Regex = Regex::new(r"^[A-Z\W]+$").unwrap();
static ref PUNCTUATION: &'static str = "[!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~]";
pub static ref LEXICON: HashMap<UniCase<&'static str>, f64> = parse_raw_lexicon(RAW_LEXICON);
pub static ref EMOJI_LEXICON: HashMap<&'static str, &'static str> = parse_raw_emoji_lexicon(RAW_EMOJI_LEXICON);
static ref STATIC_BUT: UniCase<&'static str> = UniCase::new("but");
static ref STATIC_THIS: UniCase<&'static str> = UniCase::new("this");
static ref STATIC_AT: UniCase<&'static str> = UniCase::new("at");
static ref STATIC_LEAST: UniCase<&'static str> = UniCase::new("least");
static ref STATIC_VERY: UniCase<&'static str> = UniCase::new("very");
static ref STATIC_WITHOUT: UniCase<&'static str> = UniCase::new("without");
static ref STATIC_DOUBT: UniCase<&'static str> = UniCase::new("doubt");
static ref STATIC_SO: UniCase<&'static str> = UniCase::new("so");
static ref STATIC_NEVER: UniCase<&'static str> = UniCase::new("never");
static ref STATIC_KIND: UniCase<&'static str> = UniCase::new("kind");
static ref STATIC_OF: UniCase<&'static str> = UniCase::new("of");
}
/**
* Takes the raw text of the lexicon files and creates HashMaps
**/
pub fn parse_raw_lexicon(raw_lexicon: &str) -> HashMap<UniCase<&str>, f64> {
let lines = raw_lexicon.trim_end_matches("\n").split("\n");
let mut lex_dict = HashMap::new();
for line in lines {
if line.is_empty() {
continue;
}
let mut split_line = line.split('\t');
let word = split_line.next().unwrap();
let val = split_line.next().unwrap();
lex_dict.insert(UniCase::new(word), val.parse().unwrap());
}
lex_dict
}
pub fn parse_raw_emoji_lexicon(raw_emoji_lexicon: &str) -> HashMap<&str, &str> {
let lines = raw_emoji_lexicon.trim_end_matches("\n").split("\n");
let mut emoji_dict = HashMap::new();
for line in lines {
if line.is_empty() {
continue;
}
let mut split_line = line.split('\t');
let word = split_line.next().unwrap();
let desc = split_line.next().unwrap();
emoji_dict.insert(word, desc);
}
emoji_dict
}
/**
* Stores tokens and useful info about text
**/
struct ParsedText<'a> {
tokens: Vec<UniCase<&'a str>>,
has_mixed_caps: bool,
punc_amplifier: f64,
}
impl<'a> ParsedText<'a> {
//Tokenizes and extracts useful properties of input text
fn from_text(text: &'a str) -> ParsedText {
let _tokens = ParsedText::tokenize(text);
let _has_mixed_caps = ParsedText::has_mixed_caps(&_tokens);
let _punc_amplifier = ParsedText::get_punctuation_emphasis(text);
ParsedText {
tokens: _tokens,
has_mixed_caps: _has_mixed_caps,
punc_amplifier: _punc_amplifier,
}
}
fn tokenize(text: &str) -> Vec<UniCase<&str>> {
let tokens = text.split_whitespace()
.filter(|s| s.len() > 1)
.map(|s| ParsedText::strip_punc_if_word(s))
.map(UniCase::new)
.collect();
tokens
}
// Removes punctuation from words, ie "hello!!!" -> "hello" and ",don't??" -> "don't"
// Keeps most emoticons, ie ":^)" -> ":^)"\
fn strip_punc_if_word(token: &str) -> &str {
let stripped = token.trim_matches(|c| PUNCTUATION.contains(c));
if stripped.len() <= 1 {
return token;
}
stripped
}
// Determines if message has a mix of both all caps and non all caps words
fn has_mixed_caps<S: AsRef<str>>(tokens: &[S]) -> bool {
let (mut has_caps, mut has_non_caps) = (false, false);
for token in tokens.iter() {
if is_all_caps(token.as_ref()) {
has_caps = true;
} else {
has_non_caps = true;
}
if has_non_caps && has_caps {
return true;
}
}
false
}
//uses empirical values to determine how the use of '?' and '!' contribute to sentiment
fn get_punctuation_emphasis(text: &str) -> f64 {
let emark_count: i32 = text.as_bytes().iter().filter(|b| **b == b'!').count() as i32;
let qmark_count: i32 = text.as_bytes().iter().filter(|b| **b == b'?').count() as i32;
let emark_emph = min(emark_count, MAX_EMARK) as f64 * EMARK_INCR;
let mut qmark_emph = (qmark_count as f64) * QMARK_INCR;
if qmark_count > MAX_QMARK {
qmark_emph = MAX_QMARK_INCR;
}
qmark_emph + emark_emph
}
}
//Checks if all letters in token are capitalized
fn is_all_caps<S: AsRef<str>>(token: S) -> bool {
let token_ref = token.as_ref();
ALL_CAPS_RE.is_match(token_ref) && token_ref.len() > 1
}
//Checks if token is in the list of NEGATION_SCALAR
fn is_negated(token: &UniCase<&str>) -> bool {
if NEGATION_TOKENS.contains(token) {
return true;
}
token.contains("n't")
}
//Normalizes score between -1.0 and 1.0. Alpha value is expected upper limit for a score
fn normalize_score(score: f64) -> f64 {
let norm_score = score / (score * score + NORMALIZATION_ALPHA).sqrt();
if norm_score < -1.0 {
return -1.0;
} else if norm_score > 1.0 {
return 1.0;
}
norm_score
}
//Checks how previous tokens affect the valence of the current token
fn scalar_inc_dec(token: &UniCase<&str>, valence: f64, has_mixed_caps: bool) -> f64 {
let mut scalar = 0.0;
if BOOSTER_DICT.contains_key(token) {
scalar = *BOOSTER_DICT.get(token).unwrap();
if valence < 0.0 {
scalar *= -1.0;
}
if is_all_caps(token) && has_mixed_caps {
if valence > 0.0 {
scalar += C_INCR;
} else {
scalar -= C_INCR;
}
}
}
scalar
}
fn sum_sentiment_scores(scores: Vec<f64>) -> (f64, f64, u32) {
let (mut pos_sum, mut neg_sum, mut neu_count) = (0f64, 0f64, 0);
for score in scores {
if score > 0f64 {
pos_sum += score + 1.0;
} else if score < 0f64 {
neg_sum += score - 1.0;
} else {
neu_count += 1;
}
}
(pos_sum, neg_sum, neu_count)
}
pub struct SentimentIntensityAnalyzer<'a> {
lexicon: &'a HashMap<UniCase<&'a str>, f64>,
emoji_lexicon: &'a HashMap<&'a str, &'a str>,
}
impl<'a> SentimentIntensityAnalyzer<'a> {
pub fn new() -> SentimentIntensityAnalyzer<'static>{
SentimentIntensityAnalyzer {
lexicon: &LEXICON,
emoji_lexicon: &EMOJI_LEXICON,
}
}
pub fn from_lexicon<'b>(_lexicon: &'b HashMap<UniCase<&str>, f64>) ->
SentimentIntensityAnalyzer<'b> {
SentimentIntensityAnalyzer {
lexicon: _lexicon,
emoji_lexicon: &EMOJI_LEXICON,
}
}
fn get_total_sentiment(&self, sentiments: Vec<f64>, punct_emph_amplifier: f64) -> HashMap<&str, f64> {
let (mut neg, mut neu, mut pos, mut compound) = (0f64, 0f64, 0f64, 0f64);
if sentiments.len() > 0 {
let mut total_sentiment: f64 = sentiments.iter().sum();
if total_sentiment > 0f64 {
total_sentiment += punct_emph_amplifier;
} else {
total_sentiment -= punct_emph_amplifier;
}
compound = normalize_score(total_sentiment);
let (mut pos_sum, mut neg_sum, neu_count) = sum_sentiment_scores(sentiments);
if pos_sum > neg_sum.abs() {
pos_sum += punct_emph_amplifier;
} else if pos_sum < neg_sum.abs() {
neg_sum -= punct_emph_amplifier;
}
let total = pos_sum + neg_sum.abs() + (neu_count as f64);
pos = (pos_sum / total).abs();
neg = (neg_sum / total).abs();
neu = (neu_count as f64 / total).abs();
}
let sentiment_dict = hashmap!["neg" => neg,
"neu" => neu,
"pos" => pos,
"compound" => compound];
sentiment_dict
}
pub fn polarity_scores(&self, text: &str) -> HashMap<&str, f64>{
let text = self.append_emoji_descriptions(text);
let parsedtext = ParsedText::from_text(&text);
let mut sentiments = Vec::new();
let tokens = &parsedtext.tokens;
for (i, word) in tokens.iter().enumerate() {
if BOOSTER_DICT.contains_key(word) {
sentiments.push(0f64);
} else if i < tokens.len() - 1 && word == &*STATIC_KIND
&& tokens[i + 1] == *STATIC_OF {
sentiments.push(0f64);
} else {
sentiments.push(self.sentiment_valence(&parsedtext, word, i));
}
}
but_check(tokens, &mut sentiments);
self.get_total_sentiment(sentiments, parsedtext.punc_amplifier)
}
//Removes emoji and appends their description to the end the input text
fn append_emoji_descriptions(&self, text: &str) -> String {
let mut result = String::new();
let mut prev_space = true;
for chr in text.chars() {
let chr_string = chr.to_string();
if let Some(chr_replacement) = self.emoji_lexicon.get(chr_string.as_str()) {
if !prev_space {
result.push(' ');
}
result.push_str(chr_replacement);
prev_space = false;
} else {
prev_space = chr == ' ';
result.push(chr);
}
}
result
}
fn sentiment_valence(&self, parsed: &ParsedText, word: &UniCase<&str>, i: usize) -> f64 {
let mut valence = 0f64;
let tokens = &parsed.tokens;
if let Some(word_valence) = self.lexicon.get(word) {
valence = *word_valence;
if is_all_caps(word) && parsed.has_mixed_caps {
if valence > 0f64 {
valence += C_INCR;
} else {
valence -= C_INCR
}
}
for start_i in 0..3 {
if i > start_i && !self.lexicon.contains_key(
&tokens[i - start_i - 1]) {
let mut s = scalar_inc_dec(&tokens[i - start_i - 1], valence, parsed.has_mixed_caps);
if start_i == 1 {
s *= 0.95;
} else if start_i == 2 {
s *= 0.9
}
valence += s;
valence = negation_check(valence, tokens, start_i, i);
if start_i == 2 {
valence = special_idioms_check(valence, tokens, i);
}
}
}
valence = least_check(valence, tokens, i);
}
valence
}
}
/**
* Check for specific patterns or tokens, and modify sentiment as needed
**/
fn negation_check(valence: f64, tokens: &[UniCase<&str>], start_i: usize, i: usize) -> f64 {
let mut valence = valence;
if start_i == 0 {
if is_negated(&tokens[i - start_i - 1]) {
valence *= NEGATION_SCALAR;
}
} else if start_i == 1 {
if tokens[i - 2] == *STATIC_NEVER &&
(tokens[i - 1] == *STATIC_SO ||
tokens[i - 1] == *STATIC_THIS) {
valence *= 1.25
} else if tokens[i - 2] == *STATIC_WITHOUT && tokens[i - 1] == *STATIC_DOUBT {
valence *= 1.0
} else if is_negated(&tokens[i - start_i - 1]) {
valence *= NEGATION_SCALAR;
}
} else if start_i == 2 {
if tokens[i - 3] == *STATIC_NEVER &&
tokens[i - 2] == *STATIC_SO || tokens[i - 2] == *STATIC_THIS||
tokens[i - 1] == *STATIC_SO || tokens[i - 1] == *STATIC_THIS {
valence *= 1.25
} else if tokens[i - 3] == *STATIC_WITHOUT &&
tokens[i - 2] == *STATIC_DOUBT ||
tokens[i - 1] == *STATIC_DOUBT {
valence *= 1.0;
} else if is_negated(&tokens[i - start_i - 1]) {
valence *= NEGATION_SCALAR;
}
}
valence
}
// If "but" is in the tokens, scales down the sentiment of words before "but" and
// adds more emphasis to the words after
fn but_check(tokens: &[UniCase<&str>], sentiments: &mut Vec<f64>) {
match tokens.iter().position(|&s| s == *STATIC_BUT) {
Some(but_index) => {
for i in 0..sentiments.len() {
if i < but_index {
sentiments[i] *= 0.5;
} else if i > but_index {
sentiments[i] *= 1.5;
}
}
},
None => return,
}
}
fn least_check(_valence: f64, tokens: &[UniCase<&str>], i: usize) -> f64 {
let mut valence = _valence;
if i > 1 && tokens[i - 1] == *STATIC_LEAST
&& tokens[i - 2] == *STATIC_AT
&& tokens[i - 2] == *STATIC_VERY {
valence *= NEGATION_SCALAR;
} else if i > 0 && tokens[i - 1] == *STATIC_LEAST {
valence *= NEGATION_SCALAR;
}
valence
}
// //This was present in the original python implementation, but unused
// fn idioms_check(valence: f64, text: &str) -> f64 {
// let mut total_valence = 0f64;
// let mut count = 0;
// for (idiom, val) in SENTIMENT_LADEN_IDIOMS.iter() {
// if text.contains(idiom) {
// total_valence += val;
// count += 1;
// }
// }
// if count > 0 {
// return total_valence / count as f64;
// }
// 0f64
// }
fn special_idioms_check(_valence: f64, tokens: &[UniCase<&str>], i: usize) -> f64 {
assert_eq!(i > 2, true);
let mut valence = _valence;
let mut end_i = i + 1;
//if i isn't the last index
if tokens.len() - 1 > i {
//make the end of the window 2 words ahead, or until the end of the tokens
end_i = min(i + 3, tokens.len());
}
// TODO: We can do this faster by comparing splits?
let target_window = tokens[(i - 3)..end_i].iter().map(|u| u.as_ref()).collect::<Vec<&str>>().join(" ").to_lowercase();
for (key, val) in SPECIAL_CASE_IDIOMS.iter() {
if target_window.contains(key.as_ref()) {
valence = *val;
break;
}
}
let prev_three = tokens[(i - 3)..i].iter().map(|u| u.as_ref()).collect::<Vec<&str>>().join(" ").to_lowercase();
for (key, val) in BOOSTER_DICT.iter() {
if prev_three.contains(key.as_ref()) {
valence += *val;
}
}
valence
}
pub mod demo;
|
use svd::gpio;
unsafe fn write_pin_cnf(number: u8, bits: u32) {
match number {
0 => gpio().pin_cnf0.write_bits(bits),
1 => gpio().pin_cnf1.write_bits(bits),
2 => gpio().pin_cnf2.write_bits(bits),
3 => gpio().pin_cnf3.write_bits(bits),
4 => gpio().pin_cnf4.write_bits(bits),
5 => gpio().pin_cnf5.write_bits(bits),
6 => gpio().pin_cnf6.write_bits(bits),
7 => gpio().pin_cnf7.write_bits(bits),
8 => gpio().pin_cnf8.write_bits(bits),
9 => gpio().pin_cnf9.write_bits(bits),
10 => gpio().pin_cnf10.write_bits(bits),
11 => gpio().pin_cnf11.write_bits(bits),
12 => gpio().pin_cnf12.write_bits(bits),
13 => gpio().pin_cnf13.write_bits(bits),
14 => gpio().pin_cnf14.write_bits(bits),
15 => gpio().pin_cnf15.write_bits(bits),
16 => gpio().pin_cnf16.write_bits(bits),
17 => gpio().pin_cnf17.write_bits(bits),
18 => gpio().pin_cnf18.write_bits(bits),
19 => gpio().pin_cnf19.write_bits(bits),
20 => gpio().pin_cnf20.write_bits(bits),
21 => gpio().pin_cnf21.write_bits(bits),
22 => gpio().pin_cnf22.write_bits(bits),
23 => gpio().pin_cnf23.write_bits(bits),
24 => gpio().pin_cnf24.write_bits(bits),
25 => gpio().pin_cnf25.write_bits(bits),
26 => gpio().pin_cnf26.write_bits(bits),
27 => gpio().pin_cnf27.write_bits(bits),
28 => gpio().pin_cnf28.write_bits(bits),
29 => gpio().pin_cnf29.write_bits(bits),
30 => gpio().pin_cnf30.write_bits(bits),
31 => gpio().pin_cnf31.write_bits(bits),
_ => unreachable!(),
}
}
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub struct PinNumber(pub u8);
impl PinNumber {
fn mask(&self) -> u32 {
1 << self.0
}
pub fn input_pullup(&self) {
unsafe {
write_pin_cnf(self.0, CONFIG_INPUT | CONFIG_PULLUP);
}
}
pub fn output_pullup(&self) {
unsafe {
write_pin_cnf(self.0, CONFIG_OUTPUT | CONFIG_PULLUP);
}
}
}
pub struct Pin {
mask: u32,
}
impl Pin {
pub fn output(number: PinNumber) -> Self {
unsafe {
write_pin_cnf(number.0, CONFIG_OUTPUT);
}
Pin { mask: number.mask() }
}
pub fn set_high(&self) {
unsafe {
gpio().outset.write_bits(self.mask);
}
}
pub fn set_low(&self) {
unsafe {
gpio().outclr.write_bits(self.mask);
}
}
}
const CONFIG_INPUT: u32 = 0 << 0;
const CONFIG_OUTPUT: u32 = 1 << 0;
const CONFIG_PULLUP: u32 = 3 << 2;
|
// example of trying to write a custom "safe-get" trait on Vec
trait SafeGetter<T> {
fn safe_get(&self, index: i32) -> Option<&T>;
}
impl <T> SafeGetter<T> for Vec<T> {
fn safe_get(&self, index: i32) -> Option<&T> {
if index < 0 {
None
} else {
self.get(index as usize)
}
}
}
fn main() {
let v = vec![1,2,3,4,5];
for i in -2..8 {
dbg!(&v.safe_get(i));
}
} |
// Copyright 2021 Datafuse Labs.
//
// 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.
use std::ops::Range;
use std::pin::Pin;
use std::task::Context;
use std::task::Poll;
use common_base::base::tokio::sync::mpsc::error::SendError;
use common_base::base::tokio::sync::mpsc::Receiver;
use common_base::rangemap::RangeMapKey;
use common_meta_types::protobuf::watch_request::FilterType;
use common_meta_types::protobuf::WatchResponse;
use futures::Stream;
use tonic::Status;
use super::WatcherId;
use super::WatcherSender;
use crate::watcher::EventDispatcherHandle;
/// Attributes of a watcher that is interested in kv change events.
#[derive(Clone, Debug)]
pub struct Watcher {
pub id: WatcherId,
/// Defines how to filter keys with `key_range`.
pub filter_type: FilterType,
/// The range of key this watcher is interested in.
pub key_range: Range<String>,
}
impl Watcher {
pub fn new(id: WatcherId, filter_type: FilterType, key_range: Range<String>) -> Self {
Self {
id,
filter_type,
key_range,
}
}
}
/// A handle of a watching stream, for feeding messages to the stream.
pub struct WatchStreamHandle {
pub watcher: Watcher,
tx: WatcherSender,
}
impl WatchStreamHandle {
pub fn new(watcher: Watcher, tx: WatcherSender) -> Self {
WatchStreamHandle { watcher, tx }
}
pub async fn send(
&self,
resp: WatchResponse,
) -> Result<(), SendError<Result<WatchResponse, Status>>> {
self.tx.send(Ok(resp)).await
}
}
/// A wrapper around [`tokio::sync::mpsc::Receiver`] that implements [`Stream`].
#[derive(Debug)]
pub struct WatchStream<T> {
inner: Receiver<T>,
watcher: Watcher,
dispatcher: EventDispatcherHandle,
}
impl<T> Drop for WatchStream<T> {
fn drop(&mut self) {
let rng = self.watcher.key_range.clone();
let id = self.watcher.id;
self.dispatcher.request(move |d| {
let key = RangeMapKey::new(rng, id);
d.remove_watcher(&key)
})
}
}
impl<T> WatchStream<T> {
/// Create a new `WatcherStream`.
pub fn new(rx: Receiver<T>, watcher: Watcher, dispatcher: EventDispatcherHandle) -> Self {
Self {
inner: rx,
watcher,
dispatcher,
}
}
/// Closes the receiving half of a channel without dropping it.
pub fn close(&mut self) {
self.inner.close()
}
}
impl<T> Stream for WatchStream<T> {
type Item = T;
fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
self.inner.poll_recv(cx)
}
}
impl<T> AsRef<Receiver<T>> for WatchStream<T> {
fn as_ref(&self) -> &Receiver<T> {
&self.inner
}
}
impl<T> AsMut<Receiver<T>> for WatchStream<T> {
fn as_mut(&mut self) -> &mut Receiver<T> {
&mut self.inner
}
}
|
use megadrile::{commands, config, error::Error};
fn evaluate_args() -> megadrile::Result<()> {
let arg_matches = config::get_cli_config();
if let (sub_name, Some(sub_matches)) = arg_matches.subcommand() {
match sub_name {
config::SUB_COMMAND_NAME_COUNTS => commands::print_counts(sub_matches),
config::SUB_COMMAND_NAME_LIST_VARIANTS => commands::write_list_of_variants(sub_matches),
config::SUB_COMMAND_NAME_LIST_SAMPLES => commands::write_list_of_samples(sub_matches),
config::SUB_COMMAND_NAME_MAF => commands::calculate_maf(sub_matches),
&_ => {
let message = format!("Unknown subcommand {}. Use '--help' to get list.", sub_name);
Err(Error::from(message))
}
}
} else {
Err(Error::from("Missing subcommand. Use '--help' to get list."))
}
}
fn main() {
if let Err(e) = evaluate_args() {
eprintln!("Error: {}", e)
} else {
println!("Done!");
}
}
|
mod dependencies;
mod post;
pub use dependencies::*;
pub use post::*;
|
//! embedded-gui
//! ============
//!
//! `embedded-gui` is an experimental `no_std`, `no_alloc`, cross-platform, composable Rust GUI
//! toolkit.
//!
//! `embedded-gui` consists of two parts: the main crate, and a platform-specific backend.
//! The main crate contains layout containers, composable base widgets, and the event handling
//! framework.
//! Backend crates define how each widget is rendered, and they may also contain custom widgets or
//! backend-specific extensions to the base widgets.
//!
//! Widgets
//! -------
//!
//! In an `embedded-gui` GUI, the most basic unit is called a widget. Widgets define behavior and/or
//! appearance. A GUI is defined as a tree of widgets. This means that widgets may either be leaf
//! widgets, wrapper widgets or layout containers. Wrapper widgets and layout containers contain
//! other widget(s).
//!
//! The set of widgets provided by `embedded-gui` are listed in the [`widgets`] module.
//!
//! Data binding
//! ------------
//!
//! `embedded-gui` widgets support a limited form of data binding. Data binding can be used to
//! connect widgets together or to pass data to the outside of the GUI.
//!
//! Widget states
//! -------------
//!
//! Some widgets define "states", which are used to communicate changes to the descendants of the
//! widget. For example, states can be used to change the border color of a button.
//!
//! States always propagate from the outside in, from a wrapper widget to the wrapped one.
//! Usually, when a widget defines it's own state, it will not propagate the parent's state further.
//!
//! Supported platforms
//! -------------------
//!
//! * `embedded-graphics`: [platform][embedded-graphics] - [backend][backend-embedded-graphics]
//!
//! [embedded-graphics]: https://github.com/embedded-graphics/embedded-graphics
//! [backend-embedded-graphics]: https://github.com/bugadani/embedded-gui/backend-embedded-graphics
#![no_std]
pub mod data;
pub mod geometry;
pub mod input;
pub mod state;
pub mod widgets;
use crate::{
geometry::{measurement::MeasureSpec, MeasuredSize, Position},
input::{
controller::{DefaultInputController, InputController},
event::InputEvent,
},
widgets::Widget,
};
pub mod prelude {
pub use crate::{
data::WidgetData,
widgets::{utils::wrapper::WrapperBindable, Widget},
WidgetRenderer, Window,
};
}
pub trait WidgetRenderer<C: Canvas> {
fn draw(&mut self, canvas: &mut C) -> Result<(), C::Error>;
}
pub trait Canvas {
type Error;
fn size(&self) -> MeasuredSize;
}
pub struct Window<C, W, I>
where
C: Canvas,
W: Widget + WidgetRenderer<C>,
I: InputController,
{
pub canvas: C,
pub root: W,
pub input_controller: I,
}
impl<C, W> Window<C, W, DefaultInputController>
where
C: Canvas,
W: Widget + WidgetRenderer<C>,
{
pub fn new(canvas: C, mut root: W) -> Self {
root.attach(0, 0);
Window {
canvas,
root,
input_controller: DefaultInputController::new(),
}
}
}
impl<C, W, I> Window<C, W, I>
where
C: Canvas,
W: Widget + WidgetRenderer<C>,
I: InputController,
{
pub fn with_input_controller<I2>(self, input_controller: I2) -> Window<C, W, I2>
where
I2: InputController,
{
Window {
canvas: self.canvas,
root: self.root,
input_controller,
}
}
pub fn update(&mut self) {
self.root.update();
}
pub fn measure(&mut self) {
self.root
.measure(MeasureSpec::from_measured_at_most(self.canvas.size()));
}
pub fn arrange(&mut self) {
self.root.arrange(Position { x: 0, y: 0 });
}
pub fn draw(&mut self) -> Result<(), C::Error> {
self.root.draw(&mut self.canvas)
}
pub fn input_event(&mut self, event: InputEvent) {
self.input_controller.input_event(&mut self.root, event);
}
}
|
pub const PIXEL_SIZE: f64 = 20.0;
#[derive(Clone)]
pub struct Pixel {
pub x_cord: i32,
pub y_cord: i32,
}
pub fn i32_to_f64(number: i32) -> f64 {
(number as f64) * PIXEL_SIZE
}
pub fn i32_to_u32(number: i32) -> u32 {
i32_to_f64(number) as u32
}
|
#[test]
fn fold_consumer_test() {
let str_col = [
"This ",
"text ",
"should ",
"be ",
"all ",
"together ",
":/",
];
let text = str_col.iter().fold(String::new(), |mut s, &w| {
s.push_str(w);
s
});
assert_eq!(text, "This text should be all together :/");
}
#[test]
fn fold_consumer_test_2() {
let nums = [0, 2, 3, 4, 5];
let inc_by = &2;
let result = nums.iter().fold(0, |mut prev, curr| {
prev += curr + inc_by;
prev
});
assert_eq!(result, 24);
}
|
#![feature(test)]
extern crate peg_syntax_ext;
use peg_syntax_ext::peg_file;
extern crate test;
use test::Bencher;
peg_file!(parser("json.rustpeg"));
#[bench]
fn json(b: &mut Bencher) {
let bench_str = r#"
{
"X": 0.6e2,
"Y": 5,
"Z": -5.312344,
"Bool": false,
"Bool": true,
"Null": null,
"Attr": {
"Name": "bla",
"Siblings": [6, 1, 2, {}, {}, {}]
},
"Nested Array": [[[[[[[[[]]]]]]]]],
"Obj": {
"Child": {
"A": [],
"Child": {
"Child": {}
}
}
}
}
"#;
b.bytes = bench_str.len() as u64;
b.iter(|| {
parser::json(bench_str).unwrap();
});
}
|
extern crate jlib;
use jlib::api::message::amount::Amount;
use jlib::api::create_offer::api::CreateOffer;
use jlib::api::create_offer::data::{OfferType, OfferCreateTxResponse, OfferCreateSideKick};
use jlib::api::config::Config;
pub static TEST_SERVER: &'static str = "ws://101.200.176.249:5040"; //dev12 国密服务器
fn main() {
let config = Config::new(TEST_SERVER, false);
//Sell
let offer_type = OfferType::Sell;
let taker_gets: Amount = Amount::new(Some( "CNY".to_string() ), "0.01".to_string(), Some( "j9syYwWgtmjchcbqhVB18pmFqXUYahZvvg".to_string() ));
let taker_pays: Amount = Amount::new(Some( "SWT".to_string() ), "1".to_string(), None);
//Buy
//let taker_gets: Amount = Amount::new(Some( "SWT".to_string() ), "1".to_string(), None);
//let taker_pays: Amount = Amount::new(Some( "CNY".to_string() ), "0.01".to_string(), Some("jHb9CJAWyB4jr91VRWn96DkukG4bwdtyTh".to_string()) );
let account: String = "j9syYwWgtmjchcbqhVB18pmFqXUYahZvvg".to_string();
let secret : String= "shstwqJpVJbsqFA5uYJJw1YniXcDF".to_string();
CreateOffer::with_params(config, account, secret).create_offer( offer_type, taker_gets, taker_pays,
|x| match x {
Ok(response) => {
let res: OfferCreateTxResponse = response;
// let fee = res.tx_json.fee.parse::<f32>().unwrap() / 1000000f32;
println!("挂单返回数据: {:#?}", res);
},
Err(e) => {
let err: OfferCreateSideKick = e;
println!("err: {:?}", err);
}
});
}
|
/*!
This document describes what changes are valid/invalid for a library using `abi_stable`,
Note that all of these only applies to types that implement `StableAbi`,
and are checked when loading the dynamic libraries using
the functions in `abi_stable::library::RootModule`.
Those dynamic libraries use the [`export_root_module`] attribute on some function
that export the root module
([a struct of function pointers and other nested modules](../prefix_types/index.html)).
# Semver in/compatible changes
These are the changes to pre-existing data structures that are
allowed/disallowed in semver compatible versions
(0.y.z < 0.(y+1).0 , x.y.z < (x+1).0.0).
It is never allowed to remove fields or variants in newer versions of a library.
Types cannot be renamed.
A type cannot be replaced with a `#[repr(transparent)]` types wrappig it.
If you rename a field,remember to use the `#[sabi(rename=the_old_name)]` attribute,
field names are part of the ABI of a type.
### Structs
It's only valid to add fields to structs if they are
[prefix types (vtables or modules)](../prefix_types/index.html),
and only after the last field.
### Exhaustive Enums
It is not possible to add variants or fields to exhaustive enums.
Exhaustive enums being ones that are declared like this:
```rust
use abi_stable::{std_types::RString, StableAbi};
#[repr(u8)]
#[derive(StableAbi)]
enum Exhaustive {
A,
B(RString),
C,
D { hello: u32, world: i64 },
}
# fn main(){}
```
### Non-exhaustive enums
It's possible to add variants with either:
- Field-less enums implemented as a struct wrapping an integer,
with associated constants as the variants.
- [Enums which use the
`#[sabi(kind(WithNonExhaustive())]` attribute
](../sabi_nonexhaustive/index.html),
wrapped inside `NonExhaustive<>`.
Neither one allow enums to change their size or alignment.
<br>
Example field-less enum implemented as a struct wrapping an integer:
```
use abi_stable::StableAbi;
#[repr(transparent)]
#[derive(StableAbi, Eq, PartialEq)]
pub struct Direction(u8);
impl Direction {
pub const LEFT: Self = Direction(0);
pub const RIGHT: Self = Direction(1);
pub const UP: Self = Direction(2);
pub const DOWN: Self = Direction(3);
}
# fn main(){}
```
### Unions
It's not possible to add fields to unions,this is not currently possible
because the original author of`abi_stable` didn't see any need for it
(if you need it create an issue for it).
# Semver in/compatible additions
It is always valid to declare new types in a library.
### Wrapping non-StableAbi types
You must be very careful when wrapping types which don't implement StableAbi
from external libraries,
since they might not guarantee any of these properties:
- Their size,alignment,representation attribute,layout in general.
- Their dependence on global state,
which could cause undefined behavior if passed between dynamic libraries,
or just be unpredictable.
The potential dependence on global state is why `abi_stable` uses dynamic dispatch
for all the types it wraps in `abi_stable::external_types`
# abi_stable specific
If you add StableAbi types to abi_stable,make sure to add them to the list of types in
`version_compatibility_interface::ManyTypes`
(the crate is in testing/version_compatibility/interface/)
[`export_root_module`]: crate::export_root_module
*/
|
use ::std::fmt;
use ::std::fmt::Display;
use ::rand::{thread_rng, Rng, sample};
use std::collections::{HashMap, HashSet};
lazy_static!{
// Create a HashMap of each fence edge that correlates the surrounding
// fences. By checking if both ends of a fence are occupied, we can
// guarentee we have a fence that is closed.
//
// For example: Fence 6 North:
// One end point has (1 West, 6 West, 5 North) and
// the other end point has (1 East, 6 east, 7 North)
//
// We can also leverage this mapping to randomly select a fence to place.
// Flatten the two endpoint vectors to have a vector of all possible
// surrounding fences and then randomly select one of those, ensures
// that the random fence structure is contiguous.
// static ref FENCE_MAP: HashMap<(&(usize, &str), &str> = {
static ref FENCE_MAP: HashMap<(usize, &'static str), (Vec<(usize, &'static str)>, Vec<(usize, &'static str)>)> = {
let mut adjacent_fences = HashMap::new();
adjacent_fences.insert((0, "north"), (vec!((0, "west")), vec!((0, "east"), (1, "north"))));
adjacent_fences.insert((1, "north"), (vec!((0, "north"), (1, "west")), vec!((1, "east"), (2, "north"))));
adjacent_fences.insert((2, "north"), (vec!((1, "north"), (2, "west")), vec!((2, "east"), (3, "north"))));
adjacent_fences.insert((3, "north"), (vec!((2, "north"), (3, "west")), vec!((3, "east"), (4, "north"))));
adjacent_fences.insert((4, "north"), (vec!((3, "north"), (4, "west")), vec!((4, "east"))));
adjacent_fences.insert((0, "west"), (vec!((0, "north")), vec!((0, "south"), (5, "west"))));
adjacent_fences.insert((0, "east"), (vec!((0, "north")), vec!((0, "south"), (1, "north"), (1, "south"), (5, "east"))));
adjacent_fences.insert((1, "east"), (vec!((1, "north")), vec!((1, "south"), (2, "north"), (2, "south"), (6, "east"))));
adjacent_fences.insert((2, "east"), (vec!((2, "north")), vec!((2, "south"), (3, "north"), (3, "south"), (7, "east"))));
adjacent_fences.insert((3, "east"), (vec!((3, "north")), vec!((3, "south"), (4, "north"), (4, "south"), (8, "east"))));
adjacent_fences.insert((4, "east"), (vec!((4, "north")), vec!((4, "south"), (9, "east"))));
adjacent_fences.insert((5, "north"), (vec!((0, "west"), (5, "west")), vec!((0, "east"), (5, "east"), (6, "north"))));
adjacent_fences.insert((6, "north"), (vec!((1, "west"), (6, "west"), (5, "north")), vec!((1, "east"), (6, "east"), (7, "north"))));
adjacent_fences.insert((7, "north"), (vec!((2, "west"), (7, "west"), (6, "north")), vec!((2, "east"), (7, "east"), (8, "north"))));
adjacent_fences.insert((8, "north"), (vec!((3, "west"), (8, "west"), (7, "north")), vec!((3, "east"), (8, "east"), (9, "north"))));
adjacent_fences.insert((9, "north"), (vec!((4, "west"), (8, "north"), (9, "west")), vec!((4, "east"), (9, "east"))));
adjacent_fences.insert((5, "west"), (vec!((5, "north"), (0, "west")), vec!((5, "south"), (10, "west"))));
adjacent_fences.insert((5, "east"), (vec!((5, "north"), (0, "east"), (6, "north")), vec!((5, "south"), (6, "south"), (10, "east"))));
adjacent_fences.insert((6, "east"), (vec!((6, "north"), (1, "east"), (7, "north")), vec!((6, "south"), (7, "south"), (11, "east"))));
adjacent_fences.insert((7, "east"), (vec!((7, "north"), (2, "east"), (8, "north")), vec!((7, "south"), (8, "south"), (12, "east"))));
adjacent_fences.insert((8, "east"), (vec!((8, "north"), (3, "east"), (9, "north")), vec!((8, "south"), (9, "south"), (13, "east"))));
adjacent_fences.insert((9, "east"), (vec!((9, "north"), (4, "east")), vec!((9, "south"), (14, "east"))));
adjacent_fences.insert((10, "north"), (vec!((5, "west"), (10, "west")), vec!((5, "east"), (10, "east"), (11, "north"))));
adjacent_fences.insert((11, "north"), (vec!((6, "west"), (11, "west"), (10, "north")), vec!((11, "east"), (6, "east"), (12, "north"))));
adjacent_fences.insert((12, "north"), (vec!((7, "west"), (12, "west"), (11, "north")), vec!((12, "east"), (7, "east"), (13, "north"))));
adjacent_fences.insert((13, "north"), (vec!((8, "west"), (13, "west"), (12, "north")), vec!((13, "east"), (8, "east"), (14, "north"))));
adjacent_fences.insert((14, "north"), (vec!((9, "west"), (14, "west"), (13, "north")), vec!((14, "east"), (9, "east"))));
adjacent_fences.insert((10, "west"), (vec!((10, "north"), (5, "west")), vec!((10, "south"))));
adjacent_fences.insert((10, "east"), (vec!((10, "north"), (11, "north"), (5, "east")), vec!((10, "south"), (11, "south"))));
adjacent_fences.insert((11, "east"), (vec!((11, "north"), (12, "north"), (6, "east")), vec!((11, "south"), (12, "south"))));
adjacent_fences.insert((12, "east"), (vec!((12, "north"), (13, "north"), (7, "east")), vec!((12, "south"), (13, "south"))));
adjacent_fences.insert((13, "east"), (vec!((13, "north"), (14, "north"), (8, "east")), vec!((13, "south"), (14, "south"))));
adjacent_fences.insert((14, "east"), (vec!((14, "north"), (9, "west")), vec!((14, "south"))));
adjacent_fences.insert((10, "south"), (vec!((10, "west")), vec!((10, "east"), (11, "south"))));
adjacent_fences.insert((11, "south"), (vec!((11, "west"), (10, "south")), vec!((11, "east"), (12, "south"))));
adjacent_fences.insert((12, "south"), (vec!((12, "west"), (11, "south")), vec!((12, "east"), (13, "south"))));
adjacent_fences.insert((13, "south"), (vec!((13, "west"), (12, "south")), vec!((13, "east"), (14, "south"))));
adjacent_fences.insert((14, "south"), (vec!((14, "west"), (13, "south")), vec!((14, "east"))));
adjacent_fences
};
}
#[derive(Debug, Clone)]
pub enum HouseType {
Wood,
Clay,
Stone
}
impl Display for HouseType {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
&HouseType::Wood => write!(f, "Wood "),
&HouseType::Clay => write!(f, "Clay "),
&HouseType::Stone => write!(f, "Stone"),
}
}
}
#[derive(Debug, Clone)]
pub enum Animal {
Sheep,
Boar,
Cattle
}
impl Display for Animal {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
&Animal::Sheep => write!(f, "Sheep "),
&Animal::Boar => write!(f, "Boar "),
&Animal::Cattle => write!(f, "Cattle"),
}
}
}
#[derive(Debug, Clone, PartialEq)]
pub enum Crop {
Grain,
Vegetable
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.