max_stars_count
int64 301
224k
| text
stringlengths 6
1.05M
| token_count
int64 3
727k
|
|---|---|---|
310 | <reponame>dreeves/usesthis
{
"name": "UltraFine 5K",
"description": "A 27 inch monitor.",
"url": "https://www.apple.com/shop/product/HKN62LL/A/lg-ultrafine-5k-display"
}
| 76 |
1,056 | <gh_stars>1000+
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.netbeans.modules.selenium2.webclient.protractor;
import java.io.File;
import java.util.Collection;
import java.util.Collections;
import java.util.prefs.PreferenceChangeEvent;
import java.util.prefs.PreferenceChangeListener;
import javax.swing.event.ChangeListener;
import org.netbeans.api.project.Project;
import org.netbeans.modules.selenium2.webclient.protractor.preferences.ProtractorPreferences;
import org.netbeans.modules.selenium2.webclient.protractor.preferences.ProtractorPreferencesValidator;
import org.netbeans.modules.web.common.api.ValidationResult;
import org.netbeans.modules.web.common.spi.ImportantFilesImplementation;
import org.netbeans.spi.project.ProjectServiceProvider;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileUtil;
import org.openide.util.ChangeSupport;
import org.openide.util.WeakListeners;
@ProjectServiceProvider(service = ImportantFilesImplementation.class, projectType = "org-netbeans-modules-web-clientproject") // NOI18N
public final class ImportantFilesImpl implements ImportantFilesImplementation, PreferenceChangeListener {
private final Project project;
private final ChangeSupport changeSupport = new ChangeSupport(this);
// @GuardedBy("this")
private boolean listening = false;
public ImportantFilesImpl(Project project) {
assert project != null;
this.project = project;
}
private synchronized void addListener(Project project) {
if (listening) {
return;
}
ProtractorPreferences.addPreferenceChangeListener(project, WeakListeners.create(PreferenceChangeListener.class, this, ProtractorPreferences.class));
listening = true;
}
@Override
public Collection<FileInfo> getFiles() {
addListener(project);
if (!ProtractorPreferences.isEnabled(project)) {
return Collections.emptyList();
}
String config = ProtractorPreferences.getUserConfigurationFile(project);
ValidationResult result = new ProtractorPreferencesValidator()
.validateUserConfigurationFile(project, config)
.getResult();
if (!result.isFaultless()) {
return Collections.emptyList();
}
FileObject file = FileUtil.toFileObject(new File(config));
assert file != null : config;
return Collections.singleton(new FileInfo(file));
}
@Override
public void addChangeListener(ChangeListener listener) {
changeSupport.addChangeListener(listener);
}
@Override
public void removeChangeListener(ChangeListener listener) {
changeSupport.removeChangeListener(listener);
}
@Override
public void preferenceChange(PreferenceChangeEvent evt) {
String key = evt.getKey();
if (ProtractorPreferences.ENABLED.equals(key)
|| ProtractorPreferences.USER_CONFIGURATION_FILE.equals(key)) {
changeSupport.fireChange();
}
}
}
| 1,237 |
1,056 | <filename>platform/core.windows/test/unit/src/org/netbeans/core/windows/view/ui/toolbars/ConfigureToolbarPanelTest.java
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.netbeans.core.windows.view.ui.toolbars;
import java.awt.Component;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.io.IOException;
import javax.swing.AbstractAction;
import javax.swing.Icon;
import org.netbeans.junit.NbTestCase;
import org.openide.cookies.InstanceCookie;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileUtil;
import org.openide.loaders.DataFolder;
import org.openide.loaders.InstanceDataObject;
import org.openide.nodes.Node;
import org.openide.util.HelpCtx;
import org.openide.util.actions.CallbackSystemAction;
public class ConfigureToolbarPanelTest extends NbTestCase {
private DataFolder folder;
private Node node;
public ConfigureToolbarPanelTest(String n) {
super(n);
}
@Override
protected void setUp() throws Exception {
clearWorkDir();
FileObject fo = FileUtil.toFileObject(getWorkDir());
folder = DataFolder.findFolder(fo);
node = ConfigureToolbarPanel.createFolderActionNode(folder);
}
public void testSystemActionWithNoIconResource() throws IOException {
InstanceDataObject.create(folder, null, NoIcon.class);
Node[] arr = node.getChildren().getNodes(true);
assertEquals("Action is not visible", 0, arr.length);
}
public void testActionDefinesSmallIcon() throws IOException, ClassNotFoundException {
InstanceDataObject.create(folder, null, SmallIcon.class);
Node[] arr = node.getChildren().getNodes(true);
assertEquals("Action is visible", 1, arr.length);
final InstanceCookie ic = arr[0].getLookup().lookup(InstanceCookie.class);
assertEquals("Right class", SmallIcon.class, ic.instanceClass());
}
public void testSubfolder() throws Exception {
DataFolder sub = DataFolder.findFolder(folder.getPrimaryFile().createFolder("sub"));
InstanceDataObject.create(sub, null, NoIcon.class);
InstanceDataObject.create(sub, null, SmallIcon.class);
Node[] arr = node.getChildren().getNodes(true);
assertEquals(1, arr.length);
arr = node.getChildren().getNodeAt(0).getChildren().getNodes(true);
assertEquals(1, arr.length);
}
public static final class NoIcon extends CallbackSystemAction {
@Override
public String getName() {
throw new UnsupportedOperationException("Not supported yet.");
}
@Override
public HelpCtx getHelpCtx() {
throw new UnsupportedOperationException("Not supported yet.");
}
}
public static final class SmallIcon extends AbstractAction implements Icon {
public SmallIcon() {
putValue(SMALL_ICON, this);
}
@Override
public void actionPerformed(ActionEvent e) {
throw new UnsupportedOperationException("Not supported yet.");
}
@Override
public void paintIcon(Component c, Graphics g, int x, int y) {
throw new UnsupportedOperationException("Not supported yet.");
}
@Override
public int getIconWidth() {
throw new UnsupportedOperationException("Not supported yet.");
}
@Override
public int getIconHeight() {
throw new UnsupportedOperationException("Not supported yet.");
}
} // end of SmallIcon
}
| 1,528 |
640 | extern void set1(void);
extern void set2(void);
__addressmod set1 nspace1;
__addressmod set2 nspace2;
extern nspace1 int *nspace2 x;
nspace1 int *y;
void function() {
*x = 2;
}
void function2() {
*y = 2;
}
nspace2 int z = 2;
void func3() {
z = 2;
}
| 123 |
335 | <gh_stars>100-1000
{
"word": "Trick",
"definitions": [
"Intended or used to deceive or mystify, or to create an illusion.",
"Liable to fail; defective."
],
"parts-of-speech": "Adjective"
} | 94 |
1,168 | /**
* The MIT License
* Copyright © 2010 JmxTrans team
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package com.googlecode.jmxtrans.model.naming;
import java.util.regex.Pattern;
public final class StringUtils {
private static final Pattern DOT_SLASH_UNDERSCORE_PAT = Pattern.compile("[./]");
private static final Pattern SLASH_UNDERSCORE_PAT = Pattern.compile("/", Pattern.LITERAL);
private static final Pattern SPACE_PAT = Pattern.compile("[ \"']+");
private StringUtils() {}
/**
* Replaces all . and / with _ and removes all spaces and double/single quotes.
*/
public static String cleanupStr(String name) {
return cleanupStr(name, false);
}
/**
* Replaces all . and / with _ and removes all spaces and double/single quotes.
* Chomps any trailing . or _ character.
*
* @param allowDottedKeys whether we remove the dots or not.
*/
public static String cleanupStr(String name, boolean allowDottedKeys) {
if (name == null) {
return null;
}
Pattern pattern;
if (!allowDottedKeys) {
pattern = DOT_SLASH_UNDERSCORE_PAT;
} else {
pattern = SLASH_UNDERSCORE_PAT;
}
String clean = pattern.matcher(name).replaceAll("_");
clean = SPACE_PAT.matcher(clean).replaceAll("");
clean = org.apache.commons.lang.StringUtils.chomp(clean, ".");
clean = org.apache.commons.lang.StringUtils.chomp(clean, "_");
return clean;
}
}
| 733 |
637 | <filename>core/src/main/java/jenkins/util/AntWithFindResourceClassLoader.java
package jenkins.util;
import org.apache.tools.ant.Project;
import java.io.Closeable;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.Field;
import java.net.URL;
import java.util.Collection;
import java.util.Enumeration;
import java.util.Vector;
/**
* As of 1.8.0, {@link org.apache.tools.ant.AntClassLoader} doesn't implement {@link #findResource(String)}
* in any meaningful way, which breaks fast lookup. Implement it properly.
*/
public class AntWithFindResourceClassLoader extends AntClassLoader implements Closeable {
private final Vector pathComponents;
public AntWithFindResourceClassLoader(ClassLoader parent, boolean parentFirst) {
super(parent, parentFirst);
try {
Field $pathComponents = AntClassLoader.class.getDeclaredField("pathComponents");
$pathComponents.setAccessible(true);
pathComponents = (Vector)$pathComponents.get(this);
} catch (NoSuchFieldException | IllegalAccessException e) {
throw new Error(e);
}
}
public void addPathFiles(Collection<File> paths) throws IOException {
for (File f : paths)
addPathFile(f);
}
public void close() throws IOException {
cleanup();
}
@Override
protected URL findResource(String name) {
URL url = null;
// try and load from this loader if the parent either didn't find
// it or wasn't consulted.
Enumeration e = pathComponents.elements();
while (e.hasMoreElements() && url == null) {
File pathComponent = (File) e.nextElement();
url = getResourceURL(pathComponent, name);
if (url != null) {
log("Resource " + name + " loaded from ant loader", Project.MSG_DEBUG);
}
}
return url;
}
}
| 727 |
6,036 | // Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
#pragma once
using ApiAttributeVariant = std::variant<
const DML_TENSOR_DESC*,
const DML_OPERATOR_DESC*,
UINT,
UINT64,
INT,
FLOAT,
const UINT*,
const INT*,
const FLOAT*,
const DML_SCALE_BIAS*,
DML_SIZE_2D,
DML_SCALAR_UNION
>;
namespace OperatorFieldTypes
{
using TensorDesc = std::optional<DmlBufferTensorDesc>; // DML_SCHEMA_FIELD_TYPE_TENSOR_DESC
using TensorDescArray = std::optional<std::vector<DmlBufferTensorDesc>>; // DML_SCHEMA_FIELD_TYPE_TENSOR_DESC_ARRAY
using OperatorDesc = std::optional<AbstractOperatorDesc>; // DML_SCHEMA_FIELD_TYPE_OPERATOR_DESC
using OperatorDescArray = std::optional<std::vector<AbstractOperatorDesc>>; // DML_SCHEMA_FIELD_TYPE_OPERATOR_DESC_ARRAY
using UInt = uint32_t; // DML_SCHEMA_FIELD_TYPE_UINT
using UInt64 = uint64_t; // DML_SCHEMA_FIELD_TYPE_UINT64
using Int = int32_t; // DML_SCHEMA_FIELD_TYPE_INT
using Float = float; // DML_SCHEMA_FIELD_TYPE_FLOAT
using UIntArray = std::optional<std::vector<uint32_t>>; // DML_SCHEMA_FIELD_TYPE_UINT_ARRAY
using IntArray = std::optional<std::vector<int32_t>>; // DML_SCHEMA_FIELD_TYPE_INT_ARRAY
using FloatArray = std::optional<std::vector<float>>; // DML_SCHEMA_FIELD_TYPE_FLOAT_ARRAY
using ScaleBias = std::optional<DML_SCALE_BIAS>; // DML_SCHEMA_FIELD_TYPE_SCALE_BIAS
using Size2D = DML_SIZE_2D; // DML_SCHEMA_FIELD_TYPE_SIZE_2D
using ScalarUnion = DML_SCALAR_UNION; // DML_SCHEMA_FIELD_TYPE_SCALAR_UNION
}
using OperatorFieldVariant = std::variant<
OperatorFieldTypes::TensorDesc,
OperatorFieldTypes::TensorDescArray,
OperatorFieldTypes::OperatorDesc,
OperatorFieldTypes::OperatorDescArray,
OperatorFieldTypes::UInt,
OperatorFieldTypes::UInt64,
OperatorFieldTypes::Int,
OperatorFieldTypes::Float,
OperatorFieldTypes::UIntArray,
OperatorFieldTypes::IntArray,
OperatorFieldTypes::FloatArray,
OperatorFieldTypes::ScaleBias,
OperatorFieldTypes::Size2D,
OperatorFieldTypes::ScalarUnion
>;
class OperatorField
{
public:
OperatorField() = default;
explicit OperatorField(const DML_SCHEMA_FIELD* schema, OperatorFieldVariant&& data)
: m_schema(schema)
, m_data(std::move(data))
{
assert(m_schema->Type == (DML_SCHEMA_FIELD_TYPE)m_data.index());
}
const DML_SCHEMA_FIELD* GetSchema() const
{
return m_schema;
}
const OperatorFieldVariant& GetData() const
{
return m_data;
}
const OperatorFieldTypes::TensorDesc& AsTensorDesc() const { return std::get<OperatorFieldTypes::TensorDesc>(m_data); }
OperatorFieldTypes::TensorDesc& AsTensorDesc() { return std::get<OperatorFieldTypes::TensorDesc>(m_data); }
const OperatorFieldTypes::TensorDescArray& AsTensorDescArray() const { return std::get<OperatorFieldTypes::TensorDescArray>(m_data); }
OperatorFieldTypes::TensorDescArray& AsTensorDescArray() { return std::get<OperatorFieldTypes::TensorDescArray>(m_data); }
const OperatorFieldTypes::OperatorDesc& AsOperatorDesc() const { return std::get<OperatorFieldTypes::OperatorDesc>(m_data); }
OperatorFieldTypes::OperatorDesc& AsOperatorDesc() { return std::get<OperatorFieldTypes::OperatorDesc>(m_data); }
const OperatorFieldTypes::OperatorDescArray& AsOperatorDescArray() const { return std::get<OperatorFieldTypes::OperatorDescArray>(m_data); }
OperatorFieldTypes::OperatorDescArray& AsOperatorDescArray() { return std::get<OperatorFieldTypes::OperatorDescArray>(m_data); }
const OperatorFieldTypes::UInt& AsUInt() const { return std::get<OperatorFieldTypes::UInt>(m_data); }
OperatorFieldTypes::UInt& AsUInt() { return std::get<OperatorFieldTypes::UInt>(m_data); }
const OperatorFieldTypes::UInt64& AsUInt64() const { return std::get<OperatorFieldTypes::UInt64>(m_data); }
OperatorFieldTypes::UInt64& AsUInt64() { return std::get<OperatorFieldTypes::UInt64>(m_data); }
const OperatorFieldTypes::Int& AsInt() const { return std::get<OperatorFieldTypes::Int>(m_data); }
OperatorFieldTypes::Int& AsInt() { return std::get<OperatorFieldTypes::Int>(m_data); }
const OperatorFieldTypes::Float& AsFloat() const { return std::get<OperatorFieldTypes::Float>(m_data); }
OperatorFieldTypes::Float& AsFloat() { return std::get<OperatorFieldTypes::Float>(m_data); }
const OperatorFieldTypes::UIntArray& AsUIntArray() const { return std::get<OperatorFieldTypes::UIntArray>(m_data); }
OperatorFieldTypes::UIntArray& AsUIntArray() { return std::get<OperatorFieldTypes::UIntArray>(m_data); }
const OperatorFieldTypes::IntArray& AsIntArray() const { return std::get<OperatorFieldTypes::IntArray>(m_data); }
OperatorFieldTypes::IntArray& AsIntArray() { return std::get<OperatorFieldTypes::IntArray>(m_data); }
const OperatorFieldTypes::FloatArray& AsFloatArray() const { return std::get<OperatorFieldTypes::FloatArray>(m_data); }
OperatorFieldTypes::FloatArray& AsFloatArray() { return std::get<OperatorFieldTypes::FloatArray>(m_data); }
const OperatorFieldTypes::ScaleBias& AsScaleBias() const { return std::get<OperatorFieldTypes::ScaleBias>(m_data); }
OperatorFieldTypes::ScaleBias& AsScaleBias() { return std::get<OperatorFieldTypes::ScaleBias>(m_data); }
const OperatorFieldTypes::Size2D& AsSize2D() const { return std::get<OperatorFieldTypes::Size2D>(m_data); }
OperatorFieldTypes::Size2D& AsSize2D() { return std::get<OperatorFieldTypes::Size2D>(m_data); }
const OperatorFieldTypes::ScalarUnion& AsScalarUnion() const { return std::get<OperatorFieldTypes::ScalarUnion>(m_data); }
OperatorFieldTypes::ScalarUnion& AsScalarUnion() { return std::get<OperatorFieldTypes::ScalarUnion>(m_data); }
private:
const DML_SCHEMA_FIELD* m_schema;
OperatorFieldVariant m_data;
};
| 2,168 |
689 | """Loss function for the DRAEM model implementation."""
# Copyright (C) 2022 Intel Corporation
# SPDX-License-Identifier: Apache-2.0
from kornia.losses import FocalLoss, SSIMLoss
from torch import nn
class DraemLoss(nn.Module):
"""Overall loss function of the DRAEM model.
The total loss consists of the sum of the L2 loss and Focal loss between the reconstructed image and the input
image, and the Structural Similarity loss between the predicted and GT anomaly masks.
"""
def __init__(self):
super().__init__()
self.l2_loss = nn.modules.loss.MSELoss()
self.focal_loss = FocalLoss(alpha=1, reduction="mean")
self.ssim_loss = SSIMLoss(window_size=11)
def forward(self, input_image, reconstruction, anomaly_mask, prediction):
"""Compute the loss over a batch for the DRAEM model."""
l2_loss_val = self.l2_loss(reconstruction, input_image)
focal_loss_val = self.focal_loss(prediction, anomaly_mask.squeeze(1).long())
ssim_loss_val = self.ssim_loss(reconstruction, input_image) * 2
return l2_loss_val + ssim_loss_val + focal_loss_val
| 419 |
1,338 | // NetAddress.h
#ifndef NET_FS_NET_ADDRESS_H
#define NET_FS_NET_ADDRESS_H
#ifdef HAIKU_TARGET_PLATFORM_BEOS
# include <socket.h>
#else
# include <netinet/in.h>
# include <sys/socket.h>
#endif
namespace BPrivate {
class HashString;
};
using BPrivate::HashString;
// NetAddress
class NetAddress {
public:
NetAddress();
NetAddress(const sockaddr_in& address);
NetAddress(const NetAddress& address);
void SetIP(int32 address);
int32 GetIP() const;
void SetPort(uint16 port);
uint16 GetPort() const;
void SetAddress(const sockaddr_in& address);
const sockaddr_in& GetAddress() const;
bool IsLocal() const;
status_t GetString(HashString* string,
bool includePort = true) const;
uint32 GetHashCode() const;
NetAddress& operator=(const NetAddress& address);
bool operator==(const NetAddress& address) const;
bool operator!=(const NetAddress& address) const;
private:
sockaddr_in fAddress;
};
// NetAddressResolver
class NetAddressResolver {
public:
NetAddressResolver();
~NetAddressResolver();
status_t InitCheck() const;
status_t GetHostAddress(const char* hostName,
NetAddress* address);
private:
class Resolver;
static void _Lock();
static void _Unlock();
Resolver* fResolver;
static Resolver* volatile sResolver;
static int32 sLockCounter;
};
#endif // NET_FS_NET_ADDRESS_H
| 614 |
369 | <gh_stars>100-1000
// Copyright (c) 2017-2021, Mudit<NAME>.o.o. All rights reserved.
// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
#include "QueryMultimediaFilesCount.hpp"
#include <string>
namespace db::multimedia_files::query
{
GetCount::GetCount() : Query(Query::Type::Read)
{}
GetCountResult::GetCountResult(unsigned count) : count(count)
{}
[[nodiscard]] auto GetCount::debugInfo() const -> std::string
{
return "GetCount";
}
[[nodiscard]] auto GetCountResult::debugInfo() const -> std::string
{
return "GetCountResult";
}
auto GetCountResult::getCount() const noexcept -> unsigned
{
return count;
}
GetCountArtists::GetCountArtists() : Query(Query::Type::Read)
{}
[[nodiscard]] auto GetCountArtists::debugInfo() const -> std::string
{
return "GetCountArtists";
}
GetCountAlbums::GetCountAlbums() : Query(Query::Type::Read)
{}
[[nodiscard]] auto GetCountAlbums::debugInfo() const -> std::string
{
return "GetCountAlbums";
}
GetCountForArtist::GetCountForArtist(const Artist &artist) : Query(Query::Type::Read), artist(artist)
{}
[[nodiscard]] auto GetCountForArtist::debugInfo() const -> std::string
{
return "GetCountForArtist";
}
GetCountForAlbum::GetCountForAlbum(const Album &album) : Query(Query::Type::Read), album(album)
{}
[[nodiscard]] auto GetCountForAlbum::debugInfo() const -> std::string
{
return "GetCountForAlbum";
}
} // namespace db::multimedia_files::query
| 619 |
1,192 | // RUN: %clang_cc1 -std=c++11 -fsyntax-only -Wno-nullability-declspec %s -verify
#if __has_feature(nullability)
#else
# error nullability feature should be defined
#endif
typedef decltype(nullptr) nullptr_t;
class X {
};
// Nullability applies to all pointer types.
typedef int (X::* _Nonnull member_function_type_1)(int);
typedef int X::* _Nonnull member_data_type_1;
typedef nullptr_t _Nonnull nonnull_nullptr_t; // expected-error{{nullability specifier '_Nonnull' cannot be applied to non-pointer type 'nullptr_t'}}
// Nullability can move into member pointers (this is suppressing a warning).
typedef _Nonnull int (X::* member_function_type_2)(int);
typedef int (X::* _Nonnull member_function_type_3)(int);
typedef _Nonnull int X::* member_data_type_2;
// Adding non-null via a template.
template<typename T>
struct AddNonNull {
typedef _Nonnull T type; // expected-error{{nullability specifier '_Nonnull' cannot be applied to non-pointer type 'int'}}
// expected-error@-1{{nullability specifier '_Nonnull' cannot be applied to non-pointer type 'nullptr_t'}}
};
typedef AddNonNull<int *>::type nonnull_int_ptr_1;
typedef AddNonNull<int * _Nullable>::type nonnull_int_ptr_2; // FIXME: check that it was overridden
typedef AddNonNull<nullptr_t>::type nonnull_int_ptr_3; // expected-note{{in instantiation of template class}}
typedef AddNonNull<int>::type nonnull_non_pointer_1; // expected-note{{in instantiation of template class 'AddNonNull<int>' requested here}}
// Non-null checking within a template.
template<typename T>
struct AddNonNull2 {
typedef _Nonnull AddNonNull<T> invalid1; // expected-error{{nullability specifier '_Nonnull' cannot be applied to non-pointer type 'AddNonNull<T>'}}
typedef _Nonnull AddNonNull2 invalid2; // expected-error{{nullability specifier '_Nonnull' cannot be applied to non-pointer type 'AddNonNull2<T>'}}
typedef _Nonnull AddNonNull2<T> invalid3; // expected-error{{nullability specifier '_Nonnull' cannot be applied to non-pointer type 'AddNonNull2<T>'}}
typedef _Nonnull typename AddNonNull<T>::type okay1;
// Don't move past a dependent type even if we know that nullability
// cannot apply to that specific dependent type.
typedef _Nonnull AddNonNull<T> (*invalid4); // expected-error{{nullability specifier '_Nonnull' cannot be applied to non-pointer type 'AddNonNull<T>'}}
};
// Check passing null to a _Nonnull argument.
void (*accepts_nonnull_1)(_Nonnull int *ptr);
void (*& accepts_nonnull_2)(_Nonnull int *ptr) = accepts_nonnull_1;
void (X::* accepts_nonnull_3)(_Nonnull int *ptr);
void accepts_nonnull_4(_Nonnull int *ptr);
void (&accepts_nonnull_5)(_Nonnull int *ptr) = accepts_nonnull_4;
void test_accepts_nonnull_null_pointer_literal(X *x) {
accepts_nonnull_1(0); // expected-warning{{null passed to a callee that requires a non-null argument}}
accepts_nonnull_2(0); // expected-warning{{null passed to a callee that requires a non-null argument}}
(x->*accepts_nonnull_3)(0); // expected-warning{{null passed to a callee that requires a non-null argument}}
accepts_nonnull_4(0); // expected-warning{{null passed to a callee that requires a non-null argument}}
accepts_nonnull_5(0); // expected-warning{{null passed to a callee that requires a non-null argument}}
}
template<void FP(_Nonnull int*)>
void test_accepts_nonnull_null_pointer_literal_template() {
FP(0); // expected-warning{{null passed to a callee that requires a non-null argument}}
}
template void test_accepts_nonnull_null_pointer_literal_template<&accepts_nonnull_4>(); // expected-note{{instantiation of function template specialization}}
| 1,171 |
2,151 | <filename>contracts/libc++/upstream/test/std/experimental/string.view/string.view.io/stream_insert.pass.cpp
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <string>
// template<class charT, class traits, class Allocator>
// basic_ostream<charT, traits>&
// operator<<(basic_ostream<charT, traits>& os,
// const basic_string_view<charT,traits> str);
#include <experimental/string_view>
#include <sstream>
#include <cassert>
using std::experimental::string_view;
using std::experimental::wstring_view;
int main()
{
{
std::ostringstream out;
string_view sv("some text");
out << sv;
assert(out.good());
assert(sv == out.str());
}
{
std::ostringstream out;
std::string s("some text");
string_view sv(s);
out.width(12);
out << sv;
assert(out.good());
assert(" " + s == out.str());
}
{
std::wostringstream out;
wstring_view sv(L"some text");
out << sv;
assert(out.good());
assert(sv == out.str());
}
{
std::wostringstream out;
std::wstring s(L"some text");
wstring_view sv(s);
out.width(12);
out << sv;
assert(out.good());
assert(L" " + s == out.str());
}
}
| 673 |
334 | <gh_stars>100-1000
/*
* This file is part of Sponge, licensed under the MIT License (MIT).
*
* Copyright (c) SpongePowered <https://www.spongepowered.org>
* Copyright (c) contributors
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package org.spongepowered.common.data.value;
import io.leangen.geantyref.GenericTypeReflector;
import org.spongepowered.api.data.Key;
import org.spongepowered.api.data.value.ListValue;
import org.spongepowered.api.data.value.MapValue;
import org.spongepowered.api.data.value.SetValue;
import org.spongepowered.api.data.value.Value;
import org.spongepowered.api.data.value.WeightedCollectionValue;
import org.spongepowered.api.util.weighted.WeightedTable;
import org.spongepowered.common.data.key.SpongeKey;
import java.util.List;
import java.util.Map;
import java.util.Set;
@SuppressWarnings({"unchecked", "rawtypes"})
public final class ValueConstructorFactory {
public static <V extends Value<E>, E> ValueConstructor<V, E> getConstructor(final SpongeKey<V, E> key) {
final Class<?> valueType = GenericTypeReflector.erase(key.valueType());
ValueConstructor<V, E> valueConstructor;
if (ListValue.class.isAssignableFrom(valueType)) {
valueConstructor = new SimpleValueConstructor(key,
(key1, value) -> new MutableSpongeListValue((Key<? extends ListValue>) key1, (List) value),
(key1, value) -> new ImmutableSpongeListValue((Key<? extends ListValue>) key1, (List) value));
} else if (SetValue.class.isAssignableFrom(valueType)) {
valueConstructor = new SimpleValueConstructor(key,
(key1, value) -> new MutableSpongeSetValue((Key<? extends SetValue>) key1, (Set) value),
(key1, value) -> new ImmutableSpongeSetValue((Key<? extends SetValue>) key1, (Set) value));
} else if (MapValue.class.isAssignableFrom(valueType)) {
valueConstructor = new SimpleValueConstructor(key,
(key1, value) -> new MutableSpongeMapValue((Key<? extends MapValue>) key1, (Map) value),
(key1, value) -> new ImmutableSpongeMapValue((Key<? extends MapValue>) key1, (Map) value));
} else if (WeightedCollectionValue.class.isAssignableFrom(valueType)) {
valueConstructor = new SimpleValueConstructor(key,
(key1, value) -> new MutableSpongeWeightedCollectionValue(
(Key<? extends WeightedCollectionValue>) key1, (WeightedTable) value),
(key1, value) -> new ImmutableSpongeWeightedCollectionValue(
(Key<? extends WeightedCollectionValue>) key1, (WeightedTable) value));
} else {
valueConstructor = new SimpleValueConstructor(key,
(key1, value) -> new MutableSpongeValue((Key<? extends Value>) key1, value),
(key1, value) -> new ImmutableSpongeValue((Key<? extends Value>) key1, value));
final Class<?> elementType = GenericTypeReflector.erase(key.elementType());
if (Enum.class.isAssignableFrom(elementType)) {
valueConstructor = new CachedEnumValueConstructor(valueConstructor, elementType);
} else if (elementType == Boolean.class) {
valueConstructor = (ValueConstructor<V, E>) new CachedBooleanValueConstructor(
(ValueConstructor<Value<Boolean>, Boolean>) valueConstructor);
}
}
return valueConstructor;
}
}
| 1,671 |
2,151 | <reponame>zipated/src
/**
* Copyright (C) 2014 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.hardware.soundtrigger;
import android.Manifest;
import android.content.Intent;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.content.pm.ResolveInfo;
import android.content.res.Resources;
import android.content.res.TypedArray;
import android.content.res.XmlResourceParser;
import android.service.voice.AlwaysOnHotwordDetector;
import android.text.TextUtils;
import android.util.ArraySet;
import android.util.AttributeSet;
import android.util.Slog;
import android.util.Xml;
import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;
import java.io.IOException;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
import java.util.Map;
/**
* Enrollment information about the different available keyphrases.
*
* @hide
*/
public class KeyphraseEnrollmentInfo {
private static final String TAG = "KeyphraseEnrollmentInfo";
/**
* Name under which a Hotword enrollment component publishes information about itself.
* This meta-data should reference an XML resource containing a
* <code><{@link
* android.R.styleable#VoiceEnrollmentApplication
* voice-enrollment-application}></code> tag.
*/
private static final String VOICE_KEYPHRASE_META_DATA = "android.voice_enrollment";
/**
* Activity Action: Show activity for managing the keyphrases for hotword detection.
* This needs to be defined by an activity that supports enrolling users for hotword/keyphrase
* detection.
*/
public static final String ACTION_MANAGE_VOICE_KEYPHRASES =
"com.android.intent.action.MANAGE_VOICE_KEYPHRASES";
/**
* Intent extra: The intent extra for the specific manage action that needs to be performed.
* Possible values are {@link AlwaysOnHotwordDetector#MANAGE_ACTION_ENROLL},
* {@link AlwaysOnHotwordDetector#MANAGE_ACTION_RE_ENROLL}
* or {@link AlwaysOnHotwordDetector#MANAGE_ACTION_UN_ENROLL}.
*/
public static final String EXTRA_VOICE_KEYPHRASE_ACTION =
"com.android.intent.extra.VOICE_KEYPHRASE_ACTION";
/**
* Intent extra: The hint text to be shown on the voice keyphrase management UI.
*/
public static final String EXTRA_VOICE_KEYPHRASE_HINT_TEXT =
"com.android.intent.extra.VOICE_KEYPHRASE_HINT_TEXT";
/**
* Intent extra: The voice locale to use while managing the keyphrase.
* This is a BCP-47 language tag.
*/
public static final String EXTRA_VOICE_KEYPHRASE_LOCALE =
"com.android.intent.extra.VOICE_KEYPHRASE_LOCALE";
/**
* List of available keyphrases.
*/
final private KeyphraseMetadata[] mKeyphrases;
/**
* Map between KeyphraseMetadata and the package name of the enrollment app that provides it.
*/
final private Map<KeyphraseMetadata, String> mKeyphrasePackageMap;
private String mParseError;
public KeyphraseEnrollmentInfo(PackageManager pm) {
// Find the apps that supports enrollment for hotword keyhphrases,
// Pick a privileged app and obtain the information about the supported keyphrases
// from its metadata.
List<ResolveInfo> ris = pm.queryIntentActivities(
new Intent(ACTION_MANAGE_VOICE_KEYPHRASES), PackageManager.MATCH_DEFAULT_ONLY);
if (ris == null || ris.isEmpty()) {
// No application capable of enrolling for voice keyphrases is present.
mParseError = "No enrollment applications found";
mKeyphrasePackageMap = Collections.<KeyphraseMetadata, String>emptyMap();
mKeyphrases = null;
return;
}
List<String> parseErrors = new LinkedList<String>();
mKeyphrasePackageMap = new HashMap<KeyphraseMetadata, String>();
for (ResolveInfo ri : ris) {
try {
ApplicationInfo ai = pm.getApplicationInfo(
ri.activityInfo.packageName, PackageManager.GET_META_DATA);
if ((ai.privateFlags & ApplicationInfo.PRIVATE_FLAG_PRIVILEGED) == 0) {
// The application isn't privileged (/system/priv-app).
// The enrollment application needs to be a privileged system app.
Slog.w(TAG, ai.packageName + "is not a privileged system app");
continue;
}
if (!Manifest.permission.MANAGE_VOICE_KEYPHRASES.equals(ai.permission)) {
// The application trying to manage keyphrases doesn't
// require the MANAGE_VOICE_KEYPHRASES permission.
Slog.w(TAG, ai.packageName + " does not require MANAGE_VOICE_KEYPHRASES");
continue;
}
mKeyphrasePackageMap.put(
getKeyphraseMetadataFromApplicationInfo(pm, ai, parseErrors),
ai.packageName);
} catch (PackageManager.NameNotFoundException e) {
String error = "error parsing voice enrollment meta-data for "
+ ri.activityInfo.packageName;
parseErrors.add(error + ": " + e);
Slog.w(TAG, error, e);
}
}
if (mKeyphrasePackageMap.isEmpty()) {
String error = "No suitable enrollment application found";
parseErrors.add(error);
Slog.w(TAG, error);
mKeyphrases = null;
} else {
mKeyphrases = mKeyphrasePackageMap.keySet().toArray(
new KeyphraseMetadata[mKeyphrasePackageMap.size()]);
}
if (!parseErrors.isEmpty()) {
mParseError = TextUtils.join("\n", parseErrors);
}
}
private KeyphraseMetadata getKeyphraseMetadataFromApplicationInfo(PackageManager pm,
ApplicationInfo ai, List<String> parseErrors) {
XmlResourceParser parser = null;
String packageName = ai.packageName;
KeyphraseMetadata keyphraseMetadata = null;
try {
parser = ai.loadXmlMetaData(pm, VOICE_KEYPHRASE_META_DATA);
if (parser == null) {
String error = "No " + VOICE_KEYPHRASE_META_DATA + " meta-data for " + packageName;
parseErrors.add(error);
Slog.w(TAG, error);
return null;
}
Resources res = pm.getResourcesForApplication(ai);
AttributeSet attrs = Xml.asAttributeSet(parser);
int type;
while ((type=parser.next()) != XmlPullParser.END_DOCUMENT
&& type != XmlPullParser.START_TAG) {
}
String nodeName = parser.getName();
if (!"voice-enrollment-application".equals(nodeName)) {
String error = "Meta-data does not start with voice-enrollment-application tag for "
+ packageName;
parseErrors.add(error);
Slog.w(TAG, error);
return null;
}
TypedArray array = res.obtainAttributes(attrs,
com.android.internal.R.styleable.VoiceEnrollmentApplication);
keyphraseMetadata = getKeyphraseFromTypedArray(array, packageName, parseErrors);
array.recycle();
} catch (XmlPullParserException e) {
String error = "Error parsing keyphrase enrollment meta-data for " + packageName;
parseErrors.add(error + ": " + e);
Slog.w(TAG, error, e);
} catch (IOException e) {
String error = "Error parsing keyphrase enrollment meta-data for " + packageName;
parseErrors.add(error + ": " + e);
Slog.w(TAG, error, e);
} catch (PackageManager.NameNotFoundException e) {
String error = "Error parsing keyphrase enrollment meta-data for " + packageName;
parseErrors.add(error + ": " + e);
Slog.w(TAG, error, e);
} finally {
if (parser != null) parser.close();
}
return keyphraseMetadata;
}
private KeyphraseMetadata getKeyphraseFromTypedArray(TypedArray array, String packageName,
List<String> parseErrors) {
// Get the keyphrase ID.
int searchKeyphraseId = array.getInt(
com.android.internal.R.styleable.VoiceEnrollmentApplication_searchKeyphraseId, -1);
if (searchKeyphraseId <= 0) {
String error = "No valid searchKeyphraseId specified in meta-data for " + packageName;
parseErrors.add(error);
Slog.w(TAG, error);
return null;
}
// Get the keyphrase text.
String searchKeyphrase = array.getString(
com.android.internal.R.styleable.VoiceEnrollmentApplication_searchKeyphrase);
if (searchKeyphrase == null) {
String error = "No valid searchKeyphrase specified in meta-data for " + packageName;
parseErrors.add(error);
Slog.w(TAG, error);
return null;
}
// Get the supported locales.
String searchKeyphraseSupportedLocales = array.getString(
com.android.internal.R.styleable
.VoiceEnrollmentApplication_searchKeyphraseSupportedLocales);
if (searchKeyphraseSupportedLocales == null) {
String error = "No valid searchKeyphraseSupportedLocales specified in meta-data for "
+ packageName;
parseErrors.add(error);
Slog.w(TAG, error);
return null;
}
ArraySet<Locale> locales = new ArraySet<>();
// Try adding locales if the locale string is non-empty.
if (!TextUtils.isEmpty(searchKeyphraseSupportedLocales)) {
try {
String[] supportedLocalesDelimited = searchKeyphraseSupportedLocales.split(",");
for (int i = 0; i < supportedLocalesDelimited.length; i++) {
locales.add(Locale.forLanguageTag(supportedLocalesDelimited[i]));
}
} catch (Exception ex) {
// We catch a generic exception here because we don't want the system service
// to be affected by a malformed metadata because invalid locales were specified
// by the system application.
String error = "Error reading searchKeyphraseSupportedLocales from meta-data for "
+ packageName;
parseErrors.add(error);
Slog.w(TAG, error);
return null;
}
}
// Get the supported recognition modes.
int recognitionModes = array.getInt(com.android.internal.R.styleable
.VoiceEnrollmentApplication_searchKeyphraseRecognitionFlags, -1);
if (recognitionModes < 0) {
String error = "No valid searchKeyphraseRecognitionFlags specified in meta-data for "
+ packageName;
parseErrors.add(error);
Slog.w(TAG, error);
return null;
}
return new KeyphraseMetadata(searchKeyphraseId, searchKeyphrase, locales, recognitionModes);
}
public String getParseError() {
return mParseError;
}
/**
* @return An array of available keyphrases that can be enrolled on the system.
* It may be null if no keyphrases can be enrolled.
*/
public KeyphraseMetadata[] listKeyphraseMetadata() {
return mKeyphrases;
}
/**
* Returns an intent to launch an activity that manages the given keyphrase
* for the locale.
*
* @param action The enrollment related action that this intent is supposed to perform.
* This can be one of {@link AlwaysOnHotwordDetector#MANAGE_ACTION_ENROLL},
* {@link AlwaysOnHotwordDetector#MANAGE_ACTION_RE_ENROLL}
* or {@link AlwaysOnHotwordDetector#MANAGE_ACTION_UN_ENROLL}
* @param keyphrase The keyphrase that the user needs to be enrolled to.
* @param locale The locale for which the enrollment needs to be performed.
* @return An {@link Intent} to manage the keyphrase. This can be null if managing the
* given keyphrase/locale combination isn't possible.
*/
public Intent getManageKeyphraseIntent(int action, String keyphrase, Locale locale) {
if (mKeyphrasePackageMap == null || mKeyphrasePackageMap.isEmpty()) {
Slog.w(TAG, "No enrollment application exists");
return null;
}
KeyphraseMetadata keyphraseMetadata = getKeyphraseMetadata(keyphrase, locale);
if (keyphraseMetadata != null) {
Intent intent = new Intent(ACTION_MANAGE_VOICE_KEYPHRASES)
.setPackage(mKeyphrasePackageMap.get(keyphraseMetadata))
.putExtra(EXTRA_VOICE_KEYPHRASE_HINT_TEXT, keyphrase)
.putExtra(EXTRA_VOICE_KEYPHRASE_LOCALE, locale.toLanguageTag())
.putExtra(EXTRA_VOICE_KEYPHRASE_ACTION, action);
return intent;
}
return null;
}
/**
* Gets the {@link KeyphraseMetadata} for the given keyphrase and locale, null if any metadata
* isn't available for the given combination.
*
* @param keyphrase The keyphrase that the user needs to be enrolled to.
* @param locale The locale for which the enrollment needs to be performed.
* This is a Java locale, for example "en_US".
* @return The metadata, if the enrollment client supports the given keyphrase
* and locale, null otherwise.
*/
public KeyphraseMetadata getKeyphraseMetadata(String keyphrase, Locale locale) {
if (mKeyphrases != null && mKeyphrases.length > 0) {
for (KeyphraseMetadata keyphraseMetadata : mKeyphrases) {
// Check if the given keyphrase is supported in the locale provided by
// the enrollment application.
if (keyphraseMetadata.supportsPhrase(keyphrase)
&& keyphraseMetadata.supportsLocale(locale)) {
return keyphraseMetadata;
}
}
}
Slog.w(TAG, "No Enrollment application supports the given keyphrase/locale");
return null;
}
@Override
public String toString() {
return "KeyphraseEnrollmentInfo [Keyphrases=" + mKeyphrasePackageMap.toString()
+ ", ParseError=" + mParseError + "]";
}
}
| 6,353 |
5,169 | <gh_stars>1000+
{
"name": "YouboraConfigUtils",
"version": "1.0.0",
"summary": "Set and get all available options to be sent to the back-end",
"description": "The framework contains a ViewController to be inserted in a container. With this view controller, you can set all the properties available\nto be sent to the back-end. This framework also saves in user defaults the modified values and get values to be used whenever the user wants.",
"homepage": "http://developer.nicepeopleatwork.com/",
"license": {
"type": "MIT",
"file": "LICENSE.md"
},
"authors": {
"Nice People at Work": "<EMAIL>"
},
"dependencies": {
"YouboraLib": [
]
},
"platforms": {
"ios": "9.0"
},
"swift_versions": [
"5.0",
"5.1"
],
"source": {
"git": "https://bitbucket.org/npaw/configutil-plugin-ios.git",
"tag": "1.0.0"
},
"source_files": "YouboraConfigUtils/**/*.{swift,h,m}",
"public_header_files": "YouboraConfigUtils/**/*.h",
"swift_version": "5.1"
}
| 386 |
1,068 | package com.forezp.banya.base;
import android.content.Context;
/**
* 公共View接口
*
* @author Ht
*/
public interface IBaseView {
/**
* 显示可取消的进度条
*
* @param message 要显示的信息
*/
void showProgress(String message);
/**
* 显示可取消的无文字进度条
*/
void showProgress();
/**
* 取消显示进度条
*/
void cancelProgress();
/**
* 根据资源文件id弹出toast
*
* @param resId 资源文件id
*/
void showTheToast(int resId);
/**
* 根据字符串弹出toast
*
* @param msg 提示内容
*/
void showTheToast(String msg);
/**
* 获取当前上下文对象
* @return
*/
Context getContext();
void onServerFail(String msg);
}
| 506 |
2,134 | <reponame>henricbjork2liu/binderhub
"""Exercise the binderhub entrypoint"""
from subprocess import check_output
import sys
import pytest
from traitlets import TraitError
from binderhub.app import BinderHub
from binderhub.repoproviders import (RepoProvider, GitLabRepoProvider, GitHubRepoProvider)
def test_help():
check_output([sys.executable, '-m', 'binderhub', '-h'])
def test_help_all():
check_output([sys.executable, '-m', 'binderhub', '--help-all'])
def test_repo_providers():
# Check that repo_providers property is validated by traitlets.validate
b = BinderHub()
class Provider(RepoProvider):
pass
# Setting providers that inherit from 'RepoProvider` should be allowed
b.repo_providers = dict(gh=GitHubRepoProvider, gl=GitLabRepoProvider)
b.repo_providers = dict(p=Provider)
class BadProvider():
pass
# Setting providers that don't inherit from 'RepoProvider` should raise an error
wrong_repo_providers = [GitHubRepoProvider, {}, 'GitHub', BadProvider]
for repo_providers in wrong_repo_providers:
with pytest.raises(TraitError):
b.repo_providers = repo_providers
| 424 |
568 | """
My module
=========
Provides
1. An array object of arbitrary homogeneous items
2. Fast mathematical operations over arrays
3. Linear Algebra, Fourier Transforms, Random Number Generation
How to use the documentation
----------------------------
Documentation is available in two forms: docstrings provided
with the code, and a loose standing reference guide, available from
`the NumPy homepage <http://www.scipy.org>`_.
We recommend exploring the docstrings using
`IPython <http://ipython.scipy.org>`_, an advanced Python shell with
TAB-completion and introspection capabilities. See below for further
instructions.
The docstring examples assume that `numpy` has been imported as `np`::
>>> import numpy as np
Code snippets are indicated by three greater-than signs::
>>> x = 42
>>> x = x + 1
Use the built-in ``help`` function to view a function's docstring::
>>> help(np.sort)
... # doctest: +SKIP
For some objects, ``np.info(obj)`` may provide additional help. This is
particularly true if you see the line "Help on ufunc object:" at the top
of the help() page. Ufuncs are implemented in C, not Python, for speed.
The native Python help() does not know how to view their help, but our
np.info() function does.
""" | 341 |
12,278 | <gh_stars>1000+
// (C) Copyright <NAME> 2001.
// Use, modification and distribution are subject to the
// Boost Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
// See http://www.boost.org/libs/config for most recent version.
// MACRO: BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS
// TITLE: non-deduced function template parameters
// DESCRIPTION: Can only use deduced template arguments when
// calling function template instantiations.
#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1200)
#error "This is known to be buggy under VC6"
#endif
namespace boost_no_explicit_function_template_arguments{
struct foo
{
template<class T> int bar(){return 0;}
template<int I> int bar(){return 1;}
};
int test_0()
{
return 0;
}
template <int i>
bool foo_17041(int j)
{
return (i == j);
}
int test()
{
foo f;
int a = f.bar<char>();
int b = f.bar<2>();
if((a !=0) || (b != 1))return -1;
if(0 == foo_17041<8>(8)) return -1;
if(0 == foo_17041<4>(4)) return -1;
if(0 == foo_17041<5>(5)) return -1;
return 0;
}
}
| 473 |
4,036 | <reponame>vadi2/codeql
class Super {
synchronized void quack() {
System.out.println("Quack.");
}
synchronized Super self() {
return this;
}
synchronized void foo() {}
void bar() {}
}
class Sub extends Super {
// NOT OK
void quack() {
super.quack();
super.quack();
}
// OK
Sub self() {
return (Sub)super.self();
}
// NOT OK
void foo() {
super.bar();
}
}
class A<T> {
synchronized void foo() {}
}
class B extends A<Integer> {
// NOT OK
void foo() {}
}
class C extends A<String> {
// NOT OK
void foo() {}
} | 234 |
1,104 | //
// Created by 庾金科 on 16/10/2017.
//
#ifndef SWIFTPR_PLATESEGMENTATION_H
#define SWIFTPR_PLATESEGMENTATION_H
#include "opencv2/opencv.hpp"
#include "opencv2/dnn.hpp"
#include "PlateInfo.h"
namespace pr{
class PlateSegmentation{
public:
const int PLATE_NORMAL = 6;
const int PLATE_NORMAL_GREEN = 7;
const int DEFAULT_WIDTH = 20;
PlateSegmentation(std::string phototxt,std::string caffemodel);
PlateSegmentation(){}
void segmentPlatePipline(PlateInfo &plateInfo,int stride,std::vector<cv::Rect> &Char_rects);
void segmentPlateBySlidingWindows(cv::Mat &plateImage,int windowsWidth,int stride,cv::Mat &respones);
void templateMatchFinding(const cv::Mat &respones,int windowsWidth,std::pair<float,std::vector<int>> &candidatePts);
void refineRegion(cv::Mat &plateImage,const std::vector<int> &candidatePts,const int padding,std::vector<cv::Rect> &rects);
void ExtractRegions(PlateInfo &plateInfo,std::vector<cv::Rect> &rects);
cv::Mat classifyResponse(const cv::Mat &cropped);
private:
cv::dnn::Net net;
// RefineRegion()
};
}//namespace pr
#endif //SWIFTPR_PLATESEGMENTATION_H
| 504 |
552 | <reponame>asheraryam/ETEngine<filename>Projects/Demo/source/Common/SpawnComponent.cpp<gh_stars>100-1000
#include "stdafx.h"
#include "SpawnComponent.h"
#include <EtCore/Reflection/Registration.h>
#include <EtCore/Content/ResourceManager.h>
#include <EtRendering/GraphicsTypes/Mesh.h>
#include <EtRendering/MaterialSystem/MaterialInstance.h>
#include <EtRendering/MaterialSystem/MaterialData.h>
namespace et {
namespace demo {
// reflection
//------------
RTTR_REGISTRATION
{
rttr::registration::class_<SpawnComponent>("spawn component");
BEGIN_REGISTER_CLASS(SpawnComponentDesc, "spawn comp desc")
.property("mesh", &SpawnComponentDesc::mesh)
.property("material", &SpawnComponentDesc::material)
.property("scale", &SpawnComponentDesc::scale)
.property("shape", &SpawnComponentDesc::shape)
.property("mass", &SpawnComponentDesc::mass)
.property("interval", &SpawnComponentDesc::interval)
.property("impulse", &SpawnComponentDesc::impulse)
END_REGISTER_CLASS_POLYMORPHIC(SpawnComponentDesc, fw::I_ComponentDescriptor);
}
DEFINE_FORCED_LINKING(SpawnComponentDesc) // force the linker to include this unit
ECS_REGISTER_COMPONENT(SpawnComponent);
//=================
// Spawn Component
//=================
//-----------------------
// SpawnComponent::c-tor
//
// load assets from ids
//
SpawnComponent::SpawnComponent(AssetPtr<render::MeshData> const meshPtr,
AssetPtr<render::I_Material> const materialPtr,
float const s,
btCollisionShape* const shape,
float const shapeMass,
float const interv,
float const imp
)
: collisionShape(shape)
, mass(shapeMass)
, scale(s)
, interval(interv)
, impulse(imp)
, mesh(meshPtr)
, material(materialPtr)
{ }
//============================
// Spawn Component Descriptor
//============================
//-----------------------------
// SpawnComponentDesc:: =
//
SpawnComponentDesc& SpawnComponentDesc::operator=(SpawnComponentDesc const& other)
{
mesh = other.mesh;
material = other.material;
scale = other.scale;
mass = other.mass;
interval = other.interval;
impulse = other.impulse;
delete shape;
shape = nullptr;
if (other.shape != nullptr)
{
shape = other.shape->Clone();
}
return *this;
}
//-------------------------------
// SpawnComponentDesc::c-tor
//
SpawnComponentDesc::SpawnComponentDesc(SpawnComponentDesc const& other)
{
*this = other;
}
//-------------------------------
// SpawnComponentDesc::d-tor
//
SpawnComponentDesc::~SpawnComponentDesc()
{
delete shape;
}
//------------------------------
// SpawnComponentDesc::MakeData
//
// Create a spawn component from a descriptor
//
SpawnComponent* SpawnComponentDesc::MakeData()
{
return new SpawnComponent(mesh, material, scale, shape->MakeBulletCollisionShape(), mass, interval, impulse);
}
} // namespace demo
} // namespace et
| 872 |
852 | <filename>RecoMET/METProducers/python/HcalHaloData_cfi.py
import FWCore.ParameterSet.Config as cms
# File: HcalHaloData_cfi.py
# Original Author: <NAME>, The University of Florida
# Description: Module to build HcalHaloData Object and put into the event
# Date: Oct. 15, 2009
HcalHaloData = cms.EDProducer("HcalHaloDataProducer",
# RecHit Level
EBRecHitLabel = cms.InputTag("ecalRecHit","EcalRecHitsEB"),
EERecHitLabel = cms.InputTag("ecalRecHit", "EcalRecHitsEE"),
HBHERecHitLabel = cms.InputTag("hbhereco"),
HORecHitLabel = cms.InputTag("horeco"),
HFRecHitLabel = cms.InputTag("hfreco"),
caloTowerCollName = cms.InputTag('towerMaker'),
HcalMinMatchingRadiusParam = cms.double(110.),
HcalMaxMatchingRadiusParam = cms.double(490.),
HBRecHitEnergyThresholdParam = cms.double(0.5),
HERecHitEnergyThresholdParam = cms.double(0.5),
SumHcalEnergyThresholdParam = cms.double(18),
NHitsHcalThresholdParam = cms.int32(4),
)
| 809 |
488 | #ifndef BASTMODEL_H
#define BASTMODEL_H
#include "ItemTreeModel.h"
class SgNode;
class AstFilterInterface;
/**
* \brief The Qt-Model representing a beautified AST
*/
class BAstModel : public ItemTreeModel
{
Q_OBJECT
public:
BAstModel(QObject * parent);
virtual ~BAstModel();
void setNode(SgNode * proj);
void setFilter(AstFilterInterface * filter);
SgNode * getNodeFromIndex(const QModelIndex & ind);
protected:
virtual QVariant data (const QModelIndex & ind, int role) const;
void updateModel();
AstFilterInterface * curFilter;
SgNode * curNode;
};
#endif
| 262 |
412 | /*******************************************************************\
Module:
Author: <NAME>, <EMAIL>
\*******************************************************************/
#include "java_class_loader.h"
#include <stack>
#include <util/message.h>
#include <util/suffix.h>
#include "java_class_loader_limit.h"
java_class_loadert::parse_tree_with_overlayst &java_class_loadert::
operator()(const irep_idt &class_name, message_handlert &message_handler)
{
messaget log(message_handler);
log.debug() << "Classpath:";
for(const auto &entry : classpath_entries)
{
log.debug() << "\n " << entry.path;
}
log.debug() << messaget::eom;
std::stack<irep_idt> queue;
// Always require java.lang.Object, as it is the base of
// internal classes such as array types.
queue.push("java.lang.Object");
// java.lang.String
queue.push("java.lang.String");
// add java.lang.Class
queue.push("java.lang.Class");
// Require java.lang.Throwable as the catch-type used for
// universal exception handlers:
queue.push("java.lang.Throwable");
queue.push(class_name);
// Require user provided classes to be loaded even without explicit reference
for(const auto &id : java_load_classes)
queue.push(id);
java_class_loader_limitt class_loader_limit(
message_handler, java_cp_include_files);
while(!queue.empty())
{
irep_idt c=queue.top();
queue.pop();
if(class_map.count(c) != 0)
continue;
log.debug() << "Reading class " << c << messaget::eom;
parse_tree_with_overlayst &parse_trees =
get_parse_tree(class_loader_limit, c, message_handler);
// Add any dependencies to queue
for(const java_bytecode_parse_treet &parse_tree : parse_trees)
for(const irep_idt &class_ref : parse_tree.class_refs)
queue.push(class_ref);
// Add any extra dependencies provided by our caller:
if(get_extra_class_refs)
{
for(const irep_idt &id : get_extra_class_refs(c))
queue.push(id);
}
}
return class_map.at(class_name);
}
/// Check if class is an overlay class by searching for `ID_overlay_class` in
/// its list of annotations.
///
/// An overlay class is a class with the annotation
/// \@OverlayClassImplementation. They serve the following purpose. When the JVM
/// searches the classpath for a particular class, it uses the first match,
/// and ignores any later matches. JBMC, however, will take account of later
/// matches as long as they are overlay classes. The
/// first match is then referred to as the underlying class. The
/// overlay classes can change the methods of the underlying class in the
/// following ways: adding a field (by having a new field), adding a method
/// (by having a new method) or
/// [changing the definition of a method](\ref java_bytecode_convert_classt::is_overlay_method).
/// It is an error if a method in an overlay class has the same signature as
/// a method in the underlying class and it isn't marked as an
/// [overlay method](\ref java_bytecode_convert_classt::is_overlay_method)
/// or an
/// [ignored method](\ref java_bytecode_convert_classt::is_ignored_method).
///
/// \param c: a `classt` object from a java bytecode parse tree
/// \return true if parsed class is an overlay class, else false
static bool is_overlay_class(const java_bytecode_parse_treet::classt &c)
{
return java_bytecode_parse_treet::find_annotation(
c.annotations, ID_overlay_class)
.has_value();
}
bool java_class_loadert::can_load_class(
const irep_idt &class_name,
message_handlert &message_handler)
{
for(const auto &cp_entry : classpath_entries)
{
auto parse_tree = load_class(class_name, cp_entry, message_handler);
if(parse_tree.has_value())
return true;
}
return false;
}
/// Check through all the places class parse trees can appear and returns the
/// first implementation it finds plus any overlay class implementations.
/// Uses \p class_loader_limit to limit the class files that it might (directly
/// or indirectly) load and returns a default-constructed parse tree when unable
/// to find the .class file.
/// \param class_loader_limit: Filter to decide whether to load classes
/// \param class_name: Name of class to load
/// \param message_handler: message handler
/// \return The list of valid implementations, including overlays
/// \remarks
/// Allows multiple definitions of the same class to appear on the
/// classpath, so long as all but the first definition are marked with the
/// attribute `\@java::org.cprover.OverlayClassImplementation`.
java_class_loadert::parse_tree_with_overlayst &
java_class_loadert::get_parse_tree(
java_class_loader_limitt &class_loader_limit,
const irep_idt &class_name,
message_handlert &message_handler)
{
parse_tree_with_overlayst &parse_trees = class_map[class_name];
PRECONDITION(parse_trees.empty());
messaget log(message_handler);
// do we refuse to load?
if(!class_loader_limit.load_class_file(class_name_to_jar_file(class_name)))
{
log.debug() << "not loading " << class_name << " because of limit"
<< messaget::eom;
parse_trees.emplace_back(class_name);
return parse_trees;
}
// Rummage through the class path
for(const auto &cp_entry : classpath_entries)
{
auto parse_tree = load_class(class_name, cp_entry, message_handler);
if(parse_tree.has_value())
parse_trees.emplace_back(std::move(*parse_tree));
}
auto parse_tree_it = parse_trees.begin();
// If the first class implementation is an overlay emit a warning and
// skip over it until we find a non-overlay class
while(parse_tree_it != parse_trees.end())
{
// Skip parse trees that failed to load - though these shouldn't exist yet
if(parse_tree_it->loading_successful)
{
if(!is_overlay_class(parse_tree_it->parsed_class))
{
// Keep the non-overlay class
++parse_tree_it;
break;
}
log.debug() << "Skipping class " << class_name
<< " marked with OverlayClassImplementation but found before"
" original definition"
<< messaget::eom;
}
auto unloaded_or_overlay_out_of_order_it = parse_tree_it;
++parse_tree_it;
parse_trees.erase(unloaded_or_overlay_out_of_order_it);
}
// Collect overlay classes
while(parse_tree_it != parse_trees.end())
{
// Remove non-initial classes that aren't overlays
if(!is_overlay_class(parse_tree_it->parsed_class))
{
log.debug() << "Skipping duplicate definition of class " << class_name
<< " not marked with OverlayClassImplementation"
<< messaget::eom;
auto duplicate_non_overlay_it = parse_tree_it;
++parse_tree_it;
parse_trees.erase(duplicate_non_overlay_it);
}
else
++parse_tree_it;
}
if(!parse_trees.empty())
return parse_trees;
// Not found or failed to load
log.debug() << "failed to load class " << class_name << messaget::eom;
parse_trees.emplace_back(class_name);
return parse_trees;
}
/// Load all class files from a .jar file
/// \param jar_path: the path for the .jar to load
/// \param message_handler: message handler
std::vector<irep_idt> java_class_loadert::load_entire_jar(
const std::string &jar_path,
message_handlert &message_handler)
{
auto classes = read_jar_file(jar_path, message_handler);
if(!classes.has_value())
return {};
classpath_entries.push_front(
classpath_entryt(classpath_entryt::JAR, jar_path));
for(const auto &c : *classes)
operator()(c, message_handler);
classpath_entries.pop_front();
return *classes;
}
optionalt<std::vector<irep_idt>> java_class_loadert::read_jar_file(
const std::string &jar_path,
message_handlert &message_handler)
{
messaget log(message_handler);
std::vector<std::string> filenames;
try
{
filenames = jar_pool(jar_path).filenames();
}
catch(const std::runtime_error &)
{
log.error() << "failed to open JAR file '" << jar_path << "'"
<< messaget::eom;
return {};
}
log.debug() << "Adding JAR file '" << jar_path << "'" << messaget::eom;
// Create a new entry in the map and initialize using the list of file names
// that are in jar_filet
std::vector<irep_idt> classes;
for(auto &file_name : filenames)
{
if(has_suffix(file_name, ".class"))
{
log.debug() << "Found class file " << file_name << " in JAR '" << jar_path
<< "'" << messaget::eom;
irep_idt class_name=file_to_class_name(file_name);
classes.push_back(class_name);
}
}
return classes;
}
| 3,093 |
1,664 | <reponame>likenamehaojie/Apache-Ambari-ZH<filename>ambari-server/src/main/java/org/apache/ambari/server/controller/internal/AbstractJDBCResourceProvider.java<gh_stars>1000+
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.ambari.server.controller.internal;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Map;
import java.util.Set;
import org.apache.ambari.server.controller.spi.Resource;
import org.apache.ambari.server.controller.spi.Resource.Type;
import org.apache.commons.lang.StringUtils;
/**
* Abstract resource provider implementation that contains helper methods for
* retrieving data from a result set.
*/
public abstract class AbstractJDBCResourceProvider<E extends Enum<E>> extends
AbstractResourceProvider {
private final Map<String,E> dbFields;
/**
* Create a new resource provider.
*
* @param propertyIds
* the property ids
* @param keyPropertyIds
* the key property ids
*/
protected AbstractJDBCResourceProvider(Set<String> propertyIds,
Map<Type,String> keyPropertyIds) {
super(propertyIds, keyPropertyIds);
this.dbFields = getDBFieldMap();
}
/**
* Gets a map from property ids to db fields.
*
* @return the map from property ids to db fields.
*/
protected abstract Map<String,E> getDBFieldMap();
/**
* Retrieves the db field corresponding to a property id from a result set as
* a string and sets the resulting string as a resource property.
*
* @param resource
* resource object to set the property on
* @param propertyId
* the property id to retrieve from the result set
* @param rs
* the result set
* @param requestedIds
* the requested ids
* @throws SQLException
* if property id cannot be retrieved from the result set
*/
protected void setString(Resource resource, String propertyId, ResultSet rs,
Set<String> requestedIds) throws SQLException {
if (requestedIds.contains(propertyId))
setResourceProperty(resource, propertyId,
rs.getString(dbFields.get(propertyId).toString()), requestedIds);
}
/**
* Retrieves the db field corresponding to a property id from a result set as
* an int and sets the resulting int as a resource property.
*
* @param resource
* resource object to set the property on
* @param propertyId
* the property id to retrieve from the result set
* @param rs
* the result set
* @param requestedIds
* the requested ids
* @throws SQLException
* if property id cannot be retrieved from the result set
*/
protected void setInt(Resource resource, String propertyId, ResultSet rs,
Set<String> requestedIds) throws SQLException {
if (requestedIds.contains(propertyId))
setResourceProperty(resource, propertyId,
rs.getInt(dbFields.get(propertyId).toString()), requestedIds);
}
/**
* Retrieves the db field corresponding to a property id from a result set as
* a long and sets the resulting long as a resource property.
*
* @param resource
* resource object to set the property on
* @param propertyId
* the property id to retrieve from the result set
* @param rs
* the result set
* @param requestedIds
* the requested ids
* @throws SQLException
* if property id cannot be retrieved from the result set
*/
protected void setLong(Resource resource, String propertyId, ResultSet rs,
Set<String> requestedIds) throws SQLException {
if (requestedIds.contains(propertyId))
setResourceProperty(resource, propertyId,
rs.getLong(dbFields.get(propertyId).toString()), requestedIds);
}
/**
* Gets a comma-separated list of db fields corresponding to set of requested
* ids.
*
* @param requestedIds
* the requested ids
* @return a comma-separated list of db fields
*/
protected String getDBFieldString(Set<String> requestedIds) {
String[] tmp = new String[requestedIds.size()];
int i = 0;
for (String s : requestedIds)
if (dbFields.containsKey(s))
tmp[i++] = dbFields.get(s).toString();
return StringUtils.join(tmp, ",", 0, i);
}
/**
* Gets a db field corresponding to a property id.
*
* @param propertyId
* the property id
* @return the db field enum value
*/
protected E getDBField(String propertyId) {
return dbFields.get(propertyId);
}
}
| 1,806 |
980 | <filename>src/main/java/org/jcodec/codecs/png/PNGConsts.java<gh_stars>100-1000
package org.jcodec.codecs.png;
public class PNGConsts {
static final long PNGSIG = 0x89504e470d0a1a0aL;
static final int PNGSIGhi = 0x89504e47;
static final int MNGSIGhi = 0x8a4d4e47;
static final int PNGSIGlo = 0x0d0a1a0a;
static final int MNGSIGlo = 0x0d0a1a0a;
static final int TAG_IHDR = 0x49484452;
static final int TAG_IDAT = 0x49444154;
static final int TAG_PLTE = 0x504c5445;
static final int TAG_tRNS = 0x74524e53;
static final int TAG_IEND = 0x49454e44;
}
| 270 |
852 | <filename>SimDataFormats/GeneratorProducts/src/GenFilterInfo.cc
#include <iostream>
#include <algorithm>
#include <utility>
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "SimDataFormats/GeneratorProducts/interface/GenFilterInfo.h"
using namespace edm;
using namespace std;
GenFilterInfo::GenFilterInfo()
: numPassPositiveEvents_(0),
numPassNegativeEvents_(0),
numTotalPositiveEvents_(0),
numTotalNegativeEvents_(0),
sumPassWeights_(0.),
sumPassWeights2_(0.),
sumTotalWeights_(0.),
sumTotalWeights2_(0.) {}
GenFilterInfo::GenFilterInfo(unsigned int tried, unsigned int pass)
: numPassPositiveEvents_(pass),
numPassNegativeEvents_(0),
numTotalPositiveEvents_(tried),
numTotalNegativeEvents_(0),
sumPassWeights_(pass),
sumPassWeights2_(pass),
sumTotalWeights_(tried),
sumTotalWeights2_(tried) {}
GenFilterInfo::GenFilterInfo(unsigned int passp,
unsigned int passn,
unsigned int totalp,
unsigned int totaln,
double passw,
double passw2,
double totalw,
double totalw2)
: numPassPositiveEvents_(passp),
numPassNegativeEvents_(passn),
numTotalPositiveEvents_(totalp),
numTotalNegativeEvents_(totaln),
sumPassWeights_(passw),
sumPassWeights2_(passw2),
sumTotalWeights_(totalw),
sumTotalWeights2_(totalw2) {}
GenFilterInfo::GenFilterInfo(const GenFilterInfo& other)
: numPassPositiveEvents_(other.numPassPositiveEvents_),
numPassNegativeEvents_(other.numPassNegativeEvents_),
numTotalPositiveEvents_(other.numTotalPositiveEvents_),
numTotalNegativeEvents_(other.numTotalNegativeEvents_),
sumPassWeights_(other.sumPassWeights_),
sumPassWeights2_(other.sumPassWeights2_),
sumTotalWeights_(other.sumTotalWeights_),
sumTotalWeights2_(other.sumTotalWeights2_) {}
GenFilterInfo::~GenFilterInfo() {}
bool GenFilterInfo::mergeProduct(GenFilterInfo const& other) {
// merging two GenFilterInfos means that the numerator and
// denominator from the original product need to besummed with
// those in the product we are going to merge
numPassPositiveEvents_ += other.numPassPositiveEvents_;
numPassNegativeEvents_ += other.numPassNegativeEvents_;
numTotalPositiveEvents_ += other.numTotalPositiveEvents_;
numTotalNegativeEvents_ += other.numTotalNegativeEvents_;
sumPassWeights_ += other.sumPassWeights_;
sumPassWeights2_ += other.sumPassWeights2_;
sumTotalWeights_ += other.sumTotalWeights_;
sumTotalWeights2_ += other.sumTotalWeights2_;
return true;
}
void GenFilterInfo::swap(GenFilterInfo& other) {
std::swap(numPassPositiveEvents_, other.numPassPositiveEvents_);
std::swap(numPassNegativeEvents_, other.numPassNegativeEvents_);
std::swap(numTotalPositiveEvents_, other.numTotalPositiveEvents_);
std::swap(numTotalNegativeEvents_, other.numTotalNegativeEvents_);
std::swap(sumPassWeights_, other.sumPassWeights_);
std::swap(sumPassWeights2_, other.sumPassWeights2_);
std::swap(sumTotalWeights_, other.sumTotalWeights_);
std::swap(sumTotalWeights2_, other.sumTotalWeights2_);
}
double GenFilterInfo::filterEfficiency(int idwtup) const {
double eff = -1;
switch (idwtup) {
case 3:
case -3:
eff = numEventsTotal() > 0 ? (double)numEventsPassed() / (double)numEventsTotal() : -1;
break;
default:
eff = sumWeights() > 0 ? sumPassWeights() / sumWeights() : -1;
break;
}
return eff;
}
double GenFilterInfo::filterEfficiencyError(int idwtup) const {
double efferr = -1;
switch (idwtup) {
case 3:
case -3: {
double effp =
numTotalPositiveEvents() > 0 ? (double)numPassPositiveEvents() / (double)numTotalPositiveEvents() : 0;
double effp_err2 = numTotalPositiveEvents() > 0 ? (1 - effp) * effp / (double)numTotalPositiveEvents() : 0;
double effn =
numTotalNegativeEvents() > 0 ? (double)numPassNegativeEvents() / (double)numTotalNegativeEvents() : 0;
double effn_err2 = numTotalNegativeEvents() > 0 ? (1 - effn) * effn / (double)numTotalNegativeEvents() : 0;
efferr = numEventsTotal() > 0
? sqrt(((double)numTotalPositiveEvents() * (double)numTotalPositiveEvents() * effp_err2 +
(double)numTotalNegativeEvents() * (double)numTotalNegativeEvents() * effn_err2) /
(double)numEventsTotal() / (double)numEventsTotal())
: -1;
break;
}
default: {
double denominator = sumWeights() * sumWeights() * sumWeights() * sumWeights();
double numerator = sumPassWeights2() * sumFailWeights() * sumFailWeights() +
sumFailWeights2() * sumPassWeights() * sumPassWeights();
efferr = denominator > 0 ? sqrt(numerator / denominator) : -1;
break;
}
}
return efferr;
}
| 2,062 |
441 | //
// Copyright (c) 2017-2020 the rbfx project.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//
#pragma once
#include "../Core/Object.h"
#include "../RenderPipeline/RenderBuffer.h"
#include "../RenderPipeline/RenderPipelineDefs.h"
namespace Urho3D
{
/// RenderPipeline used to render geometry buffer for lightmap baking.
class URHO3D_API LightmapRenderPipelineView
: public Object
, public RenderPipelineInterface
{
URHO3D_OBJECT(LightmapRenderPipelineView, Object);
public:
explicit LightmapRenderPipelineView(Context* context);
~LightmapRenderPipelineView() override;
/// Render geometry buffer. May be called only once.
void RenderGeometryBuffer(Viewport* viewport, int textureSize);
/// Return geometry buffer textures
/// @{
Texture2D* GetPositionBuffer() const { return positionBuffer_->GetTexture2D(); }
Texture2D* GetSmoothPositionBuffer() const { return smoothPositionBuffer_->GetTexture2D(); }
Texture2D* GetFaceNormalBuffer() const { return faceNormalBuffer_->GetTexture2D(); }
Texture2D* GetSmoothNormalBuffer() const { return smoothNormalBuffer_->GetTexture2D(); }
Texture2D* GetAlbedoBuffer() const { return albedoBuffer_->GetTexture2D(); }
Texture2D* GetEmissionBuffer() const { return emissionBuffer_->GetTexture2D(); }
/// @}
/// Implement RenderPipelineInterface
/// @{
Context* GetContext() const override { return BaseClassName::GetContext(); }
RenderPipelineDebugger* GetDebugger() override { return nullptr; }
/// @}
private:
SharedPtr<RenderBuffer> depthBuffer_;
SharedPtr<RenderBuffer> positionBuffer_;
SharedPtr<RenderBuffer> smoothPositionBuffer_;
SharedPtr<RenderBuffer> faceNormalBuffer_;
SharedPtr<RenderBuffer> smoothNormalBuffer_;
SharedPtr<RenderBuffer> albedoBuffer_;
SharedPtr<RenderBuffer> emissionBuffer_;
};
}
| 865 |
1,397 | from __future__ import unicode_literals
from __future__ import print_function
from __future__ import division
from __future__ import absolute_import
import SimpleITK as sitk
import tensorflow as tf
import os
import numpy as np
from dltk.io.augmentation import add_gaussian_noise, extract_random_example_array
from dltk.io.preprocessing import whitening
def read_fn(file_references, mode, params=None):
"""A custom python read function for interfacing with nii image files.
Args:
file_references (list): A list of lists containing file references,
such as [['id_0', 'image_filename_0', target_value_0], ...,
['id_N', 'image_filename_N', target_value_N]].
mode (str): One of the tf.estimator.ModeKeys strings: TRAIN, EVAL or
PREDICT.
params (dict, optional): A dictionary to parametrise read_fn outputs
(e.g. reader_params = {'n_examples': 10, 'example_size':
[64, 64, 64], 'extract_examples': True}, etc.).
Yields:
dict: A dictionary of reader outputs for dltk.io.abstract_reader.
"""
def _augment(img):
"""An image augmentation function"""
return add_gaussian_noise(img, sigma=0.1)
for f in file_references:
subject_id = f[0]
data_path = '../../../data/IXI_HH/1mm'
# Read the image nii with sitk
t1_fn = os.path.join(data_path, '{}/T1_1mm.nii.gz'.format(subject_id))
t2_fn = os.path.join(data_path, '{}/T2_1mm.nii.gz'.format(subject_id))
pd_fn = os.path.join(data_path, '{}/PD_1mm.nii.gz'.format(subject_id))
t1 = sitk.GetArrayFromImage(sitk.ReadImage(str(t1_fn)))
t2 = sitk.GetArrayFromImage(sitk.ReadImage(str(t2_fn)))
pd = sitk.GetArrayFromImage(sitk.ReadImage(str(pd_fn)))
# Normalise volume images
t1 = whitening(t1)
t2 = whitening(t2)
pd = whitening(pd)
# Create a 4D multi-sequence image (i.e. [x, y, z, channels])
images = np.stack([t1, t2, pd], axis=-1).astype(np.float32)
if mode == tf.estimator.ModeKeys.PREDICT:
yield {'features': {'x': images}}
# Augment if used in training mode
if mode == tf.estimator.ModeKeys.TRAIN:
images = _augment(images)
# Check if the reader is supposed to return training examples or full
# images
if params['extract_examples']:
images = extract_random_example_array(
image_list=images,
example_size=params['example_size'],
n_examples=params['n_examples'])
for e in range(params['n_examples']):
yield {'features': {'x': images[e].astype(np.float32)}}
else:
yield {'features': {'x': images}}
return
| 1,246 |
2,996 | // Copyright 2021 The Terasology Foundation
// SPDX-License-Identifier: Apache-2.0
package org.terasology.engine.core.modes.loadProcesses;
import org.terasology.engine.context.Context;
import org.terasology.engine.core.ComponentSystemManager;
import org.terasology.engine.core.modes.SingleStepLoadProcess;
import org.terasology.engine.entitySystem.entity.EntityManager;
import org.terasology.engine.entitySystem.entity.internal.EngineEntityManager;
import org.terasology.engine.entitySystem.metadata.EventLibrary;
import org.terasology.engine.network.NetworkSystem;
import org.terasology.engine.world.BlockEntityRegistry;
public class InitialiseSystems extends SingleStepLoadProcess {
private final Context context;
public InitialiseSystems(Context context) {
this.context = context;
}
@Override
public String getMessage() {
return "Initialising Systems...";
}
@Override
public boolean step() {
EngineEntityManager entityManager = (EngineEntityManager) context.get(EntityManager.class);
EventLibrary eventLibrary = context.get(EventLibrary.class);
BlockEntityRegistry blockEntityRegistry = context.get(BlockEntityRegistry.class);
context.get(NetworkSystem.class).connectToEntitySystem(entityManager, eventLibrary, blockEntityRegistry);
ComponentSystemManager csm = context.get(ComponentSystemManager.class);
csm.initialise();
return true;
}
@Override
public int getExpectedCost() {
return 1;
}
}
| 493 |
3,579 | package com.querydsl.apt.domain;
import static org.junit.Assert.assertNotNull;
import java.math.BigDecimal;
import org.joda.money.QMoney;
import org.junit.Test;
import com.querydsl.core.types.dsl.NumberExpression;
public class JodaMoneyTest {
@Test
public void test() {
NumberExpression<BigDecimal> sum = QMoney.money.sum();
assertNotNull(sum);
}
}
| 151 |
521 | <filename>src/elle/python/containers.hh<gh_stars>100-1000
#ifndef ELLE_PYTHON_CONTAINERS_HH
# define ELLE_PYTHON_CONTAINERS_HH
namespace elle
{
namespace python
{
/** Register conversion from python list to a container C that supports
* push_back.
*/
template<typename C>
void
container_from_python();
/// Register conversion from container C to a python list-like type.
template<typename C>
void
container_to_python();
/// Register conversion both ways for given container type.
template<typename C>
void
container();
}
}
#include <elle/python/containers.hxx>
#endif
| 231 |
452 | <gh_stars>100-1000
"""Run "python setup.py install" to install scandir."""
try:
from setuptools import setup, Extension
from setuptools.command.build_ext import build_ext as base_build_ext
except ImportError:
import warnings
import sys
val = sys.exc_info()[1]
warnings.warn("import of setuptools failed %r" % val)
from distutils.core import setup, Extension
from distutils.command.build_ext import build_ext as base_build_ext
import os
import re
import sys
import logging
# Get version without importing scandir because that will lock the
# .pyd file (if scandir is already installed) so it can't be
# overwritten during the install process
with open(os.path.join(os.path.dirname(__file__), 'scandir.py')) as f:
for line in f:
match = re.match(r"__version__.*'([0-9.]+)'", line)
if match:
version = match.group(1)
break
else:
raise Exception("Couldn't find version in setup.py")
with open('README.rst') as f:
long_description = f.read()
class BuildExt(base_build_ext):
# the extension is optional since in case of lack of c the api
# there is a ctypes fallback and a slow python fallback
def build_extension(self, ext):
try:
base_build_ext.build_extension(self, ext)
except Exception:
exception = sys.exc_info()[0]
logging.warn("building the %s failed with %s", ext.name, exception)
extension = Extension('_scandir', ['_scandir.c'], optional=True)
setup(
name='scandir',
version=version,
author='<NAME>',
author_email='<EMAIL>',
url='https://github.com/benhoyt/scandir',
license='New BSD License',
description='scandir, a better directory iterator and faster os.walk()',
long_description=long_description,
py_modules=['scandir'],
ext_modules=[extension],
classifiers=[
'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'Operating System :: OS Independent',
'License :: OSI Approved :: BSD License',
'Programming Language :: Python',
'Topic :: System :: Filesystems',
'Topic :: System :: Operating System',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: 3.7',
'Programming Language :: Python :: Implementation :: CPython',
], cmdclass={'build_ext': BuildExt},
)
| 1,011 |
2,151 | <reponame>MauroArgentino/RSXGL
/**************************************************************************
*
* Copyright 2009, VMware, Inc.
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sub license, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice (including the
* next paragraph) shall be included in all copies or substantial portions
* of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
* IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
**************************************************************************/
/*
* Author: <NAME> <<EMAIL>>
* Author: <NAME> <<EMAIL>>
*/
#include "utils.h"
#include "dri_screen.h"
#include "dri_drawable.h"
#include "dri_context.h"
#include "state_tracker/drm_driver.h"
#include "pipe/p_context.h"
#include "state_tracker/st_context.h"
static void
dri_pp_query(struct dri_context *ctx)
{
unsigned int i;
for (i = 0; i < PP_FILTERS; i++) {
ctx->pp_enabled[i] = driQueryOptioni(&ctx->optionCache, pp_filters[i].name);
}
}
static void dri_fill_st_options(struct st_config_options *options,
const struct driOptionCache * optionCache)
{
options->force_glsl_extensions_warn =
driQueryOptionb(optionCache, "force_glsl_extensions_warn");
}
GLboolean
dri_create_context(gl_api api, const struct gl_config * visual,
__DRIcontext * cPriv,
unsigned major_version,
unsigned minor_version,
uint32_t flags,
unsigned *error,
void *sharedContextPrivate)
{
__DRIscreen *sPriv = cPriv->driScreenPriv;
struct dri_screen *screen = dri_screen(sPriv);
struct st_api *stapi = screen->st_api;
struct dri_context *ctx = NULL;
struct st_context_iface *st_share = NULL;
struct st_context_attribs attribs;
enum st_context_error ctx_err = 0;
memset(&attribs, 0, sizeof(attribs));
switch (api) {
case API_OPENGLES:
attribs.profile = ST_PROFILE_OPENGL_ES1;
break;
case API_OPENGLES2:
attribs.profile = ST_PROFILE_OPENGL_ES2;
break;
case API_OPENGL:
attribs.profile = ST_PROFILE_DEFAULT;
attribs.major = major_version;
attribs.minor = minor_version;
if ((flags & __DRI_CTX_FLAG_DEBUG) != 0)
attribs.flags |= ST_CONTEXT_FLAG_DEBUG;
if ((flags & __DRI_CTX_FLAG_FORWARD_COMPATIBLE) != 0)
attribs.flags |= ST_CONTEXT_FLAG_FORWARD_COMPATIBLE;
break;
default:
*error = __DRI_CTX_ERROR_BAD_API;
goto fail;
}
if (sharedContextPrivate) {
st_share = ((struct dri_context *)sharedContextPrivate)->st;
}
ctx = CALLOC_STRUCT(dri_context);
if (ctx == NULL) {
*error = __DRI_CTX_ERROR_NO_MEMORY;
goto fail;
}
cPriv->driverPrivate = ctx;
ctx->cPriv = cPriv;
ctx->sPriv = sPriv;
driParseConfigFiles(&ctx->optionCache,
&screen->optionCache, sPriv->myNum, driver_descriptor.name);
dri_fill_st_options(&attribs.options, &ctx->optionCache);
dri_fill_st_visual(&attribs.visual, screen, visual);
ctx->st = stapi->create_context(stapi, &screen->base, &attribs, &ctx_err,
st_share);
if (ctx->st == NULL) {
switch (ctx_err) {
case ST_CONTEXT_SUCCESS:
*error = __DRI_CTX_ERROR_SUCCESS;
break;
case ST_CONTEXT_ERROR_NO_MEMORY:
*error = __DRI_CTX_ERROR_NO_MEMORY;
break;
case ST_CONTEXT_ERROR_BAD_API:
*error = __DRI_CTX_ERROR_BAD_API;
break;
case ST_CONTEXT_ERROR_BAD_VERSION:
*error = __DRI_CTX_ERROR_BAD_VERSION;
break;
case ST_CONTEXT_ERROR_BAD_FLAG:
*error = __DRI_CTX_ERROR_BAD_FLAG;
break;
case ST_CONTEXT_ERROR_UNKNOWN_ATTRIBUTE:
*error = __DRI_CTX_ERROR_UNKNOWN_ATTRIBUTE;
break;
case ST_CONTEXT_ERROR_UNKNOWN_FLAG:
*error = __DRI_CTX_ERROR_UNKNOWN_FLAG;
break;
}
goto fail;
}
ctx->st->st_manager_private = (void *) ctx;
ctx->stapi = stapi;
// Context successfully created. See if post-processing is requested.
dri_pp_query(ctx);
ctx->pp = pp_init(screen->base.screen, ctx->pp_enabled);
*error = __DRI_CTX_ERROR_SUCCESS;
return GL_TRUE;
fail:
if (ctx && ctx->st)
ctx->st->destroy(ctx->st);
FREE(ctx);
return GL_FALSE;
}
void
dri_destroy_context(__DRIcontext * cPriv)
{
struct dri_context *ctx = dri_context(cPriv);
/* note: we are freeing values and nothing more because
* driParseConfigFiles allocated values only - the rest
* is owned by screen optionCache.
*/
FREE(ctx->optionCache.values);
/* No particular reason to wait for command completion before
* destroying a context, but we flush the context here
* to avoid having to add code elsewhere to cope with flushing a
* partially destroyed context.
*/
ctx->st->flush(ctx->st, 0, NULL);
ctx->st->destroy(ctx->st);
if (ctx->pp) pp_free(ctx->pp);
FREE(ctx);
}
GLboolean
dri_unbind_context(__DRIcontext * cPriv)
{
/* dri_util.c ensures cPriv is not null */
struct dri_screen *screen = dri_screen(cPriv->driScreenPriv);
struct dri_context *ctx = dri_context(cPriv);
struct st_api *stapi = screen->st_api;
if (--ctx->bind_count == 0) {
if (ctx->st == ctx->stapi->get_current(ctx->stapi)) {
/* For conformance, unbind is supposed to flush the context.
* However, if we do it here we might end up flushing a partially
* destroyed context. Instead, we flush in dri_make_current and
* in dri_destroy_context which should cover all the cases.
*/
stapi->make_current(stapi, NULL, NULL, NULL);
}
}
return GL_TRUE;
}
GLboolean
dri_make_current(__DRIcontext * cPriv,
__DRIdrawable * driDrawPriv,
__DRIdrawable * driReadPriv)
{
/* dri_util.c ensures cPriv is not null */
struct dri_context *ctx = dri_context(cPriv);
struct dri_drawable *draw = dri_drawable(driDrawPriv);
struct dri_drawable *read = dri_drawable(driReadPriv);
struct st_context_iface *old_st = ctx->stapi->get_current(ctx->stapi);
/* Flush the old context here so we don't have to flush on unbind() */
if (old_st && old_st != ctx->st)
old_st->flush(old_st, ST_FLUSH_FRONT, NULL);
++ctx->bind_count;
if (!driDrawPriv && !driReadPriv)
return ctx->stapi->make_current(ctx->stapi, ctx->st, NULL, NULL);
else if (!driDrawPriv || !driReadPriv)
return GL_FALSE;
if (ctx->dPriv != driDrawPriv) {
ctx->dPriv = driDrawPriv;
draw->texture_stamp = driDrawPriv->lastStamp - 1;
}
if (ctx->rPriv != driReadPriv) {
ctx->rPriv = driReadPriv;
read->texture_stamp = driReadPriv->lastStamp - 1;
}
ctx->stapi->make_current(ctx->stapi, ctx->st, &draw->base, &read->base);
// This is ok to call here. If they are already init, it's a no-op.
if (draw->textures[ST_ATTACHMENT_BACK_LEFT] && draw->textures[ST_ATTACHMENT_DEPTH_STENCIL]
&& ctx->pp)
pp_init_fbos(ctx->pp, draw->textures[ST_ATTACHMENT_BACK_LEFT]->width0,
draw->textures[ST_ATTACHMENT_BACK_LEFT]->height0);
return GL_TRUE;
}
struct dri_context *
dri_get_current(__DRIscreen *sPriv)
{
struct dri_screen *screen = dri_screen(sPriv);
struct st_api *stapi = screen->st_api;
struct st_context_iface *st;
st = stapi->get_current(stapi);
return (struct dri_context *) (st) ? st->st_manager_private : NULL;
}
/* vim: set sw=3 ts=8 sts=3 expandtab: */
| 3,175 |
5,169 | {
"name": "TESTSDK0818",
"version": "0.0.1",
"summary": "这是一个测试库",
"description": "此版本SDK说明文字，自己根据实际书写",
"homepage": "https://github.com/goattester/TESTSDK",
"authors": {
"linsheng": "<EMAIL>"
},
"source": {
"git": "https://github.com/goattester/TESTSDK.git",
"tag": "0.0.1"
},
"source_files": "GOAT_LIB/Goat/**",
"platforms": {
"osx": null,
"ios": null,
"tvos": null,
"watchos": null
}
}
| 248 |
1,374 | package def.dom;
public class SVGPathSegCurvetoQuadraticRel extends SVGPathSeg {
public double x;
public double x1;
public double y;
public double y1;
public static SVGPathSegCurvetoQuadraticRel prototype;
public SVGPathSegCurvetoQuadraticRel(){}
}
| 95 |
2,260 | // Autogenerated by gameplay-luagen
#include "Base.h"
#include "ScriptController.h"
#include "lua_PhysicsCollisionObject.h"
#include "Base.h"
#include "Game.h"
#include "Node.h"
#include "PhysicsCharacter.h"
#include "PhysicsCollisionObject.h"
#include "PhysicsController.h"
#include "PhysicsGhostObject.h"
#include "PhysicsRigidBody.h"
#include "PhysicsVehicle.h"
#include "PhysicsVehicleWheel.h"
#include "ScriptController.h"
#include "PhysicsGhostObject.h"
#include "PhysicsRigidBody.h"
#include "PhysicsVehicle.h"
#include "PhysicsVehicleWheel.h"
namespace gameplay
{
extern void luaGlobal_Register_Conversion_Function(const char* className, void*(*func)(void*, const char*));
static PhysicsCollisionObject* getInstance(lua_State* state)
{
void* userdata = luaL_checkudata(state, 1, "PhysicsCollisionObject");
luaL_argcheck(state, userdata != NULL, 1, "'PhysicsCollisionObject' expected.");
return (PhysicsCollisionObject*)((gameplay::ScriptUtil::LuaObject*)userdata)->instance;
}
static int lua_PhysicsCollisionObject__gc(lua_State* state)
{
// Get the number of parameters.
int paramCount = lua_gettop(state);
// Attempt to match the parameters to a valid binding.
switch (paramCount)
{
case 1:
{
if ((lua_type(state, 1) == LUA_TUSERDATA))
{
void* userdata = luaL_checkudata(state, 1, "PhysicsCollisionObject");
luaL_argcheck(state, userdata != NULL, 1, "'PhysicsCollisionObject' expected.");
gameplay::ScriptUtil::LuaObject* object = (gameplay::ScriptUtil::LuaObject*)userdata;
if (object->owns)
{
PhysicsCollisionObject* instance = (PhysicsCollisionObject*)object->instance;
SAFE_DELETE(instance);
}
return 0;
}
lua_pushstring(state, "lua_PhysicsCollisionObject__gc - Failed to match the given parameters to a valid function signature.");
lua_error(state);
break;
}
default:
{
lua_pushstring(state, "Invalid number of parameters (expected 1).");
lua_error(state);
break;
}
}
return 0;
}
static int lua_PhysicsCollisionObject_addCollisionListener(lua_State* state)
{
// Get the number of parameters.
int paramCount = lua_gettop(state);
// Attempt to match the parameters to a valid binding.
switch (paramCount)
{
case 2:
{
do
{
if ((lua_type(state, 1) == LUA_TUSERDATA) &&
(lua_type(state, 2) == LUA_TUSERDATA || lua_type(state, 2) == LUA_TTABLE || lua_type(state, 2) == LUA_TNIL))
{
// Get parameter 1 off the stack.
bool param1Valid;
gameplay::ScriptUtil::LuaArray<PhysicsCollisionObject::CollisionListener> param1 = gameplay::ScriptUtil::getObjectPointer<PhysicsCollisionObject::CollisionListener>(2, "PhysicsCollisionObjectCollisionListener", false, ¶m1Valid);
if (!param1Valid)
break;
PhysicsCollisionObject* instance = getInstance(state);
instance->addCollisionListener(param1);
return 0;
}
} while (0);
do
{
if ((lua_type(state, 1) == LUA_TUSERDATA) &&
(lua_type(state, 2) == LUA_TSTRING || lua_type(state, 2) == LUA_TNIL))
{
// Get parameter 1 off the stack.
const char* param1 = gameplay::ScriptUtil::getString(2, false);
PhysicsCollisionObject* instance = getInstance(state);
instance->addCollisionListener(param1);
return 0;
}
} while (0);
lua_pushstring(state, "lua_PhysicsCollisionObject_addCollisionListener - Failed to match the given parameters to a valid function signature.");
lua_error(state);
break;
}
case 3:
{
do
{
if ((lua_type(state, 1) == LUA_TUSERDATA) &&
(lua_type(state, 2) == LUA_TUSERDATA || lua_type(state, 2) == LUA_TTABLE || lua_type(state, 2) == LUA_TNIL) &&
(lua_type(state, 3) == LUA_TUSERDATA || lua_type(state, 3) == LUA_TTABLE || lua_type(state, 3) == LUA_TNIL))
{
// Get parameter 1 off the stack.
bool param1Valid;
gameplay::ScriptUtil::LuaArray<PhysicsCollisionObject::CollisionListener> param1 = gameplay::ScriptUtil::getObjectPointer<PhysicsCollisionObject::CollisionListener>(2, "PhysicsCollisionObjectCollisionListener", false, ¶m1Valid);
if (!param1Valid)
break;
// Get parameter 2 off the stack.
bool param2Valid;
gameplay::ScriptUtil::LuaArray<PhysicsCollisionObject> param2 = gameplay::ScriptUtil::getObjectPointer<PhysicsCollisionObject>(3, "PhysicsCollisionObject", false, ¶m2Valid);
if (!param2Valid)
break;
PhysicsCollisionObject* instance = getInstance(state);
instance->addCollisionListener(param1, param2);
return 0;
}
} while (0);
do
{
if ((lua_type(state, 1) == LUA_TUSERDATA) &&
(lua_type(state, 2) == LUA_TSTRING || lua_type(state, 2) == LUA_TNIL) &&
(lua_type(state, 3) == LUA_TUSERDATA || lua_type(state, 3) == LUA_TTABLE || lua_type(state, 3) == LUA_TNIL))
{
// Get parameter 1 off the stack.
const char* param1 = gameplay::ScriptUtil::getString(2, false);
// Get parameter 2 off the stack.
bool param2Valid;
gameplay::ScriptUtil::LuaArray<PhysicsCollisionObject> param2 = gameplay::ScriptUtil::getObjectPointer<PhysicsCollisionObject>(3, "PhysicsCollisionObject", false, ¶m2Valid);
if (!param2Valid)
break;
PhysicsCollisionObject* instance = getInstance(state);
instance->addCollisionListener(param1, param2);
return 0;
}
} while (0);
lua_pushstring(state, "lua_PhysicsCollisionObject_addCollisionListener - Failed to match the given parameters to a valid function signature.");
lua_error(state);
break;
}
default:
{
lua_pushstring(state, "Invalid number of parameters (expected 2 or 3).");
lua_error(state);
break;
}
}
return 0;
}
static int lua_PhysicsCollisionObject_collidesWith(lua_State* state)
{
// Get the number of parameters.
int paramCount = lua_gettop(state);
// Attempt to match the parameters to a valid binding.
switch (paramCount)
{
case 2:
{
if ((lua_type(state, 1) == LUA_TUSERDATA) &&
(lua_type(state, 2) == LUA_TUSERDATA || lua_type(state, 2) == LUA_TTABLE || lua_type(state, 2) == LUA_TNIL))
{
// Get parameter 1 off the stack.
bool param1Valid;
gameplay::ScriptUtil::LuaArray<PhysicsCollisionObject> param1 = gameplay::ScriptUtil::getObjectPointer<PhysicsCollisionObject>(2, "PhysicsCollisionObject", false, ¶m1Valid);
if (!param1Valid)
{
lua_pushstring(state, "Failed to convert parameter 1 to type 'PhysicsCollisionObject'.");
lua_error(state);
}
PhysicsCollisionObject* instance = getInstance(state);
bool result = instance->collidesWith(param1);
// Push the return value onto the stack.
lua_pushboolean(state, result);
return 1;
}
lua_pushstring(state, "lua_PhysicsCollisionObject_collidesWith - Failed to match the given parameters to a valid function signature.");
lua_error(state);
break;
}
default:
{
lua_pushstring(state, "Invalid number of parameters (expected 2).");
lua_error(state);
break;
}
}
return 0;
}
static int lua_PhysicsCollisionObject_getCollisionShape(lua_State* state)
{
// Get the number of parameters.
int paramCount = lua_gettop(state);
// Attempt to match the parameters to a valid binding.
switch (paramCount)
{
case 1:
{
if ((lua_type(state, 1) == LUA_TUSERDATA))
{
PhysicsCollisionObject* instance = getInstance(state);
void* returnPtr = ((void*)instance->getCollisionShape());
if (returnPtr)
{
gameplay::ScriptUtil::LuaObject* object = (gameplay::ScriptUtil::LuaObject*)lua_newuserdata(state, sizeof(gameplay::ScriptUtil::LuaObject));
object->instance = returnPtr;
object->owns = false;
luaL_getmetatable(state, "PhysicsCollisionShape");
lua_setmetatable(state, -2);
}
else
{
lua_pushnil(state);
}
return 1;
}
lua_pushstring(state, "lua_PhysicsCollisionObject_getCollisionShape - Failed to match the given parameters to a valid function signature.");
lua_error(state);
break;
}
default:
{
lua_pushstring(state, "Invalid number of parameters (expected 1).");
lua_error(state);
break;
}
}
return 0;
}
static int lua_PhysicsCollisionObject_getNode(lua_State* state)
{
// Get the number of parameters.
int paramCount = lua_gettop(state);
// Attempt to match the parameters to a valid binding.
switch (paramCount)
{
case 1:
{
if ((lua_type(state, 1) == LUA_TUSERDATA))
{
PhysicsCollisionObject* instance = getInstance(state);
void* returnPtr = ((void*)instance->getNode());
if (returnPtr)
{
gameplay::ScriptUtil::LuaObject* object = (gameplay::ScriptUtil::LuaObject*)lua_newuserdata(state, sizeof(gameplay::ScriptUtil::LuaObject));
object->instance = returnPtr;
object->owns = false;
luaL_getmetatable(state, "Node");
lua_setmetatable(state, -2);
}
else
{
lua_pushnil(state);
}
return 1;
}
lua_pushstring(state, "lua_PhysicsCollisionObject_getNode - Failed to match the given parameters to a valid function signature.");
lua_error(state);
break;
}
default:
{
lua_pushstring(state, "Invalid number of parameters (expected 1).");
lua_error(state);
break;
}
}
return 0;
}
static int lua_PhysicsCollisionObject_getShapeType(lua_State* state)
{
// Get the number of parameters.
int paramCount = lua_gettop(state);
// Attempt to match the parameters to a valid binding.
switch (paramCount)
{
case 1:
{
if ((lua_type(state, 1) == LUA_TUSERDATA))
{
PhysicsCollisionObject* instance = getInstance(state);
PhysicsCollisionShape::Type result = instance->getShapeType();
// Push the return value onto the stack.
lua_pushnumber(state, (int)result);
return 1;
}
lua_pushstring(state, "lua_PhysicsCollisionObject_getShapeType - Failed to match the given parameters to a valid function signature.");
lua_error(state);
break;
}
default:
{
lua_pushstring(state, "Invalid number of parameters (expected 1).");
lua_error(state);
break;
}
}
return 0;
}
static int lua_PhysicsCollisionObject_getType(lua_State* state)
{
// Get the number of parameters.
int paramCount = lua_gettop(state);
// Attempt to match the parameters to a valid binding.
switch (paramCount)
{
case 1:
{
if ((lua_type(state, 1) == LUA_TUSERDATA))
{
PhysicsCollisionObject* instance = getInstance(state);
PhysicsCollisionObject::Type result = instance->getType();
// Push the return value onto the stack.
lua_pushnumber(state, (int)result);
return 1;
}
lua_pushstring(state, "lua_PhysicsCollisionObject_getType - Failed to match the given parameters to a valid function signature.");
lua_error(state);
break;
}
default:
{
lua_pushstring(state, "Invalid number of parameters (expected 1).");
lua_error(state);
break;
}
}
return 0;
}
static int lua_PhysicsCollisionObject_isDynamic(lua_State* state)
{
// Get the number of parameters.
int paramCount = lua_gettop(state);
// Attempt to match the parameters to a valid binding.
switch (paramCount)
{
case 1:
{
if ((lua_type(state, 1) == LUA_TUSERDATA))
{
PhysicsCollisionObject* instance = getInstance(state);
bool result = instance->isDynamic();
// Push the return value onto the stack.
lua_pushboolean(state, result);
return 1;
}
lua_pushstring(state, "lua_PhysicsCollisionObject_isDynamic - Failed to match the given parameters to a valid function signature.");
lua_error(state);
break;
}
default:
{
lua_pushstring(state, "Invalid number of parameters (expected 1).");
lua_error(state);
break;
}
}
return 0;
}
static int lua_PhysicsCollisionObject_isEnabled(lua_State* state)
{
// Get the number of parameters.
int paramCount = lua_gettop(state);
// Attempt to match the parameters to a valid binding.
switch (paramCount)
{
case 1:
{
if ((lua_type(state, 1) == LUA_TUSERDATA))
{
PhysicsCollisionObject* instance = getInstance(state);
bool result = instance->isEnabled();
// Push the return value onto the stack.
lua_pushboolean(state, result);
return 1;
}
lua_pushstring(state, "lua_PhysicsCollisionObject_isEnabled - Failed to match the given parameters to a valid function signature.");
lua_error(state);
break;
}
default:
{
lua_pushstring(state, "Invalid number of parameters (expected 1).");
lua_error(state);
break;
}
}
return 0;
}
static int lua_PhysicsCollisionObject_isKinematic(lua_State* state)
{
// Get the number of parameters.
int paramCount = lua_gettop(state);
// Attempt to match the parameters to a valid binding.
switch (paramCount)
{
case 1:
{
if ((lua_type(state, 1) == LUA_TUSERDATA))
{
PhysicsCollisionObject* instance = getInstance(state);
bool result = instance->isKinematic();
// Push the return value onto the stack.
lua_pushboolean(state, result);
return 1;
}
lua_pushstring(state, "lua_PhysicsCollisionObject_isKinematic - Failed to match the given parameters to a valid function signature.");
lua_error(state);
break;
}
default:
{
lua_pushstring(state, "Invalid number of parameters (expected 1).");
lua_error(state);
break;
}
}
return 0;
}
static int lua_PhysicsCollisionObject_isStatic(lua_State* state)
{
// Get the number of parameters.
int paramCount = lua_gettop(state);
// Attempt to match the parameters to a valid binding.
switch (paramCount)
{
case 1:
{
if ((lua_type(state, 1) == LUA_TUSERDATA))
{
PhysicsCollisionObject* instance = getInstance(state);
bool result = instance->isStatic();
// Push the return value onto the stack.
lua_pushboolean(state, result);
return 1;
}
lua_pushstring(state, "lua_PhysicsCollisionObject_isStatic - Failed to match the given parameters to a valid function signature.");
lua_error(state);
break;
}
default:
{
lua_pushstring(state, "Invalid number of parameters (expected 1).");
lua_error(state);
break;
}
}
return 0;
}
static int lua_PhysicsCollisionObject_removeCollisionListener(lua_State* state)
{
// Get the number of parameters.
int paramCount = lua_gettop(state);
// Attempt to match the parameters to a valid binding.
switch (paramCount)
{
case 2:
{
do
{
if ((lua_type(state, 1) == LUA_TUSERDATA) &&
(lua_type(state, 2) == LUA_TUSERDATA || lua_type(state, 2) == LUA_TTABLE || lua_type(state, 2) == LUA_TNIL))
{
// Get parameter 1 off the stack.
bool param1Valid;
gameplay::ScriptUtil::LuaArray<PhysicsCollisionObject::CollisionListener> param1 = gameplay::ScriptUtil::getObjectPointer<PhysicsCollisionObject::CollisionListener>(2, "PhysicsCollisionObjectCollisionListener", false, ¶m1Valid);
if (!param1Valid)
break;
PhysicsCollisionObject* instance = getInstance(state);
instance->removeCollisionListener(param1);
return 0;
}
} while (0);
do
{
if ((lua_type(state, 1) == LUA_TUSERDATA) &&
(lua_type(state, 2) == LUA_TSTRING || lua_type(state, 2) == LUA_TNIL))
{
// Get parameter 1 off the stack.
const char* param1 = gameplay::ScriptUtil::getString(2, false);
PhysicsCollisionObject* instance = getInstance(state);
instance->removeCollisionListener(param1);
return 0;
}
} while (0);
lua_pushstring(state, "lua_PhysicsCollisionObject_removeCollisionListener - Failed to match the given parameters to a valid function signature.");
lua_error(state);
break;
}
case 3:
{
do
{
if ((lua_type(state, 1) == LUA_TUSERDATA) &&
(lua_type(state, 2) == LUA_TUSERDATA || lua_type(state, 2) == LUA_TTABLE || lua_type(state, 2) == LUA_TNIL) &&
(lua_type(state, 3) == LUA_TUSERDATA || lua_type(state, 3) == LUA_TTABLE || lua_type(state, 3) == LUA_TNIL))
{
// Get parameter 1 off the stack.
bool param1Valid;
gameplay::ScriptUtil::LuaArray<PhysicsCollisionObject::CollisionListener> param1 = gameplay::ScriptUtil::getObjectPointer<PhysicsCollisionObject::CollisionListener>(2, "PhysicsCollisionObjectCollisionListener", false, ¶m1Valid);
if (!param1Valid)
break;
// Get parameter 2 off the stack.
bool param2Valid;
gameplay::ScriptUtil::LuaArray<PhysicsCollisionObject> param2 = gameplay::ScriptUtil::getObjectPointer<PhysicsCollisionObject>(3, "PhysicsCollisionObject", false, ¶m2Valid);
if (!param2Valid)
break;
PhysicsCollisionObject* instance = getInstance(state);
instance->removeCollisionListener(param1, param2);
return 0;
}
} while (0);
do
{
if ((lua_type(state, 1) == LUA_TUSERDATA) &&
(lua_type(state, 2) == LUA_TSTRING || lua_type(state, 2) == LUA_TNIL) &&
(lua_type(state, 3) == LUA_TUSERDATA || lua_type(state, 3) == LUA_TTABLE || lua_type(state, 3) == LUA_TNIL))
{
// Get parameter 1 off the stack.
const char* param1 = gameplay::ScriptUtil::getString(2, false);
// Get parameter 2 off the stack.
bool param2Valid;
gameplay::ScriptUtil::LuaArray<PhysicsCollisionObject> param2 = gameplay::ScriptUtil::getObjectPointer<PhysicsCollisionObject>(3, "PhysicsCollisionObject", false, ¶m2Valid);
if (!param2Valid)
break;
PhysicsCollisionObject* instance = getInstance(state);
instance->removeCollisionListener(param1, param2);
return 0;
}
} while (0);
lua_pushstring(state, "lua_PhysicsCollisionObject_removeCollisionListener - Failed to match the given parameters to a valid function signature.");
lua_error(state);
break;
}
default:
{
lua_pushstring(state, "Invalid number of parameters (expected 2 or 3).");
lua_error(state);
break;
}
}
return 0;
}
static int lua_PhysicsCollisionObject_setEnabled(lua_State* state)
{
// Get the number of parameters.
int paramCount = lua_gettop(state);
// Attempt to match the parameters to a valid binding.
switch (paramCount)
{
case 2:
{
if ((lua_type(state, 1) == LUA_TUSERDATA) &&
lua_type(state, 2) == LUA_TBOOLEAN)
{
// Get parameter 1 off the stack.
bool param1 = gameplay::ScriptUtil::luaCheckBool(state, 2);
PhysicsCollisionObject* instance = getInstance(state);
instance->setEnabled(param1);
return 0;
}
lua_pushstring(state, "lua_PhysicsCollisionObject_setEnabled - Failed to match the given parameters to a valid function signature.");
lua_error(state);
break;
}
default:
{
lua_pushstring(state, "Invalid number of parameters (expected 2).");
lua_error(state);
break;
}
}
return 0;
}
// Provides support for conversion to all known relative types of PhysicsCollisionObject
static void* __convertTo(void* ptr, const char* typeName)
{
PhysicsCollisionObject* ptrObject = reinterpret_cast<PhysicsCollisionObject*>(ptr);
if (strcmp(typeName, "PhysicsGhostObject") == 0)
{
return reinterpret_cast<void*>(static_cast<PhysicsGhostObject*>(ptrObject));
}
else if (strcmp(typeName, "PhysicsRigidBody") == 0)
{
return reinterpret_cast<void*>(static_cast<PhysicsRigidBody*>(ptrObject));
}
else if (strcmp(typeName, "PhysicsVehicle") == 0)
{
return reinterpret_cast<void*>(static_cast<PhysicsVehicle*>(ptrObject));
}
else if (strcmp(typeName, "PhysicsVehicleWheel") == 0)
{
return reinterpret_cast<void*>(static_cast<PhysicsVehicleWheel*>(ptrObject));
}
// No conversion available for 'typeName'
return NULL;
}
static int lua_PhysicsCollisionObject_to(lua_State* state)
{
// There should be only a single parameter (this instance)
if (lua_gettop(state) != 2 || lua_type(state, 1) != LUA_TUSERDATA || lua_type(state, 2) != LUA_TSTRING)
{
lua_pushstring(state, "lua_PhysicsCollisionObject_to - Invalid number of parameters (expected 2).");
lua_error(state);
return 0;
}
PhysicsCollisionObject* instance = getInstance(state);
const char* typeName = gameplay::ScriptUtil::getString(2, false);
void* result = __convertTo((void*)instance, typeName);
if (result)
{
gameplay::ScriptUtil::LuaObject* object = (gameplay::ScriptUtil::LuaObject*)lua_newuserdata(state, sizeof(gameplay::ScriptUtil::LuaObject));
object->instance = (void*)result;
object->owns = false;
luaL_getmetatable(state, typeName);
lua_setmetatable(state, -2);
}
else
{
lua_pushnil(state);
}
return 1;
}
void luaRegister_PhysicsCollisionObject()
{
const luaL_Reg lua_members[] =
{
{"addCollisionListener", lua_PhysicsCollisionObject_addCollisionListener},
{"collidesWith", lua_PhysicsCollisionObject_collidesWith},
{"getCollisionShape", lua_PhysicsCollisionObject_getCollisionShape},
{"getNode", lua_PhysicsCollisionObject_getNode},
{"getShapeType", lua_PhysicsCollisionObject_getShapeType},
{"getType", lua_PhysicsCollisionObject_getType},
{"isDynamic", lua_PhysicsCollisionObject_isDynamic},
{"isEnabled", lua_PhysicsCollisionObject_isEnabled},
{"isKinematic", lua_PhysicsCollisionObject_isKinematic},
{"isStatic", lua_PhysicsCollisionObject_isStatic},
{"removeCollisionListener", lua_PhysicsCollisionObject_removeCollisionListener},
{"setEnabled", lua_PhysicsCollisionObject_setEnabled},
{"to", lua_PhysicsCollisionObject_to},
{NULL, NULL}
};
const luaL_Reg* lua_statics = NULL;
std::vector<std::string> scopePath;
gameplay::ScriptUtil::registerClass("PhysicsCollisionObject", lua_members, NULL, lua_PhysicsCollisionObject__gc, lua_statics, scopePath);
luaGlobal_Register_Conversion_Function("PhysicsCollisionObject", __convertTo);
}
}
| 12,923 |
897 | <reponame>zhcet19/NeoAlgo-1
def kadane(arr, start, finish, n):
Sum = 0
maxSum = -999999999999
i = None
finish[0] = -1
local_start = 0
for i in range(n):
Sum += arr[i]
if Sum < 0:
Sum = 0
local_start = i + 1
elif Sum > maxSum:
maxSum = Sum
start[0] = local_start
finish[0] = i
if finish[0] != -1:
return maxSum
maxSum = arr[0]
start[0] = finish[0] = 0
for i in range(1, n):
if arr[i] > maxSum:
maxSum = arr[i]
start[0] = finish[0] = i
return maxSum
def findMaxSum(M):
global ROW, COL
# Variables to store the final output
maxSum, finalLeft = -999999999999, None
finalRight, finalTop, finalBottom = None, None, None
left, right, i = None, None, None
temp = [None] * ROW
Sum = 0
start = [0]
finish = [0]
for left in range(COL):
temp = [0] * ROW
# Set the right column for the left
# column set by outer loop
for right in range(left, COL):
# Calculate sum between current left
# and right for every row 'i'
for i in range(ROW):
temp[i] += M[i][right]
Sum = kadane(temp, start, finish, ROW)
if Sum > maxSum:
maxSum = Sum
finalLeft = left
finalRight = right
finalTop = start[0]
finalBottom = finish[0]
print("(Top, Left)", "(", finalTop,
finalLeft, ")")
print("(Bottom, Right)", "(", finalBottom,
finalRight, ")")
print("Max sum is:", maxSum)
if __name__ == '__main__':
ROW=int(input("Enter the no of rows"))
COL=int(input("Enter the no of columns"))
M = []
print("Enter the entries row wise:")
for i in range(ROW):
a =[]
for j in range(COL):
a.append(int(input()))
M.append(a)
for i in range(ROW):
for j in range(COL):
print(M[i][j], end = " ")
print()
findMaxSum(M)
# Time complexity: O(n^3) or O(COL^2*ROW)
# Space Complexity: O(ROW)
'''Output :Enter the no of rows: 4
Enter the no of columns: 5
Enter the entries rowwise:
1
2
-1
-4
-20
-8
-3
4
2
1
3
8
10
1
3
-4
-1
1
7
-6
1 2 -1 -4 -20
-8 -3 4 2 1
3 8 10 1 3
-4 -1 1 7 -6
enter the
(Top, Left) ( 1 1 )
(Bottom, Right) ( 3 3 )
Max sum is: 29'''
| 1,531 |
2,743 | <reponame>eshbeata/open-paperless
from __future__ import absolute_import, unicode_literals
from django.conf import settings
from django.core import mail
from django.test import override_settings
from django.urls import reverse
from common.tests import BaseTestCase
from smart_settings.classes import Namespace
from user_management.tests.literals import (
TEST_ADMIN_EMAIL, TEST_ADMIN_PASSWORD, TEST_USER_PASSWORD_EDITED,
TEST_ADMIN_USERNAME
)
from ..settings import setting_maximum_session_length
from .literals import TEST_EMAIL_AUTHENTICATION_BACKEND
class UserLoginTestCase(BaseTestCase):
"""
Test that users can login via the supported authentication methods
"""
def setUp(self):
super(UserLoginTestCase, self).setUp()
Namespace.invalidate_cache_all()
@override_settings(AUTHENTICATION_LOGIN_METHOD='username')
def test_normal_behavior(self):
response = self.client.get(reverse('documents:document_list'))
self.assertRedirects(
response,
'http://testserver/authentication/login/?next=/documents/list/'
)
@override_settings(AUTHENTICATION_LOGIN_METHOD='username')
def test_username_login(self):
logged_in = self.client.login(
username=TEST_ADMIN_USERNAME, password=<PASSWORD>
)
self.assertTrue(logged_in)
response = self.client.get(reverse('documents:document_list'))
# We didn't get redirected to the login URL
self.assertEqual(response.status_code, 200)
@override_settings(AUTHENTICATION_LOGIN_METHOD='email')
def test_email_login(self):
with self.settings(AUTHENTICATION_BACKENDS=(TEST_EMAIL_AUTHENTICATION_BACKEND,)):
logged_in = self.client.login(
username=TEST_ADMIN_USERNAME, password=<PASSWORD>
)
self.assertFalse(logged_in)
logged_in = self.client.login(
email=TEST_ADMIN_EMAIL, password=<PASSWORD>
)
self.assertTrue(logged_in)
response = self.client.get(reverse('documents:document_list'))
# We didn't get redirected to the login URL
self.assertEqual(response.status_code, 200)
@override_settings(AUTHENTICATION_LOGIN_METHOD='username')
def test_username_login_via_views(self):
response = self.client.get(reverse('documents:document_list'))
self.assertRedirects(
response,
'http://testserver/authentication/login/?next=/documents/list/'
)
response = self.client.post(
reverse(settings.LOGIN_URL), {
'username': TEST_ADMIN_USERNAME,
'password': <PASSWORD>
}
)
response = self.client.get(reverse('documents:document_list'))
# We didn't get redirected to the login URL
self.assertEqual(response.status_code, 200)
@override_settings(AUTHENTICATION_LOGIN_METHOD='email')
def test_email_login_via_views(self):
with self.settings(AUTHENTICATION_BACKENDS=(TEST_EMAIL_AUTHENTICATION_BACKEND,)):
response = self.client.get(reverse('documents:document_list'))
self.assertRedirects(
response,
'http://testserver/authentication/login/?next=/documents/list/'
)
response = self.client.post(
reverse(settings.LOGIN_URL), {
'email': TEST_ADMIN_EMAIL, 'password': <PASSWORD>
}, follow=True
)
self.assertEqual(response.status_code, 200)
response = self.client.get(reverse('documents:document_list'))
# We didn't get redirected to the login URL
self.assertEqual(response.status_code, 200)
@override_settings(AUTHENTICATION_LOGIN_METHOD='username')
def test_username_remember_me(self):
response = self.client.post(
reverse(settings.LOGIN_URL), {
'username': TEST_ADMIN_USERNAME,
'password': <PASSWORD>,
'remember_me': True
}, follow=True
)
response = self.client.get(reverse('documents:document_list'))
self.assertEqual(response.status_code, 200)
self.assertEqual(
self.client.session.get_expiry_age(),
setting_maximum_session_length.value
)
self.assertFalse(self.client.session.get_expire_at_browser_close())
@override_settings(AUTHENTICATION_LOGIN_METHOD='username')
def test_username_dont_remember_me(self):
response = self.client.post(
reverse(settings.LOGIN_URL), {
'username': TEST_ADMIN_USERNAME,
'password': <PASSWORD>,
'remember_me': False
}, follow=True
)
response = self.client.get(reverse('documents:document_list'))
self.assertEqual(response.status_code, 200)
self.assertTrue(self.client.session.get_expire_at_browser_close())
@override_settings(AUTHENTICATION_LOGIN_METHOD='email')
def test_email_remember_me(self):
with self.settings(AUTHENTICATION_BACKENDS=(TEST_EMAIL_AUTHENTICATION_BACKEND,)):
response = self.client.post(
reverse(settings.LOGIN_URL), {
'email': TEST_ADMIN_EMAIL,
'password': <PASSWORD>,
'remember_me': True
}, follow=True
)
response = self.client.get(reverse('documents:document_list'))
self.assertEqual(response.status_code, 200)
self.assertEqual(
self.client.session.get_expiry_age(),
setting_maximum_session_length.value
)
self.assertFalse(self.client.session.get_expire_at_browser_close())
@override_settings(AUTHENTICATION_LOGIN_METHOD='email')
def test_email_dont_remember_me(self):
with self.settings(AUTHENTICATION_BACKENDS=(TEST_EMAIL_AUTHENTICATION_BACKEND,)):
response = self.client.post(
reverse(settings.LOGIN_URL), {
'email': TEST_ADMIN_EMAIL,
'password': <PASSWORD>,
'remember_me': False
}, follow=True
)
response = self.client.get(reverse('documents:document_list'))
self.assertEqual(response.status_code, 200)
self.assertTrue(self.client.session.get_expire_at_browser_close())
@override_settings(AUTHENTICATION_LOGIN_METHOD='username')
def test_password_reset(self):
response = self.client.post(
reverse('authentication:password_reset_view'), {
'email': TEST_ADMIN_EMAIL,
}, follow=True
)
self.assertContains(
response, text='Password reset email sent!', status_code=200
)
self.assertEqual(len(mail.outbox), 1)
uid_token = mail.outbox[0].body.replace('\n', '').split('/')
response = self.client.post(
reverse('authentication:password_reset_confirm_view', args=uid_token[-3:-1]), {
'new_password1': <PASSWORD>,
'new_password2': <PASSWORD>,
}, follow=True
)
self.assertContains(
response, text='Password reset complete!', status_code=200
)
response = self.client.post(
reverse(settings.LOGIN_URL), {
'username': TEST_ADMIN_USERNAME,
'password': <PASSWORD>,
'remember_me': True
}, follow=True
)
response = self.client.get(reverse('documents:document_list'))
self.assertEqual(response.status_code, 200)
| 3,559 |
424 | <gh_stars>100-1000
package com.twitter.elephantbird.mapreduce.input;
import com.twitter.elephantbird.mapreduce.io.ThriftBlockReader;
import com.twitter.elephantbird.mapreduce.io.ThriftWritable;
import com.twitter.elephantbird.util.TypeRef;
import org.apache.thrift.TBase;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* A reader for LZO-encoded protobuf blocks, generally written by
* a ProtobufBlockWriter or similar. Returns <position, protobuf> pairs.
*/
public class LzoThriftBlockRecordReader<M extends TBase<?, ?>> extends LzoBinaryBlockRecordReader<M, ThriftWritable<M>> {
private static final Logger LOG = LoggerFactory.getLogger(LzoThriftBlockRecordReader.class);
public LzoThriftBlockRecordReader(TypeRef<M> typeRef) {
// input stream for the reader will be set by LzoBinaryBlockRecordReader
super(typeRef, new ThriftBlockReader<M>(null, typeRef), new ThriftWritable<M>(typeRef));
LOG.info("LzoThriftBlockRecordReader, type args are " + typeRef.getRawClass());
}
}
| 339 |
4,071 | # Copyright 2018 Alibaba Group. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
import mxnet as mx
from mxnet.base import _Null
from xdl.python.lib.tensor import Tensor
from xdl.python.utils.collections import *
RawBatchNorm = mx.sym.BatchNorm
def BatchNormWrapper(data=None, gamma=None,
beta=None, moving_mean=None,
moving_var=None, eps=_Null,
momentum=0.9, fix_gamma=_Null,
use_global_stats=_Null,
output_mean_var=_Null,
axis=_Null,
cudnn_off=_Null,
name=None,
attr=None,
out=None,
**kwargs):
outputs = RawBatchNorm(data=data, gamma=gamma,
beta=beta,
moving_mean=moving_mean,
moving_var=moving_var,
eps=eps,
momentum=momentum,
fix_gamma=fix_gamma,
use_global_stats=use_global_stats,
output_mean_var=True,
axis=axis, cudnn_off=cudnn_off,
name=name, attr=attr,
out=out, **kwargs)
if eps == _Null:
eps = 1e-3
var = (1/outputs[2]) ** 2 - eps
aux_list = outputs.list_auxiliary_states()
add_to_collection(MXNET_BN_STATISTIC, zip(
aux_list[len(aux_list)-2:], [outputs[1], var], [momentum]*2))
if output_mean_var == _Null:
return outputs[0]
else:
return outputs
mx.sym.BatchNorm = BatchNormWrapper
RawBatchNormV1 = mx.sym.BatchNorm_v1
def BatchNormV1Wrapper(data=None, gamma=None,
beta=None, eps=_Null,
momentum=0.9, fix_gamma=_Null,
use_global_stats=_Null,
output_mean_var=_Null,
name=None, attr=None,
out=None, **kwargs):
outputs = RawBatchNormV1(data=data, gamma=gamma,
beta=beta, eps=eps,
momentum=momentum,
fix_gamma=fix_gamma,
use_global_stats=use_global_stats,
output_mean_var=True,
name=name, attr=attr,
out=out, **kwargs)
aux_list = outputs.list_auxiliary_states()
add_to_collection(MXNET_BN_STATISTIC, zip(
aux_list[len(aux_list)-2:], outputs[1:], [momentum]*2))
if output_mean_var == _Null:
return outputs[0]
else:
return outputs
mx.sym.BatchNorm_v1 = BatchNormV1Wrapper
| 1,752 |
803 | import cmd
import sys
from websploit.modules import all_modules, module_list
from websploit.core.utils import CPrint
completions = [
'target',
'ip',
'gateway',
'mac',
'iface',
'gateway_mac',
'target_mac'
]
class Module(cmd.Cmd):
parameters = {}
cp = CPrint()
def do_execute(self):
"""Execute current module"""
pass
def do_back(self, *args):
"""go back one level"""
return True
def do_exit(self, line):
"""exit websploit"""
sys.exit(0)
def do_set(self, line):
"""set options"""
try:
key, value = line.split(' ')
print(key, value)
self.parameters.update({key: value})
except KeyError:
# print(f"*** Unknown Option! option not has value!")
self.cp.warning(text="*** Unknown Option! option not has value!")
except ValueError:
# print(f"*** Option not has value!")
# print(f"*** Example : set host 127.0.0.1")
self.cp.warning(text="*** Option not has value!")
self.cp.info(text="*** Example : set host 127.0.0.1")
def do_options(self, line):
"""Show options of current module"""
print("\n")
self.cp.green(f"{'Option':20}\t{'Value':20}")
self.cp.green(f"{'--'*8:<20}\t{'--'*8:<20}")
for k,v in self.parameters.items():
self.cp.yellow(f"{k:20}\t{v:20}")
print("\n")
def complete_set(self, text, line, begidx, endidx):
mline = line.partition(' ')[2]
offs = len(mline) - len(text)
return [s[offs:] for s in self.completions if s.startswith(mline)]
| 803 |
4,253 | package com.mashibing.arica.controller;
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import com.mashibing.arica.entity.Item;
import com.mashibing.arica.service.ItemService;
@Controller
public class MainController {
@Autowired
ItemService itemSrv;
@RequestMapping("")
public String index() {
System.out.println("xxoo");
return "arica";
}
/**
* 显示添加 item 表单
* @return
*/
@RequestMapping("addtor")
public String addtor() {
return "add";
}
/**
* 表单接受，入库
* @param item
* @param model
* @return
*/
@RequestMapping("add")
public String add(Item item,Model model) {
Item itemRecord = itemSrv.insert(item);
model.addAttribute("msg", "添加商品成功, <a href = 'view?id="
+itemRecord.getId()+"' target='_blank' class=\"layui-btn\">预览一下</a>");
return "success";
}
/**
* 临时预览，动态
* @param item
* @param model
* @return
*/
@RequestMapping("view")
public String view(Model model,int id) {
Item item = itemSrv.findById(id);
model.addAttribute("item", item);
return "view";
}
}
| 547 |
852 | #include "CondFormats/SiPixelObjects/interface/SiPixelFedCablingTree.h"
#include <algorithm>
#include <sstream>
#include <iostream>
using namespace std;
using namespace sipixelobjects;
typedef std::unordered_map<int, SiPixelFedCablingTree::PixelFEDCabling>::const_iterator IMAP;
std::vector<sipixelobjects::CablingPathToDetUnit> SiPixelFedCablingTree::pathToDetUnit(uint32_t rawDetId) const {
std::vector<sipixelobjects::CablingPathToDetUnit> result;
for (auto im = theFedCablings.begin(); im != theFedCablings.end(); ++im) {
const PixelFEDCabling& aFed = im->second;
for (unsigned int idxLink = 1; idxLink <= aFed.numberOfLinks(); idxLink++) {
const PixelFEDLink* link = aFed.link(idxLink);
if (!link)
continue;
unsigned int numberOfRocs = link->numberOfROCs();
for (unsigned int idxRoc = 1; idxRoc <= numberOfRocs; idxRoc++) {
const PixelROC* roc = link->roc(idxRoc);
if (rawDetId == roc->rawId()) {
CablingPathToDetUnit path = {aFed.id(), link->id(), roc->idInLink()};
result.push_back(path);
}
}
}
}
return result;
}
bool SiPixelFedCablingTree::pathToDetUnitHasDetUnit(uint32_t rawDetId, unsigned int fedId) const {
for (auto im = theFedCablings.begin(); im != theFedCablings.end(); ++im) {
const PixelFEDCabling& aFed = im->second;
if (aFed.id() == fedId) {
for (unsigned int idxLink = 1; idxLink <= aFed.numberOfLinks(); idxLink++) {
const PixelFEDLink* link = aFed.link(idxLink);
if (!link)
continue;
unsigned int numberOfRocs = link->numberOfROCs();
for (unsigned int idxRoc = 1; idxRoc <= numberOfRocs; idxRoc++) {
const PixelROC* roc = link->roc(idxRoc);
if (rawDetId == roc->rawId()) {
return true;
}
}
}
}
}
return false;
}
std::unordered_map<uint32_t, unsigned int> SiPixelFedCablingTree::det2fedMap() const {
std::unordered_map<uint32_t, unsigned int> result;
for (auto im = theFedCablings.begin(); im != theFedCablings.end(); ++im) {
auto const& aFed = im->second;
for (unsigned int idxLink = 1; idxLink <= aFed.numberOfLinks(); idxLink++) {
auto link = aFed.link(idxLink);
if (!link)
continue;
unsigned int numberOfRocs = link->numberOfROCs();
for (unsigned int idxRoc = 1; idxRoc <= numberOfRocs; idxRoc++) {
auto roc = link->roc(idxRoc);
result[roc->rawId()] = aFed.id(); // we know that a det is in one fed only...
}
}
}
return result;
}
std::map<uint32_t, std::vector<sipixelobjects::CablingPathToDetUnit> > SiPixelFedCablingTree::det2PathMap() const {
std::map<uint32_t, std::vector<sipixelobjects::CablingPathToDetUnit> > result;
for (auto im = theFedCablings.begin(); im != theFedCablings.end(); ++im) {
auto const& aFed = im->second;
for (unsigned int idxLink = 1; idxLink <= aFed.numberOfLinks(); idxLink++) {
auto link = aFed.link(idxLink);
if (!link)
continue;
unsigned int numberOfRocs = link->numberOfROCs();
for (unsigned int idxRoc = 1; idxRoc <= numberOfRocs; idxRoc++) {
auto roc = link->roc(idxRoc);
CablingPathToDetUnit path = {aFed.id(), link->id(), roc->idInLink()};
result[roc->rawId()].push_back(path);
}
}
}
return result;
}
void SiPixelFedCablingTree::addFed(const PixelFEDCabling& f) {
int id = f.id();
theFedCablings[id] = f;
}
const PixelFEDCabling* SiPixelFedCablingTree::fed(unsigned int id) const {
auto it = theFedCablings.find(id);
return (it == theFedCablings.end()) ? nullptr : &(*it).second;
}
string SiPixelFedCablingTree::print(int depth) const {
ostringstream out;
if (depth-- >= 0) {
out << theVersion << endl;
for (IMAP it = theFedCablings.begin(); it != theFedCablings.end(); it++) {
out << (*it).second.print(depth);
}
}
out << endl;
return out.str();
}
std::vector<const PixelFEDCabling*> SiPixelFedCablingTree::fedList() const {
std::vector<const PixelFEDCabling*> result;
for (IMAP im = theFedCablings.begin(); im != theFedCablings.end(); im++) {
result.push_back(&(im->second));
}
std::sort(result.begin(), result.end(), [](const PixelFEDCabling* a, const PixelFEDCabling* b) {
return a->id() < b->id();
});
return result;
}
void SiPixelFedCablingTree::addItem(unsigned int fedId, unsigned int linkId, const PixelROC& roc) {
PixelFEDCabling& cabling = theFedCablings[fedId];
if (cabling.id() != fedId)
cabling = PixelFEDCabling(fedId);
cabling.addItem(linkId, roc);
}
const sipixelobjects::PixelROC* SiPixelFedCablingTree::findItem(const CablingPathToDetUnit& path) const {
const PixelROC* roc = nullptr;
const PixelFEDCabling* aFed = fed(path.fed);
if (aFed) {
const PixelFEDLink* aLink = aFed->link(path.link);
if (aLink)
roc = aLink->roc(path.roc);
}
return roc;
}
const sipixelobjects::PixelROC* SiPixelFedCablingTree::findItemInFed(const CablingPathToDetUnit& path,
const PixelFEDCabling* aFed) const {
const PixelROC* roc = nullptr;
const PixelFEDLink* aLink = aFed->link(path.link);
if (aLink)
roc = aLink->roc(path.roc);
return roc;
}
int SiPixelFedCablingTree::checkNumbering() const {
int status = 0;
for (auto im = theFedCablings.begin(); im != theFedCablings.end(); ++im) {
if (im->first != static_cast<int>(im->second.id())) {
status = 1;
std::cout << "PROBLEM WITH FED ID!!" << im->first << " vs: " << im->second.id() << std::endl;
}
im->second.checkLinkNumbering();
}
return status;
}
| 2,379 |
1,346 | <reponame>duruyi/dal
package com.ctrip.framework.dal.cluster.client;
import com.ctrip.framework.dal.cluster.client.cluster.DefaultClusterTest;
import com.ctrip.framework.dal.cluster.client.cluster.DefaultLocalConfigProviderTest;
import com.ctrip.framework.dal.cluster.client.util.CaseInsensitivePropertiesTest;
import com.ctrip.framework.dal.cluster.client.util.ObjectHolderTest;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
/**
* Created by @author zhuYongMing on 2019/11/29.
*/
@RunWith(Suite.class)
@Suite.SuiteClasses({
DefaultClusterTest.class,
DefaultLocalConfigProviderTest.class,
ObjectHolderTest.class,
CaseInsensitivePropertiesTest.class
})
// test: 99/99 passed/all env:fat
public class AllTests {
}
| 280 |
1,471 | <reponame>ethereum/vyper
from math import ceil
from vyper.codegen.core import bytes_data_ptr, ensure_in_memory, get_bytearray_length
from vyper.codegen.ir_node import IRnode
from vyper.codegen.types import BaseType, ByteArrayLike, is_base_type
from vyper.exceptions import CompilerPanic
from vyper.utils import SHA3_BASE, SHA3_PER_WORD, MemoryPositions, bytes_to_int, keccak256
def _check_byteslike(typ, _expr):
if not isinstance(typ, ByteArrayLike) and not is_base_type(typ, "bytes32"):
# NOTE this may be checked at a higher level, but just be safe
raise CompilerPanic("keccak256 only accepts bytes-like objects")
def _gas_bound(num_words):
return SHA3_BASE + num_words * SHA3_PER_WORD
def keccak256_helper(expr, to_hash, context):
_check_byteslike(to_hash.typ, expr)
# Can hash literals
# TODO this is dead code.
if isinstance(to_hash, bytes):
return IRnode.from_list(bytes_to_int(keccak256(to_hash)), typ=BaseType("bytes32"))
# Can hash bytes32 objects
if is_base_type(to_hash.typ, "bytes32"):
return IRnode.from_list(
[
"seq",
["mstore", MemoryPositions.FREE_VAR_SPACE, to_hash],
["sha3", MemoryPositions.FREE_VAR_SPACE, 32],
],
typ=BaseType("bytes32"),
add_gas_estimate=_gas_bound(1),
)
to_hash = ensure_in_memory(to_hash, context)
with to_hash.cache_when_complex("buf") as (b1, to_hash):
data = bytes_data_ptr(to_hash)
len_ = get_bytearray_length(to_hash)
return b1.resolve(
IRnode.from_list(
["sha3", data, len_],
typ="bytes32",
annotation="keccak256",
add_gas_estimate=_gas_bound(ceil(to_hash.typ.maxlen / 32)),
)
)
| 848 |
3,631 | /*
* Copyright 2017 Red Hat, Inc. and/or its affiliates.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.kie.dmn.feel.runtime.functions.twovaluelogic;
import java.math.BigDecimal;
import java.math.MathContext;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import org.junit.Before;
import org.junit.Test;
import org.kie.dmn.feel.runtime.events.InvalidParametersEvent;
import org.kie.dmn.feel.runtime.functions.FunctionTestUtil;
public class StddevFunctionTest {
private NNStddevFunction stddevFunction;
@Before
public void setUp() {
stddevFunction = NNStddevFunction.INSTANCE;
}
@Test
public void invokeNumberNull() {
FunctionTestUtil.assertResult(stddevFunction.invoke((Number) null), null);
}
@Test
public void invokeSingleNumber() {
FunctionTestUtil.assertResultError(stddevFunction.invoke(BigDecimal.TEN), InvalidParametersEvent.class);
FunctionTestUtil.assertResultError(stddevFunction.invoke(10), InvalidParametersEvent.class);
FunctionTestUtil.assertResultError(stddevFunction.invoke(10d), InvalidParametersEvent.class);
FunctionTestUtil.assertResultError(stddevFunction.invoke(10.1d), InvalidParametersEvent.class);
FunctionTestUtil.assertResultError(stddevFunction.invoke(10.1f), InvalidParametersEvent.class);
}
@Test
public void invokeUnconvertableNumber() {
FunctionTestUtil.assertResultError(stddevFunction.invoke(Double.POSITIVE_INFINITY), InvalidParametersEvent.class);
FunctionTestUtil.assertResultError(stddevFunction.invoke(Double.NEGATIVE_INFINITY), InvalidParametersEvent.class);
FunctionTestUtil.assertResultError(stddevFunction.invoke(Double.NaN), InvalidParametersEvent.class);
}
@Test
public void invokeListNull() {
FunctionTestUtil.assertResult(stddevFunction.invoke((List) null), null);
}
@Test
public void invokeListEmpty() {
FunctionTestUtil.assertResult(stddevFunction.invoke(Collections.emptyList()), null);
}
@Test
public void invokeListTypeHeterogenous() {
FunctionTestUtil.assertResultError(stddevFunction.invoke(Arrays.asList(1, "test")), InvalidParametersEvent.class);
}
@Test
public void invokeListParamSupportedTypesWithNull() {
FunctionTestUtil.assertResult(stddevFunction.invoke(Arrays.asList(20, 30, null, (long) 40, null, BigDecimal.TEN)),
new BigDecimal("12.90994448735805628393088466594133", MathContext.DECIMAL128));
}
@Test
public void invokeListWithIntegers() {
FunctionTestUtil.assertResult(stddevFunction.invoke(Arrays.asList(10, 20, 30, 40)),
new BigDecimal("12.90994448735805628393088466594133", MathContext.DECIMAL128));
}
@Test
public void invokeListWithDoubles() {
FunctionTestUtil.assertResult(stddevFunction.invoke(Arrays.asList(10.0d, 20.0d, 30.0d, 40.0d)),
new BigDecimal("12.90994448735805628393088466594133", MathContext.DECIMAL128));
}
@Test
public void invokeArrayNull() {
FunctionTestUtil.assertResult(stddevFunction.invoke((Object[]) null), null);
}
@Test
public void invokeArrayEmpty() {
FunctionTestUtil.assertResult(stddevFunction.invoke(new Object[]{}), null);
}
@Test
public void invokeArrayTypeHeterogenous() {
FunctionTestUtil.assertResultError(stddevFunction.invoke(new Object[]{1, "test"}), InvalidParametersEvent.class);
}
@Test
public void invokeArrayWithIntegers() {
FunctionTestUtil.assertResult(stddevFunction.invoke(new Object[]{10, 20, 30, 40}),
new BigDecimal("12.90994448735805628393088466594133", MathContext.DECIMAL128));
}
@Test
public void invokeArrayWithDoubles() {
FunctionTestUtil.assertResult(stddevFunction.invoke(new Object[]{10.0d, 20.0d, 30.0d, 40.0d}),
new BigDecimal("12.90994448735805628393088466594133", MathContext.DECIMAL128));
}
@Test
public void invokeArrayParamSupportedTypesWithNull() {
FunctionTestUtil.assertResult(stddevFunction.invoke(new Object[]{20, 30, null, (long) 40, null, BigDecimal.TEN}),
new BigDecimal("12.90994448735805628393088466594133", MathContext.DECIMAL128));
}
} | 1,781 |
2,321 | package com.provectus.kafka.ui.service;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import reactor.core.publisher.Flux;
import reactor.core.scheduler.Schedulers;
@Component
@RequiredArgsConstructor
@Slf4j
public class ClustersMetricsScheduler {
private final ClustersStorage clustersStorage;
private final MetricsService metricsService;
@Scheduled(fixedRateString = "${kafka.update-metrics-rate-millis:30000}")
public void updateMetrics() {
Flux.fromIterable(clustersStorage.getKafkaClusters())
.parallel()
.runOn(Schedulers.parallel())
.flatMap(cluster -> {
log.debug("Start getting metrics for kafkaCluster: {}", cluster.getName());
return metricsService.updateCache(cluster)
.doOnSuccess(m -> log.debug("Metrics updated for cluster: {}", cluster.getName()));
})
.then()
.block();
}
}
| 389 |
9,156 | /**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.pulsar.tests.integration.topologies;
import static java.util.stream.Collectors.joining;
import java.util.stream.Stream;
import lombok.Getter;
import lombok.extern.slf4j.Slf4j;
@Slf4j
public class PulsarGeoClusterTestBase extends PulsarTestBase {
@Override
protected final void setup() throws Exception {
setupCluster();
}
@Override
protected final void cleanup() throws Exception {
tearDownCluster();
}
protected void setupCluster() throws Exception {
this.setupCluster("");
}
@Getter
private PulsarGeoCluster geoCluster;
public void setupCluster(String namePrefix) throws Exception {
PulsarClusterSpec.PulsarClusterSpecBuilder[] specBuilders = new PulsarClusterSpec.PulsarClusterSpecBuilder[2];
for (int i = 0; i < 2; i++) {
String clusterName = Stream.of(this.getClass().getSimpleName(), namePrefix, String.valueOf(i),
randomName(5))
.filter(s -> s != null && !s.isEmpty())
.collect(joining("-"));
specBuilders[i] = PulsarClusterSpec.builder().clusterName(clusterName);
}
specBuilders = beforeSetupCluster(specBuilders);
PulsarClusterSpec[] specs = new PulsarClusterSpec[2];
for (int i = 0; i < specBuilders.length; i++) {
specs[i] = specBuilders[i].build();
}
setupCluster0(specs);
}
protected PulsarClusterSpec.PulsarClusterSpecBuilder[] beforeSetupCluster (
PulsarClusterSpec.PulsarClusterSpecBuilder... specBuilder) {
return specBuilder;
}
protected void setupCluster0(PulsarClusterSpec... specs) throws Exception {
incrementSetupNumber();
log.info("Setting up geo cluster with {} local clusters}", specs.length);
this.geoCluster = PulsarGeoCluster.forSpec(specs);
beforeStartCluster();
this.geoCluster.start();
log.info("Geo Cluster is setup!");
}
protected void beforeStartCluster() throws Exception {
// no-op
}
public void tearDownCluster() throws Exception {
markCurrentSetupNumberCleaned();
if (null != this.geoCluster) {
this.geoCluster.stop();
}
}
}
| 1,150 |
468 | #define GLI_INCLUDE_ATI_FRAGMENT_SHADER
enum Main {
GL_FRAGMENT_SHADER_ATI = 0x8920,
GL_REG_0_ATI = 0x8921,
GL_REG_1_ATI = 0x8922,
GL_REG_2_ATI = 0x8923,
GL_REG_3_ATI = 0x8924,
GL_REG_4_ATI = 0x8925,
GL_REG_5_ATI = 0x8926,
GL_REG_6_ATI = 0x8927,
GL_REG_7_ATI = 0x8928,
GL_REG_8_ATI = 0x8929,
GL_REG_9_ATI = 0x892A,
GL_REG_10_ATI = 0x892B,
GL_REG_11_ATI = 0x892C,
GL_REG_12_ATI = 0x892D,
GL_REG_13_ATI = 0x892E,
GL_REG_14_ATI = 0x892F,
GL_REG_15_ATI = 0x8930,
GL_REG_16_ATI = 0x8931,
GL_REG_17_ATI = 0x8932,
GL_REG_18_ATI = 0x8933,
GL_REG_19_ATI = 0x8934,
GL_REG_20_ATI = 0x8935,
GL_REG_21_ATI = 0x8936,
GL_REG_22_ATI = 0x8937,
GL_REG_23_ATI = 0x8938,
GL_REG_24_ATI = 0x8939,
GL_REG_25_ATI = 0x893A,
GL_REG_26_ATI = 0x893B,
GL_REG_27_ATI = 0x893C,
GL_REG_28_ATI = 0x893D,
GL_REG_29_ATI = 0x893E,
GL_REG_30_ATI = 0x893F,
GL_REG_31_ATI = 0x8940,
GL_CON_0_ATI = 0x8941,
GL_CON_1_ATI = 0x8942,
GL_CON_2_ATI = 0x8943,
GL_CON_3_ATI = 0x8944,
GL_CON_4_ATI = 0x8945,
GL_CON_5_ATI = 0x8946,
GL_CON_6_ATI = 0x8947,
GL_CON_7_ATI = 0x8948,
GL_CON_8_ATI = 0x8949,
GL_CON_9_ATI = 0x894A,
GL_CON_10_ATI = 0x894B,
GL_CON_11_ATI = 0x894C,
GL_CON_12_ATI = 0x894D,
GL_CON_13_ATI = 0x894E,
GL_CON_14_ATI = 0x894F,
GL_CON_15_ATI = 0x8950,
GL_CON_16_ATI = 0x8951,
GL_CON_17_ATI = 0x8952,
GL_CON_18_ATI = 0x8953,
GL_CON_19_ATI = 0x8954,
GL_CON_20_ATI = 0x8955,
GL_CON_21_ATI = 0x8956,
GL_CON_22_ATI = 0x8957,
GL_CON_23_ATI = 0x8958,
GL_CON_24_ATI = 0x8959,
GL_CON_25_ATI = 0x895A,
GL_CON_26_ATI = 0x895B,
GL_CON_27_ATI = 0x895C,
GL_CON_28_ATI = 0x895D,
GL_CON_29_ATI = 0x895E,
GL_CON_30_ATI = 0x895F,
GL_CON_31_ATI = 0x8960,
GL_MOV_ATI = 0x8961,
GL_ADD_ATI = 0x8963,
GL_MUL_ATI = 0x8964,
GL_SUB_ATI = 0x8965,
GL_DOT3_ATI = 0x8966,
GL_DOT4_ATI = 0x8967,
GL_MAD_ATI = 0x8968,
GL_LERP_ATI = 0x8969,
GL_CND_ATI = 0x896A,
GL_CND0_ATI = 0x896B,
GL_DOT2_ADD_ATI = 0x896C,
GL_SECONDARY_INTERPOLATOR_ATI = 0x896D,
GL_NUM_FRAGMENT_REGISTERS_ATI = 0x896E,
GL_NUM_FRAGMENT_CONSTANTS_ATI = 0x896F,
GL_NUM_PASSES_ATI = 0x8970,
GL_NUM_INSTRUCTIONS_PER_PASS_ATI = 0x8971,
GL_NUM_INSTRUCTIONS_TOTAL_ATI = 0x8972,
GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI = 0x8973,
GL_NUM_LOOPBACK_COMPONENTS_ATI = 0x8974,
GL_COLOR_ALPHA_PAIRING_ATI = 0x8975,
GL_SWIZZLE_STR_ATI = 0x8976,
GL_SWIZZLE_STQ_ATI = 0x8977,
GL_SWIZZLE_STR_DR_ATI = 0x8978,
GL_SWIZZLE_STQ_DQ_ATI = 0x8979,
GL_SWIZZLE_STRQ_ATI = 0x897A,
GL_SWIZZLE_STRQ_DQ_ATI = 0x897B,
};
enum ATIFS_SrcArgRep {
GL_NONE = 0x0,
GL_RED = 0x1903,
GL_GREEN = 0x1904,
GL_BLUE = 0x1905,
GL_ALPHA = 0x1906,
};
enum Mask_ATIFS_DstMask {
GL_NONE = 0x0,
GL_RED_BIT_ATI = 0x00000001,
GL_GREEN_BIT_ATI = 0x00000002,
GL_BLUE_BIT_ATI = 0x00000004,
};
enum Mask_ATIFS_DStMod {
GL_NONE = 0x0,
GL_2X_BIT_ATI = 0x00000001,
GL_4X_BIT_ATI = 0x00000002,
GL_8X_BIT_ATI = 0x00000004,
GL_HALF_BIT_ATI = 0x00000008,
GL_QUARTER_BIT_ATI = 0x00000010,
GL_EIGHTH_BIT_ATI = 0x00000020,
GL_SATURATE_BIT_ATI = 0x00000040,
};
enum Mask_ATIFS_SrcMod {
GL_NONE = 0x0,
GL_2X_BIT_ATI = 0x00000001,
GL_COMP_BIT_ATI = 0x00000002,
GL_NEGATE_BIT_ATI = 0x00000004,
GL_BIAS_BIT_ATI = 0x00000008,
};
GLuint glGenFragmentShadersATI (GLuint range);
void glBindFragmentShaderATI (GLuint id);
void glDeleteFragmentShaderATI (GLuint id);
void glBeginFragmentShaderATI (void);
void glEndFragmentShaderATI (void);
void glPassTexCoordATI (GLenum[Main] dst, GLenum[Main] coord, GLenum[Main] swizzle);
void glSampleMapATI (GLenum[Main] dst, GLenum[Main] interp, GLenum[Main] swizzle);
void glColorFragmentOp1ATI (GLenum[Main] op, GLenum[Main] dst, GLbitfield[Mask_ATIFS_DstMask] dstMask, GLbitfield[Mask_ATIFS_DStMod] dstMod, GLenum[Main] arg1, GLenum[ATIFS_SrcArgRep] arg1Rep, GLbitfield[Mask_ATIFS_SrcMod] arg1Mod);
void glColorFragmentOp2ATI (GLenum[Main] op, GLenum[Main] dst, GLbitfield[Mask_ATIFS_DstMask] dstMask, GLbitfield[Mask_ATIFS_DStMod] dstMod, GLenum[Main] arg1, GLenum[ATIFS_SrcArgRep] arg1Rep, GLbitfield[Mask_ATIFS_SrcMod] arg1Mod, GLenum[Main] arg2, GLenum[ATIFS_SrcArgRep] arg2Rep, GLbitfield[Mask_ATIFS_SrcMod] arg2Mod);
void glColorFragmentOp3ATI (GLenum[Main] op, GLenum[Main] dst, GLbitfield[Mask_ATIFS_DstMask] dstMask, GLbitfield[Mask_ATIFS_DStMod] dstMod, GLenum[Main] arg1, GLenum[ATIFS_SrcArgRep] arg1Rep, GLbitfield[Mask_ATIFS_SrcMod] arg1Mod, GLenum[Main] arg2, GLenum[ATIFS_SrcArgRep] arg2Rep, GLbitfield[Mask_ATIFS_SrcMod] arg2Mod, GLenum[Main] arg3, GLenum[ATIFS_SrcArgRep] arg3Rep, GLbitfield[Mask_ATIFS_SrcMod] arg3Mod);
void glAlphaFragmentOp1ATI (GLenum[Main] op, GLenum[Main] dst, GLbitfield[Mask_ATIFS_DStMod] dstMod, GLenum[Main] arg1, GLenum[ATIFS_SrcArgRep] arg1Rep, GLbitfield[Mask_ATIFS_SrcMod] arg1Mod);
void glAlphaFragmentOp2ATI (GLenum[Main] op, GLenum[Main] dst, GLbitfield[Mask_ATIFS_DStMod] dstMod, GLenum[Main] arg1, GLenum[ATIFS_SrcArgRep] arg1Rep, GLbitfield[Mask_ATIFS_SrcMod] arg1Mod, GLenum[Main] arg2, GLenum[ATIFS_SrcArgRep] arg2Rep, GLbitfield[Mask_ATIFS_SrcMod] arg2Mod);
void glAlphaFragmentOp3ATI (GLenum[Main] op, GLenum[Main] dst, GLbitfield[Mask_ATIFS_DStMod] dstMod, GLenum[Main] arg1, GLenum[ATIFS_SrcArgRep] arg1Rep, GLbitfield[Mask_ATIFS_SrcMod] arg1Mod, GLenum[Main] arg2, GLenum[ATIFS_SrcArgRep] arg2Rep, GLbitfield[Mask_ATIFS_SrcMod] arg2Mod, GLenum[Main] arg3, GLenum[ATIFS_SrcArgRep] arg3Rep, GLbitfield[Mask_ATIFS_SrcMod] arg3Mod);
void glSetFragmentShaderConstantATI (GLenum[Main] dst, const GLfloat *value);
| 5,777 |
692 | /*
Copyright (C) 2002-2006 Quantum ESPRESSO group
This file is distributed under the terms of the
GNU General Public License. See the file `License'
in the root directory of the present distribution,
or http://www.gnu.org/copyleft/gpl.txt .
*/
#include <sys/time.h>
#include <sys/resource.h>
#include <unistd.h>
#include "c_defs.h"
double F77_FUNC(cclock,CCLOCK)()
/* Return the second elapsed since Epoch (00:00:00 UTC, January 1, 1970)
*/
{
struct timeval tmp;
double sec;
gettimeofday( &tmp, (struct timezone *)0 );
sec = tmp.tv_sec + ((double)tmp.tv_usec)/1000000.0;
return sec;
}
double F77_FUNC(scnds,SCNDS) ( )
/* Return the cpu time associated to the current process
*/
{
static struct rusage T;
getrusage(RUSAGE_SELF, &T);
return ((double)T.ru_utime.tv_sec + ((double)T.ru_utime.tv_usec)/1000000.0);
}
| 351 |
4,812 | #undef DEF
#include "header.h"
static int foo() {
return 0;
}
int main() {
f1();
long *x;
f2(&x);
double *y;
f2(&y);
f3();
return foo();
}
| 76 |
764 | {"symbol": "MIB","address": "0x146D8D942048ad517479C9bab1788712Af180Fde","overview":{"en": ""},"email": "<EMAIL>","website": "https://www.mibcoin.io/","state": "NORMAL","links": {"blog": "","twitter": "https://twitter.com/mibcoin","telegram": "https://t.me/joinchat/DNeZgA-RivbU3EOQfl-wIQ","github": ""}} | 126 |
669 | import onnx
from onnx import OperatorSetIdProto, TensorProto, helper
onnxdomain = OperatorSetIdProto()
onnxdomain.version = 12
# The empty string ("") or absence of this field implies the operator set that is defined as part of the ONNX specification.
onnxdomain.domain = ""
msdomain = OperatorSetIdProto()
msdomain.version = 1
msdomain.domain = "com.microsoft"
opsets = [onnxdomain, msdomain]
def save(model_path, nodes, inputs, outputs, initializers):
graph = helper.make_graph(nodes, "TransposeMatMulTest", inputs, outputs, initializers)
model = helper.make_model(graph, opset_imports=opsets, producer_name="onnxruntime-test")
onnx.save(model, model_path)
def gen_from_transpose_scale_matmul(model_path):
nodes = [
helper.make_node("Transpose", ["input_0"], ["transposed_input_0"]),
helper.make_node(
"FusedMatMul",
["transposed_input_0", "input_1"],
["output"],
"FusedMatMul",
"",
msdomain.domain,
alpha=3.0,
transA=1,
),
]
inputs = [
helper.make_tensor_value_info("input_0", TensorProto.FLOAT, ["M", "K"]),
helper.make_tensor_value_info("input_1", TensorProto.FLOAT, ["K", "N"]),
]
outputs = [helper.make_tensor_value_info("output", TensorProto.FLOAT, ["M", "N"])]
save(model_path, nodes, inputs, outputs, [])
gen_from_transpose_scale_matmul("transpose_matmul_2d_fusion_from_transpose_scale_matmul.onnx")
def gen_invalid_default_perm(model_path):
nodes = [
helper.make_node("Transpose", ["input_0"], ["transposed_input_0"]),
helper.make_node("MatMul", ["transposed_input_0", "input_1"], ["output"]),
]
inputs = [
helper.make_tensor_value_info("input_0", TensorProto.FLOAT, ["K", "M", 3, 2]),
helper.make_tensor_value_info("input_1", TensorProto.FLOAT, [2, 3, "K", "N"]),
]
outputs = [helper.make_tensor_value_info("output", TensorProto.FLOAT, [2, 3, "M", "N"])]
save(model_path, nodes, inputs, outputs, [])
gen_invalid_default_perm("transpose_matmul_4d_fusion_invalid_default_perm.onnx")
def gen_with_preserved_transpose(model_path):
nodes = [
helper.make_node("Transpose", ["input_0"], ["transposed_input_0"]),
helper.make_node("MatMul", ["transposed_input_0", "input_1"], ["output_0"]),
helper.make_node("Identity", ["transposed_input_0"], ["output_1"]),
]
inputs = [
helper.make_tensor_value_info("input_0", TensorProto.FLOAT, ["K", "M"]),
helper.make_tensor_value_info("input_1", TensorProto.FLOAT, ["K", "N"]),
]
outputs = [
helper.make_tensor_value_info("output_0", TensorProto.FLOAT, ["M", "N"]),
helper.make_tensor_value_info("output_1", TensorProto.FLOAT, ["M", "K"]),
]
save(model_path, nodes, inputs, outputs, [])
gen_with_preserved_transpose("transpose_matmul_2d_fusion_with_preserved_transpose.onnx")
def gen_transpose_fusion_with_cast(model_path):
cast_1 = helper.make_node("Cast", ["input_1"], ["casted_input_1"], "Cast_1", to=TensorProto.FLOAT16)
transpose_0 = helper.make_node(
"Transpose",
["input_0"],
["transposed_input_0"],
"Transpose_0",
perm=[0, 1, 3, 2],
)
cast_0 = helper.make_node(
"Cast",
["transposed_input_0"],
["transposed_casted_input_0"],
"Cast_0",
to=TensorProto.FLOAT16,
)
matmul_0 = helper.make_node(
"MatMul",
["transposed_casted_input_0", "casted_input_1"],
["output_0"],
"MatMul_0",
)
nodes = [transpose_0, cast_0, cast_1, matmul_0]
input_0 = helper.make_tensor_value_info("input_0", TensorProto.FLOAT, [3, 2, "N", "N"])
input_1 = helper.make_tensor_value_info("input_1", TensorProto.FLOAT, [3, 2, "N", "N"])
inputs = [input_0, input_1]
output_0 = helper.make_tensor_value_info("output_0", TensorProto.FLOAT16, [3, 2, "N", "N"])
outputs = [output_0]
# Testcase0: First input of MatMul is transposed
save(model_path + "0.onnx", nodes, inputs, outputs, [])
# Testcase1: Re-arragne nodes so that the transpose is on second input of matmul
transpose_1 = helper.make_node(
"Transpose",
["input_1"],
["transposed_input_1"],
"Transpose_1",
perm=[0, 1, 3, 2],
)
cast_1.input[0] = "transposed_input_1"
cast_1.output[0] = "transposed_casted_input_1"
cast_0.input[0] = "input_0"
cast_0.output[0] = "casted_input_0"
matmul_0.input[0] = cast_0.output[0]
matmul_0.input[1] = cast_1.output[0]
nodes = [cast_0, transpose_1, cast_1, matmul_0]
save(model_path + "1.onnx", nodes, inputs, outputs, [])
# Testcase2: Create an example with two Cast-ed Transpose-ed inputs feeding a MatMul
cast_0.input[0] = "transposed_input_0"
cast_0.output[0] = "transposed_casted_input_0"
matmul_0.input[0] = cast_0.output[0]
nodes = [transpose_0, cast_0, transpose_1, cast_1, matmul_0]
save(model_path + "2.onnx", nodes, inputs, outputs, [])
# Testcase3: Create a second MatMul node using the outputs from the same Cast nodes as before
# with each Cast node feeding more than one node.
nodes.append(
helper.make_node(
"MatMul",
["transposed_casted_input_0", "transposed_casted_input_1"],
["output_1"],
"MatMul_1",
)
)
output_1 = helper.make_tensor_value_info("output_1", TensorProto.FLOAT16, [3, 2, "N", "N"])
outputs.append(output_1)
save(model_path + "3.onnx", nodes, inputs, outputs, [])
# Testcase4: The second MatMul uses transposed inputs without cast.
nodes.pop()
outputs.pop()
matmul_1 = helper.make_node("MatMul", ["transposed_input_0", "transposed_input_1"], ["output_1"], "MatMul_1")
nodes.append(matmul_1)
outputs.append(helper.make_tensor_value_info("output_1", TensorProto.FLOAT, [3, 2, "N", "N"]))
save(model_path + "4.onnx", nodes, inputs, outputs, [])
# Testcase5: Each MatMul uses outputs from a Cast and a Transpose
input_0.type.tensor_type.elem_type = TensorProto.FLOAT16
cast_0.attribute[0].i = TensorProto.FLOAT
matmul_0.input[0] = "transposed_input_0"
matmul_1.input[0] = "transposed_casted_input_0"
output_1.type.tensor_type.elem_type = TensorProto.FLOAT
save(model_path + "5.onnx", nodes, inputs, outputs, [])
gen_transpose_fusion_with_cast("transpose_cast_matmul_4d_fusion")
def gen_transpose_fusion_invalid_datatype(model_path, datatype):
nodes = [
helper.make_node("Transpose", ["input_0"], ["transposed_input_0"], perm=[0, 1, 3, 2]),
helper.make_node("MatMul", ["transposed_input_0", "input_1"], ["output"]),
]
inputs = [
helper.make_tensor_value_info("input_0", datatype, [2, 3, "K", "M"]),
helper.make_tensor_value_info("input_1", datatype, [2, 3, "K", "N"]),
]
outputs = [helper.make_tensor_value_info("output", datatype, [2, 3, "M", "N"])]
save(model_path, nodes, inputs, outputs, [])
gen_transpose_fusion_invalid_datatype("transpose_matmul_4d_fusion_invalid_datatype_int32.onnx", TensorProto.INT32)
gen_transpose_fusion_invalid_datatype("transpose_matmul_4d_fusion_invalid_datatype_int64.onnx", TensorProto.INT64)
def gen_transpose_matmul_trans_batch_fusion(model_path):
nodes = [
helper.make_node("Transpose", ["input_0"], ["transposed_input_0"], perm=[1, 2, 0]),
helper.make_node("Transpose", ["input_1"], ["transposed_input_1"], perm=[0, 2, 1]),
helper.make_node("MatMul", ["transposed_input_0", "transposed_input_1"], ["output"]),
]
inputs = [
helper.make_tensor_value_info("input_0", TensorProto.FLOAT, ["K", 3, "M"]),
helper.make_tensor_value_info("input_1", TensorProto.FLOAT, [3, "N", "K"]),
]
outputs = [helper.make_tensor_value_info("output", TensorProto.FLOAT, [3, "M", "N"])]
save(model_path + "1.onnx", nodes, inputs, outputs, [])
nodes = [
helper.make_node("Transpose", ["input_0"], ["transposed_input_0"], perm=[1, 2, 0, 3]),
helper.make_node("Transpose", ["input_0"], ["transposed_input_1"], perm=[1, 2, 3, 0]),
helper.make_node("MatMul", ["transposed_input_0", "transposed_input_1"], ["output"]),
]
inputs = [
helper.make_tensor_value_info("input_0", TensorProto.FLOAT, ["M", 2, 3, "K"]),
]
outputs = [helper.make_tensor_value_info("output", TensorProto.FLOAT, [2, 3, "M", "M"])]
save(model_path + "2.onnx", nodes, inputs, outputs, [])
nodes = [
helper.make_node("Transpose", ["input_0"], ["transposed_input_0"], perm=[1, 2, 3, 0]),
helper.make_node(
"FusedMatMul",
["transposed_input_0", "input_1"],
["output"],
"FusedMatMul",
"",
msdomain.domain,
alpha=3.0,
transA=1,
transBatchB=1,
),
]
inputs = [
helper.make_tensor_value_info("input_0", TensorProto.FLOAT, ["M", 2, 3, "K"]),
helper.make_tensor_value_info("input_1", TensorProto.FLOAT, ["K", 2, 3, "N"]),
]
outputs = [helper.make_tensor_value_info("output", TensorProto.FLOAT, [2, 3, "M", "M"])]
save(model_path + "3.onnx", nodes, inputs, outputs, [])
gen_transpose_matmul_trans_batch_fusion("transpose_matmul_trans_batch_fusion")
def gen_transpose_matmul_trans_batch_fusion_invalid_cases(model_path):
nodes = [
helper.make_node("Transpose", ["input_0"], ["transposed_input_0"], perm=[1, 2, 0]),
helper.make_node("MatMul", ["transposed_input_0", "input_1"], ["output"]),
]
inputs = [
helper.make_tensor_value_info("input_0", TensorProto.FLOAT, ["K", 3, "M"]),
helper.make_tensor_value_info("input_1", TensorProto.FLOAT, [2, 3, "K", "N"]),
]
outputs = [helper.make_tensor_value_info("output", TensorProto.FLOAT, [2, 3, "M", "N"])]
save(model_path + "1.onnx", nodes, inputs, outputs, [])
nodes = [
helper.make_node("Transpose", ["input_0"], ["transposed_input_0"], perm=[0, 2, 1, 3]),
helper.make_node("Transpose", ["input_0"], ["transposed_input_1"], perm=[0, 2, 3, 1]),
helper.make_node("MatMul", ["transposed_input_0", "transposed_input_1"], ["output"]),
]
inputs = [
helper.make_tensor_value_info("input_0", TensorProto.FLOAT, [2, "M", 3, "K"]),
]
outputs = [helper.make_tensor_value_info("output", TensorProto.FLOAT, [2, 3, "M", "M"])]
save(model_path + "2.onnx", nodes, inputs, outputs, [])
nodes = [
helper.make_node("Transpose", ["input_0"], ["transposed_input_0"], perm=[1, 2, 3, 0]),
helper.make_node(
"FusedMatMul",
["transposed_input_0", "input_1"],
["output"],
"FusedMatMul",
"",
msdomain.domain,
alpha=3.0,
transBatchA=1,
),
]
inputs = [
helper.make_tensor_value_info("input_0", TensorProto.FLOAT, ["K", "M", 2, 3]),
helper.make_tensor_value_info("input_1", TensorProto.FLOAT, [2, 3, "K", "N"]),
]
outputs = [helper.make_tensor_value_info("output", TensorProto.FLOAT, [2, 3, "M", "M"])]
save(model_path + "3.onnx", nodes, inputs, outputs, [])
gen_transpose_matmul_trans_batch_fusion_invalid_cases("transpose_matmul_trans_batch_fusion_invalid_case")
| 5,248 |
401 | <filename>anchore/anchore_auth.py
import os
import json
import requests
import base64
import urllib
import logging
_logger = logging.getLogger(__name__)
def anchore_auth_init(username, password, auth_file, client_info_url, token_url, conn_timeout, max_retries):
if not username or not password or not auth_file or not client_info_url or not token_url or not conn_timeout or not max_retries:
return (False)
anchore_auth = {'username': '',
'password': '',
'max_retries': int(max_retries),
'conn_timeout': int(conn_timeout),
'client_info_url': client_info_url,
'token_url': token_url,
'auth_file': auth_file,
'client_info': {},
'token_info': {},
'user_info': {},
}
if os.path.exists(auth_file):
try:
with open(auth_file, 'r') as FH:
loaded_anchore_auth = json.loads(FH.read())
anchore_auth.update(loaded_anchore_auth)
except:
pass
if anchore_auth['username'] != username or anchore_auth['password'] != password:
anchore_auth['username'] = username
anchore_auth['password'] = password
anchore_auth_invalidate(anchore_auth)
if not anchore_auth_save(anchore_auth, auth_file):
_logger.error("could not save authentication details (" + auth_file + ")")
return (False)
return (anchore_auth)
def get_current_user_info(anchore_auth):
"""
Return the metadata about the current user as supplied by the anchore.io service. Includes permissions and tier access.
:return: Dict of user metadata
"""
user_url = anchore_auth['client_info_url'] + '/' + anchore_auth['username']
user_timeout = 60
retries = 3
result = requests.get(user_url, headers={'x-anchore-password': anchore_auth['password']})
if result.status_code == 200:
user_data = json.loads(result.content)
else:
raise requests.HTTPError('Error response from service: {}'.format(result.status_code))
return user_data
def anchore_auth_invalidate(anchore_auth):
if 'client_info' in anchore_auth:
anchore_auth['client_info'] = {}
if 'token_info' in anchore_auth:
anchore_auth['token_info'] = {}
if 'user_info' in anchore_auth:
anchore_auth['user_info'] = {}
return (True)
def anchore_auth_save(anchore_auth, auth_file):
if not anchore_auth or not auth_file:
return (False)
try:
with os.fdopen(os.open(auth_file, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0600), 'w') as OFH:
OFH.write(json.dumps(anchore_auth))
except:
return (False)
return (True)
def anchore_auth_refresh(anchore_auth, forcerefresh=False):
ret = {'success': False, 'text': "", 'status_code': 0}
if not anchore_auth:
ret['text'] = json.dumps("no anchore_auth token given as input")
return (False, ret)
new_anchore_auth = {}
new_anchore_auth.update(anchore_auth)
username = anchore_auth['username']
password = <PASSWORD>['password']
url_username = urllib.quote_plus(username)
url_password = urllib.quote_plus(password)
client_info_url = anchore_auth['client_info_url']
token_url = anchore_auth['token_url']
client_info = anchore_auth['client_info']
token_info = anchore_auth['token_info']
auth_file = anchore_auth['auth_file']
user_info = anchore_auth['user_info']
conn_timeout = int(anchore_auth['conn_timeout'])
if not client_info:
# get client info
url = client_info_url + "/" + username
headers = {'x-anchore-password': password}
try:
r = requests.get(url, headers=headers, timeout=conn_timeout)
except:
# print "request timed out"
ret['text'] = json.dumps("connection timed out: increase anchore_auth_conn_timeout higher or try again")
return (False, ret)
ret['text'] = r.text
ret['status_code'] = r.status_code
if r.status_code == 200:
new_anchore_auth['client_info'] = json.loads(r.text)['clients'][0]
client_info = new_anchore_auth['client_info']
ret['success'] = True
elif r.status_code == 401:
# print "bad username/password!"
return (False, ret)
else:
# print "unknown login error: "
return (False, ret)
else:
pass
# print "skipping client_info get"
b64bearertok = base64.b64encode(client_info['client_id'] + ":" + client_info['client_secret'])
if not token_info:
# get a token set
payload = "grant_type=password&username=" + url_username + "&password=" + url_password
headers = {
'content-type': "application/x-www-form-urlencoded",
'authorization': "Basic " + b64bearertok,
'cache-control': "no-cache",
}
try:
r = requests.post(token_url, headers=headers, data=payload)
except:
# print "request timed out"
ret['text'] = json.dumps("connection timed out: increase anchore_auth_conn_timeout higher or try again")
return (False, ret)
ret['text'] = r.text
ret['status_code'] = r.status_code
if r.status_code == 200:
new_anchore_auth['token_info'] = json.loads(r.text)
ret['success'] = True
else:
# print "unknown token get error: "
return (False, ret)
elif forcerefresh:
# print "refreshening"
payload = "grant_type=refresh_token&refresh_token=" + token_info['refreshToken']
headers = {
'content-type': "application/x-www-form-urlencoded",
'authorization': "Basic " + b64bearertok,
'cache-control': "no-cache",
}
try:
r = requests.post(token_url, headers=headers, data=payload)
except:
# print "request timed out"
ret['text'] = json.dumps("connection timed out: increase anchore_auth_conn_timeout higher or try again")
return (False, ret)
ret['text'] = r.text
ret['status_code'] = r.status_code
if r.status_code == 200:
new_anchore_auth['token_info'] = json.loads(r.text)
ret['success'] = True
else:
# print "refresh token invalid"
return (False, ret)
else:
pass
# print "skipping token_info get"
if not user_info or forcerefresh:
# Update the cached local user data
new_user_info = get_current_user_info(anchore_auth)
new_anchore_auth['user_info'] = new_user_info
if anchore_auth != new_anchore_auth:
anchore_auth.update(new_anchore_auth)
anchore_auth_save(anchore_auth, auth_file)
else:
pass
# print "skipping save"
return (True, ret)
def anchore_auth_get(anchore_auth, url, timeout=None, retries=None):
# make a request
if not timeout:
timeout = int(anchore_auth['conn_timeout'])
if not retries:
retries = int(anchore_auth['max_retries'])
timeout = int(timeout)
retries = int(retries)
ret = {'status_code': 1, 'text': '', 'success': False}
success = False
count = 0
# retries = anchore_auth['max_retries']
while (not success and count < retries):
count += 1
_logger.debug("get attempt " + str(count) + " of " + str(retries))
try:
rc, record = anchore_auth_refresh(anchore_auth, forcerefresh=False)
if not rc:
# print "cannot get valid auth token"
ret['text'] = record['text']
return (ret)
else:
token_info = anchore_auth['token_info']
accessToken = token_info['accessToken']
headers = {"Authorization": "Bearer " + accessToken, "Cache-Control": "no-cache"}
_logger.debug("making authenticated request to url: " + str(url))
r = requests.get(url, headers=headers, timeout=timeout)
_logger.debug("\tresponse status_code: " + str(r.status_code))
if r.status_code == 401:
_logger.debug("\tresponse body: " + str(r.text))
resp = json.loads(r.text)
if 'name' in resp and resp['name'] == 'invalid_token':
# print "bad tok - attempting to refresh"
rc, record = anchore_auth_refresh(anchore_auth, forcerefresh=True)
if not rc:
# start over and retry
# print "refresh token failed, invalidating tok and starting over"
anchore_auth_invalidate(anchore_auth)
else:
success = True
ret['success'] = False
ret['err_msg'] = 'not authorized'
elif r.status_code == 200:
success = True
ret['success'] = True
elif r.status_code == 404:
success = True
ret['success'] = False
elif r.status_code == 403:
success = True
ret['success'] = False
ret['err_msg'] = 'Access denied, check your access tier'
ret['status_code'] = r.status_code
ret['text'] = r.text
except requests.exceptions.ConnectTimeout as err:
_logger.debug("attempt failed: " + str(err))
ret['text'] = "server error: timed_out: " + str(err)
# return(ret)
except Exception as err:
_logger.debug("attempt failed: " + str(err))
ret['text'] = "server error: " + str(err)
return (ret)
| 4,688 |
335 | {
"word": "Insight",
"definitions": [
"The capacity to gain an accurate and deep understanding of someone or something.",
"An accurate and deep understanding.",
"Awareness by a mentally ill person that their mental experiences are not based in external reality."
],
"parts-of-speech": "Noun"
} | 109 |
621 | <reponame>Ashraf-Ali-aa/carina<filename>carina-utils/src/main/java/com/qaprosoft/carina/core/foundation/utils/StringGenerator.java
/*******************************************************************************
* Copyright 2013-2020 QaProSoft (http://www.qaprosoft.com).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*******************************************************************************/
package com.qaprosoft.carina.core.foundation.utils;
import java.util.Random;
import org.apache.commons.lang3.RandomStringUtils;
public class StringGenerator {
private static final String ALPHABET = "abcdefghijklmnopqrstuvwxyz";
private static final String GENERATE = "$generate";
private static final Random RANDOM = new Random();
public static String generateWord(int keySize) {
StringBuilder result = new StringBuilder();
String base = generateBase(keySize);
int position = RANDOM.nextInt(ALPHABET.length() - 1);
int sign = -1;
for (int i = 0; i < keySize; i++) {
int step = Integer.parseInt(base.substring(i, i + 1)) * sign;
if (position + step > 0 && position + step < ALPHABET.length() - 1) {
position += step;
} else {
position -= step;
}
result.append(ALPHABET.charAt(position));
sign *= -1;
}
return result.toString();
}
public static String generateNumeric(int keySize) {
return RandomStringUtils.randomNumeric(keySize);
}
public static String generateWordAN(int keySize) {
return RandomStringUtils.randomAlphanumeric(keySize);
}
private static String generateBase(int keySize) {
StringBuilder base = new StringBuilder();
for (int i = 0; i < keySize; i++) {
base.append(RANDOM.nextInt(9));
}
return base.toString();
}
public static void generateInputParameters(Object[] params) {
for (int i = 0; i < params.length; i++) {
if (params[i].toString().contains(GENERATE)) {
String newLine = params[i].toString();
int size = Integer.parseInt(newLine.split(":")[1]);
newLine = newLine.substring(0, newLine.indexOf(GENERATE));
newLine += generateWord(size);
params[i] = newLine;
}
}
}
public static String getUniqueItemName() {
return "qatest-" + System.nanoTime();
}
public static String generateEmail() {
return generateWord(10) + "@gmail.com";
}
}
| 1,165 |
608 | package com.google.android.stardroid;
import android.accounts.AccountManager;
import android.content.Context;
import android.content.SharedPreferences;
import android.content.res.AssetManager;
import android.content.res.Resources;
import android.hardware.SensorManager;
import android.location.LocationManager;
import android.net.ConnectivityManager;
import android.util.Log;
import androidx.core.content.ContextCompat;
import androidx.preference.PreferenceManager;
import com.google.android.stardroid.control.AstronomerModel;
import com.google.android.stardroid.control.AstronomerModelImpl;
import com.google.android.stardroid.control.MagneticDeclinationCalculator;
import com.google.android.stardroid.control.RealMagneticDeclinationCalculator;
import com.google.android.stardroid.control.ZeroMagneticDeclinationCalculator;
import com.google.android.stardroid.layers.EclipticLayer;
import com.google.android.stardroid.layers.GridLayer;
import com.google.android.stardroid.layers.HorizonLayer;
import com.google.android.stardroid.layers.LayerManager;
import com.google.android.stardroid.layers.MeteorShowerLayer;
import com.google.android.stardroid.layers.NewConstellationsLayer;
import com.google.android.stardroid.layers.NewMessierLayer;
import com.google.android.stardroid.layers.NewStarsLayer;
import com.google.android.stardroid.layers.PlanetsLayer;
import com.google.android.stardroid.layers.SkyGradientLayer;
import com.google.android.stardroid.util.Analytics;
import com.google.android.stardroid.util.AnalyticsInterface;
import com.google.android.stardroid.util.MiscUtil;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import javax.inject.Named;
import javax.inject.Singleton;
import dagger.Module;
import dagger.Provides;
/**
* Dagger module
* Created by johntaylor on 3/26/16.
*/
@Module
public class ApplicationModule {
private static final String TAG = MiscUtil.getTag(ApplicationModule.class);
private StardroidApplication app;
public ApplicationModule(StardroidApplication app) {
Log.d(TAG, "Creating application module for " + app);
this.app = app;
}
@Provides
@Singleton
StardroidApplication provideApplication() {
return app;
}
@Provides
Context provideContext() {
return app;
}
@Provides
@Singleton
SharedPreferences provideSharedPreferences() {
Log.d(TAG, "Providing shared preferences");
return PreferenceManager.getDefaultSharedPreferences(app);
}
@Provides
@Singleton
LocationManager provideLocationManager() {
return ContextCompat.getSystemService(app, LocationManager.class);
}
@Provides
@Singleton
AstronomerModel provideAstronomerModel(
@Named("zero") MagneticDeclinationCalculator magneticDeclinationCalculator) {
return new AstronomerModelImpl(magneticDeclinationCalculator);
}
@Provides
@Singleton
@Named("zero")
MagneticDeclinationCalculator provideDefaultMagneticDeclinationCalculator() {
return new ZeroMagneticDeclinationCalculator();
}
@Provides
@Singleton
@Named("real")
MagneticDeclinationCalculator provideRealMagneticDeclinationCalculator() {
return new RealMagneticDeclinationCalculator();
}
@Provides
@Singleton
AnalyticsInterface provideAnalytics(Analytics analytics) {
return analytics;
}
@Provides
@Singleton
ExecutorService provideBackgroundExecutor() {
return new ScheduledThreadPoolExecutor(1);
}
@Provides
@Singleton
AssetManager provideAssetManager() {
return app.getAssets();
}
@Provides
@Singleton
Resources provideResources() {
return app.getResources();
}
@Provides
@Singleton
SensorManager provideSensorManager() {
return ContextCompat.getSystemService(app, SensorManager.class);
}
@Provides
@Singleton
ConnectivityManager provideConnectivityManager() {
return ContextCompat.getSystemService(app, ConnectivityManager.class);
}
@Provides
@Singleton
AccountManager provideAccountManager(Context context) {
return AccountManager.get(context);
}
@Provides @Singleton
LayerManager provideLayerManager(
AssetManager assetManager, Resources resources, AstronomerModel model,
SharedPreferences preferences) {
Log.i(TAG, "Initializing LayerManager");
LayerManager layerManager = new LayerManager(preferences);
layerManager.addLayer(new NewStarsLayer(assetManager, resources));
layerManager.addLayer(new NewMessierLayer(assetManager, resources));
layerManager.addLayer(new NewConstellationsLayer(assetManager, resources));
layerManager.addLayer(new PlanetsLayer(model, resources, preferences));
layerManager.addLayer(new MeteorShowerLayer(model, resources));
layerManager.addLayer(new GridLayer(resources, 24, 9));
layerManager.addLayer(new HorizonLayer(model, resources));
layerManager.addLayer(new EclipticLayer(resources));
layerManager.addLayer(new SkyGradientLayer(model, resources));
// layerManager.addLayer(new IssLayer(resources, model));
layerManager.initialize();
return layerManager;
}
}
| 1,552 |
686 | <reponame>mirkobrombin/wine<filename>libs/port/poll.c
/*
* poll function
*
* Copyright 2008 <NAME>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "config.h"
#include "wine/port.h"
#ifndef HAVE_POLL
#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
/* we can't include winsock2.h here so we have to duplicate the definitions for Windows */
#if defined(__MINGW32__) || defined(_MSC_VER)
#define FD_SETSIZE 64
struct __ms_timeval
{
long tv_sec;
long tv_usec;
};
#define timeval __ms_timeval
typedef struct
{
unsigned int fd_count;
int fd_array[FD_SETSIZE]; /* an array of SOCKETs */
} fd_set;
#define FD_ZERO(set) ((set)->fd_count = 0)
#define FD_ISSET(fd, set) __WSAFDIsSet((fd), (set))
#define FD_SET(fd, set) do { if ((set)->fd_count < FD_SETSIZE) (set)->fd_array[(set)->fd_count++]=(fd); } while(0)
int __stdcall select(int,fd_set*,fd_set*,fd_set*,const struct timeval*);
int __stdcall __WSAFDIsSet(int,fd_set*);
#endif
int poll( struct pollfd *fds, unsigned int count, int timeout )
{
fd_set read_set, write_set, except_set;
unsigned int i;
int maxfd = -1, ret;
FD_ZERO( &read_set );
FD_ZERO( &write_set );
FD_ZERO( &except_set );
for (i = 0; i < count; i++)
{
if (fds[i].fd == -1) continue;
if (fds[i].events & (POLLIN|POLLPRI)) FD_SET( fds[i].fd, &read_set );
if (fds[i].events & POLLOUT) FD_SET( fds[i].fd, &write_set );
FD_SET( fds[i].fd, &except_set ); /* POLLERR etc. are always selected */
if (fds[i].fd > maxfd) maxfd = fds[i].fd;
}
if (timeout != -1)
{
struct timeval tv;
tv.tv_sec = timeout / 1000;
tv.tv_usec = timeout % 1000;
ret = select( maxfd + 1, &read_set, &write_set, &except_set, &tv );
}
else ret = select( maxfd + 1, &read_set, &write_set, &except_set, NULL );
if (ret >= 0)
{
for (i = 0; i < count; i++)
{
fds[i].revents = 0;
if (fds[i].fd == -1) continue;
if (FD_ISSET( fds[i].fd, &read_set )) fds[i].revents |= POLLIN;
if (FD_ISSET( fds[i].fd, &write_set )) fds[i].revents |= POLLOUT;
if (FD_ISSET( fds[i].fd, &except_set )) fds[i].revents |= POLLERR;
}
}
return ret;
}
#endif /* HAVE_POLL */
| 1,299 |
1,444 | <filename>Mage/src/main/java/mage/abilities/condition/common/TransformedCondition.java
package mage.abilities.condition.common;
import mage.abilities.Ability;
import mage.abilities.condition.Condition;
import mage.game.Game;
import mage.game.permanent.Permanent;
/**
*
* @author noxx
*/
public class TransformedCondition implements Condition {
protected boolean notCondition;
public TransformedCondition() {
this(false);
}
/**
* The condition checks whether a permanent is transformed or not.
*
* @param notCondition if true the condition is true when the permanent is not transformed
* @return true if the condition is true, false if the condition is false
*/
public TransformedCondition(boolean notCondition) {
this.notCondition = notCondition;
}
@Override
public boolean apply(Game game, Ability source) {
Permanent permanent = game.getPermanent(source.getSourceId());
if (permanent != null) {
if (notCondition) {
return !permanent.isTransformed();
} else {
return permanent.isTransformed();
}
}
return false;
}
}
| 430 |
9,182 | /*
* ActiveLoggerImplTester.cpp
*
* Created on: Mar 18, 2015
* Author: tcanham
*/
#include <Svc/ActiveLogger/test/ut/ActiveLoggerImplTester.hpp>
#include <Fw/Com/ComBuffer.hpp>
#include <Fw/Com/ComPacket.hpp>
#include <Os/IntervalTimer.hpp>
#include <gtest/gtest.h>
#include <Fw/Test/UnitTest.hpp>
#include <Os/Stubs/FileStubs.hpp>
#include <cstdio>
namespace Svc {
typedef ActiveLogger_Enabled Enabled;
typedef ActiveLogger_FilterSeverity FilterSeverity;
void ActiveLoggerImplTester::init(NATIVE_INT_TYPE instance) {
Svc::ActiveLoggerGTestBase::init();
}
ActiveLoggerImplTester::ActiveLoggerImplTester(Svc::ActiveLoggerImpl& inst) :
Svc::ActiveLoggerGTestBase("testerbase",100),
m_impl(inst),
m_receivedPacket(false),
m_receivedFatalEvent(false) {
}
ActiveLoggerImplTester::~ActiveLoggerImplTester() {
}
void ActiveLoggerImplTester::from_PktSend_handler(
const NATIVE_INT_TYPE portNum, //!< The port number
Fw::ComBuffer &data, //!< Buffer containing packet data
U32 context //!< context; not used
) {
this->m_sentPacket = data;
this->m_receivedPacket = true;
}
void ActiveLoggerImplTester::from_FatalAnnounce_handler(
const NATIVE_INT_TYPE portNum, //!< The port number
FwEventIdType Id //!< The ID of the FATAL event
) {
this->m_receivedFatalEvent = true;
this->m_fatalID = Id;
}
void ActiveLoggerImplTester::runEventNominal() {
REQUIREMENT("AL-001");
this->writeEvent(29,Fw::LogSeverity::WARNING_HI,10);
}
void ActiveLoggerImplTester::runWithFilters(Fw::LogSeverity filter) {
REQUIREMENT("AL-002");
Fw::LogBuffer buff;
U32 val = 10;
FwEventIdType id = 29;
Fw::SerializeStatus stat = buff.serialize(val);
ASSERT_EQ(Fw::FW_SERIALIZE_OK,stat);
Fw::Time timeTag(TB_NONE,0,0);
U32 cmdSeq = 21;
// enable report filter
this->clearHistory();
FilterSeverity reportFilterLevel = FilterSeverity::WARNING_HI;
switch (filter.e) {
case Fw::LogSeverity::WARNING_HI:
reportFilterLevel = FilterSeverity::WARNING_HI;
break;
case Fw::LogSeverity::WARNING_LO:
reportFilterLevel = FilterSeverity::WARNING_LO;
break;
case Fw::LogSeverity::COMMAND:
reportFilterLevel = FilterSeverity::COMMAND;
break;
case Fw::LogSeverity::ACTIVITY_HI:
reportFilterLevel = FilterSeverity::ACTIVITY_HI;
break;
case Fw::LogSeverity::ACTIVITY_LO:
reportFilterLevel = FilterSeverity::ACTIVITY_LO;
break;
case Fw::LogSeverity::DIAGNOSTIC:
reportFilterLevel = FilterSeverity::DIAGNOSTIC;
break;
default:
ASSERT_TRUE(false);
break;
}
this->clearHistory();
this->sendCmd_SET_EVENT_FILTER(0,cmdSeq,reportFilterLevel,Enabled::ENABLED);
ASSERT_CMD_RESPONSE_SIZE(1);
ASSERT_CMD_RESPONSE(
0,
ActiveLoggerImpl::OPCODE_SET_EVENT_FILTER,
cmdSeq,
Fw::CmdResponse::OK
);
this->m_receivedPacket = false;
this->invoke_to_LogRecv(0,id,timeTag,filter,buff);
// should not have received packet
ASSERT_FALSE(this->m_receivedPacket);
// dispatch message
this->m_impl.doDispatch();
// should have received packet
ASSERT_TRUE(this->m_receivedPacket);
// verify contents
// first piece should be log packet descriptor
FwPacketDescriptorType desc;
stat = this->m_sentPacket.deserialize(desc);
ASSERT_EQ(Fw::FW_SERIALIZE_OK,stat);
ASSERT_EQ(desc,static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_LOG));
// next piece should be event ID
FwEventIdType sentId;
stat = this->m_sentPacket.deserialize(sentId);
ASSERT_EQ(Fw::FW_SERIALIZE_OK,stat);
ASSERT_EQ(sentId,id);
// next piece is time tag
Fw::Time recTimeTag(TB_NONE,0,0);
stat = this->m_sentPacket.deserialize(recTimeTag);
ASSERT_EQ(Fw::FW_SERIALIZE_OK,stat);
ASSERT_TRUE(timeTag == recTimeTag);
// next piece is event argument
U32 readVal;
stat = this->m_sentPacket.deserialize(readVal);
ASSERT_EQ(Fw::FW_SERIALIZE_OK,stat);
ASSERT_EQ(readVal, val);
// packet should be empty
ASSERT_EQ(this->m_sentPacket.getBuffLeft(),0u);
// Disable severity filter
this->clearHistory();
this->sendCmd_SET_EVENT_FILTER(0,cmdSeq,reportFilterLevel,Enabled::DISABLED);
ASSERT_CMD_RESPONSE_SIZE(1);
ASSERT_CMD_RESPONSE(
0,
ActiveLoggerImpl::OPCODE_SET_EVENT_FILTER,
cmdSeq,
Fw::CmdResponse::OK
);
this->m_receivedPacket = false;
this->invoke_to_LogRecv(0,id,timeTag,filter,buff);
// should not have received packet - all we can check since no message is dispatched.
ASSERT_FALSE(this->m_receivedPacket);
}
void ActiveLoggerImplTester::runFilterInvalidCommands() {
U32 cmdSeq = 21;
this->clearHistory();
FilterSeverity reportFilterLevel = FilterSeverity::WARNING_HI;
Enabled filterEnabled(static_cast<Enabled::t>(10));
this->sendCmd_SET_EVENT_FILTER(0,cmdSeq,reportFilterLevel,filterEnabled);
ASSERT_CMD_RESPONSE_SIZE(1);
ASSERT_CMD_RESPONSE(
0,
ActiveLoggerImpl::OPCODE_SET_EVENT_FILTER,
cmdSeq,
Fw::CmdResponse::VALIDATION_ERROR
);
this->clearHistory();
reportFilterLevel = FilterSeverity::WARNING_HI;
filterEnabled.e = static_cast<Enabled::t>(-2);
this->sendCmd_SET_EVENT_FILTER(0,cmdSeq,reportFilterLevel,filterEnabled);
ASSERT_CMD_RESPONSE_SIZE(1);
ASSERT_CMD_RESPONSE(
0,
ActiveLoggerImpl::OPCODE_SET_EVENT_FILTER,
cmdSeq,
Fw::CmdResponse::VALIDATION_ERROR
);
FilterSeverity eventLevel;
this->clearHistory();
Enabled reportEnable = Enabled::ENABLED;
eventLevel.e = static_cast<FilterSeverity::t>(-1);
this->sendCmd_SET_EVENT_FILTER(0,cmdSeq,eventLevel,reportEnable);
ASSERT_CMD_RESPONSE_SIZE(1);
ASSERT_CMD_RESPONSE(
0,
ActiveLoggerImpl::OPCODE_SET_EVENT_FILTER,
cmdSeq,
Fw::CmdResponse::VALIDATION_ERROR
);
this->clearHistory();
reportEnable = Enabled::ENABLED;
eventLevel.e = static_cast<FilterSeverity::t>(100);
this->sendCmd_SET_EVENT_FILTER(0,cmdSeq,eventLevel,reportEnable);
ASSERT_CMD_RESPONSE_SIZE(1);
ASSERT_CMD_RESPONSE(
0,
ActiveLoggerImpl::OPCODE_SET_EVENT_FILTER,
cmdSeq,
Fw::CmdResponse::VALIDATION_ERROR
);
}
void ActiveLoggerImplTester::runFilterEventNominal() {
for (Fw::LogSeverity::t sev = Fw::LogSeverity::WARNING_HI; sev <= Fw::LogSeverity::DIAGNOSTIC; sev = static_cast<Fw::LogSeverity::t>(sev + 1)) {
this->runWithFilters(sev);
}
}
void ActiveLoggerImplTester::runFilterIdNominal() {
U32 cmdSeq = 21;
// for a set of IDs, fill filter
REQUIREMENT("AL-003");
for (NATIVE_INT_TYPE filterID = 1; filterID <= TELEM_ID_FILTER_SIZE; filterID++) {
this->clearHistory();
this->clearEvents();
this->sendCmd_SET_ID_FILTER(0,cmdSeq,filterID,Enabled::ENABLED);
// dispatch message
this->m_impl.doDispatch();
ASSERT_CMD_RESPONSE_SIZE(1);
ASSERT_CMD_RESPONSE(
0,
ActiveLoggerImpl::OPCODE_SET_ID_FILTER,
cmdSeq,
Fw::CmdResponse::OK
);
ASSERT_EVENTS_SIZE(1);
ASSERT_EVENTS_ID_FILTER_ENABLED_SIZE(1);
ASSERT_EVENTS_ID_FILTER_ENABLED(0,filterID);
// send it again, to verify it will accept a second add
this->clearHistory();
this->clearEvents();
this->sendCmd_SET_ID_FILTER(0,cmdSeq,filterID,Enabled::ENABLED);
// dispatch message
this->m_impl.doDispatch();
ASSERT_CMD_RESPONSE_SIZE(1);
ASSERT_CMD_RESPONSE(
0,
ActiveLoggerImpl::OPCODE_SET_ID_FILTER,
cmdSeq,
Fw::CmdResponse::OK
);
ASSERT_EVENTS_SIZE(1);
ASSERT_EVENTS_ID_FILTER_ENABLED_SIZE(1);
ASSERT_EVENTS_ID_FILTER_ENABLED(0,filterID);
}
// Try to send the IDs that are filtered
for (NATIVE_INT_TYPE filterID = 1; filterID <= TELEM_ID_FILTER_SIZE; filterID++) {
this->clearHistory();
this->clearEvents();
Fw::LogBuffer buff;
U32 val = 10;
FwEventIdType id = filterID;
Fw::SerializeStatus stat = buff.serialize(val);
ASSERT_EQ(Fw::FW_SERIALIZE_OK,stat);
Fw::Time timeTag(TB_NONE,0,0);
this->m_receivedPacket = false;
this->invoke_to_LogRecv(0,id,timeTag,Fw::LogSeverity::ACTIVITY_HI,buff);
// should not get a packet
ASSERT_FALSE(this->m_receivedPacket);
}
// send one of the IDs as a FATAL, it should not be filtered event thought the ID is in the filter
this->clearHistory();
this->clearEvents();
Fw::LogBuffer buff;
U32 val = 10;
FwEventIdType id = 1;
Fw::SerializeStatus stat = buff.serialize(val);
ASSERT_EQ(Fw::FW_SERIALIZE_OK,stat);
Fw::Time timeTag(TB_NONE,0,0);
this->m_receivedPacket = false;
this->invoke_to_LogRecv(0,id,timeTag,Fw::LogSeverity::FATAL,buff);
this->m_impl.doDispatch();
// should get a packet anyway
ASSERT_TRUE(this->m_receivedPacket);
// Try to add to the full filter. It should be rejected
this->clearHistory();
this->clearEvents();
this->sendCmd_SET_ID_FILTER(0,cmdSeq,TELEM_ID_FILTER_SIZE+1,Enabled::ENABLED);
// dispatch message
this->m_impl.doDispatch();
ASSERT_CMD_RESPONSE_SIZE(1);
ASSERT_CMD_RESPONSE(
0,
ActiveLoggerImpl::OPCODE_SET_ID_FILTER,
cmdSeq,
Fw::CmdResponse::EXECUTION_ERROR
);
ASSERT_EVENTS_SIZE(1);
ASSERT_EVENTS_ID_FILTER_LIST_FULL_SIZE(1);
ASSERT_EVENTS_ID_FILTER_LIST_FULL(0,TELEM_ID_FILTER_SIZE+1);
// Now clear them
for (NATIVE_INT_TYPE filterID = 1; filterID <= TELEM_ID_FILTER_SIZE; filterID++) {
this->clearHistory();
this->clearEvents();
this->sendCmd_SET_ID_FILTER(0,cmdSeq,filterID,Enabled::DISABLED);
// dispatch message
this->m_impl.doDispatch();
ASSERT_CMD_RESPONSE_SIZE(1);
ASSERT_CMD_RESPONSE(
0,
ActiveLoggerImpl::OPCODE_SET_ID_FILTER,
cmdSeq,
Fw::CmdResponse::OK
);
ASSERT_EVENTS_SIZE(1);
ASSERT_EVENTS_ID_FILTER_REMOVED_SIZE(1);
ASSERT_EVENTS_ID_FILTER_REMOVED(0,filterID);
}
// Try to clear one that doesn't exist
this->clearHistory();
this->clearEvents();
this->sendCmd_SET_ID_FILTER(0,cmdSeq,10,Enabled::DISABLED);
// dispatch message
this->m_impl.doDispatch();
ASSERT_CMD_RESPONSE_SIZE(1);
ASSERT_CMD_RESPONSE(
0,
ActiveLoggerImpl::OPCODE_SET_ID_FILTER,
cmdSeq,
Fw::CmdResponse::EXECUTION_ERROR
);
ASSERT_EVENTS_SIZE(1);
ASSERT_EVENTS_ID_FILTER_NOT_FOUND_SIZE(1);
ASSERT_EVENTS_ID_FILTER_NOT_FOUND(0,10);
// Send an invalid argument
this->clearHistory();
this->clearEvents();
Enabled idEnabled(static_cast<Enabled::t>(10));
this->sendCmd_SET_ID_FILTER(0,cmdSeq,10,idEnabled);
// dispatch message
this->m_impl.doDispatch();
ASSERT_CMD_RESPONSE_SIZE(1);
ASSERT_CMD_RESPONSE(
0,
ActiveLoggerImpl::OPCODE_SET_ID_FILTER,
cmdSeq,
Fw::CmdResponse::VALIDATION_ERROR
);
ASSERT_EVENTS_SIZE(0);
}
void ActiveLoggerImplTester::runFilterDump() {
U32 cmdSeq = 21;
// set random set of filters
this->sendCmd_SET_EVENT_FILTER(0,0,FilterSeverity::WARNING_HI,Enabled::ENABLED);
this->sendCmd_SET_EVENT_FILTER(0,0,FilterSeverity::WARNING_LO,Enabled::DISABLED);
this->sendCmd_SET_EVENT_FILTER(0,0,FilterSeverity::COMMAND,Enabled::ENABLED);
this->sendCmd_SET_EVENT_FILTER(0,0,FilterSeverity::ACTIVITY_HI,Enabled::DISABLED);
this->sendCmd_SET_EVENT_FILTER(0,0,FilterSeverity::ACTIVITY_LO,Enabled::ENABLED);
this->sendCmd_SET_EVENT_FILTER(0,0,FilterSeverity::DIAGNOSTIC,Enabled::ENABLED);
this->sendCmd_SET_ID_FILTER(0,cmdSeq,4,Enabled::ENABLED);
// dispatch message
this->m_impl.doDispatch();
this->sendCmd_SET_ID_FILTER(0,cmdSeq,13,Enabled::ENABLED);
// dispatch message
this->m_impl.doDispatch();
this->sendCmd_SET_ID_FILTER(0,cmdSeq,4000,Enabled::ENABLED);
// dispatch message
this->m_impl.doDispatch();
// send command to dump the filters
this->clearHistory();
this->clearEvents();
this->sendCmd_DUMP_FILTER_STATE(0,cmdSeq);
// dispatch message
this->m_impl.doDispatch();
ASSERT_CMD_RESPONSE_SIZE(1);
ASSERT_CMD_RESPONSE(
0,
ActiveLoggerImpl::OPCODE_DUMP_FILTER_STATE,
cmdSeq,
Fw::CmdResponse::OK
);
ASSERT_EVENTS_SIZE(6+3);
ASSERT_EVENTS_SEVERITY_FILTER_STATE_SIZE(6);
ASSERT_EVENTS_SEVERITY_FILTER_STATE(0,FilterSeverity::WARNING_HI,true);
ASSERT_EVENTS_SEVERITY_FILTER_STATE(1,FilterSeverity::WARNING_LO,false);
ASSERT_EVENTS_SEVERITY_FILTER_STATE(2,FilterSeverity::COMMAND,true);
ASSERT_EVENTS_SEVERITY_FILTER_STATE(3,FilterSeverity::ACTIVITY_HI,false);
ASSERT_EVENTS_SEVERITY_FILTER_STATE(4,FilterSeverity::ACTIVITY_LO,true);
ASSERT_EVENTS_SEVERITY_FILTER_STATE(5,FilterSeverity::DIAGNOSTIC,true);
}
void ActiveLoggerImplTester::runEventFatal() {
Fw::LogBuffer buff;
U32 val = 10;
FwEventIdType id = 29;
U32 cmdSeq = 21;
REQUIREMENT("AL-004");
Fw::SerializeStatus stat = buff.serialize(val);
ASSERT_EQ(Fw::FW_SERIALIZE_OK,stat);
Fw::Time timeTag(TB_NONE,0,0);
this->m_receivedPacket = false;
this->invoke_to_LogRecv(0,id,timeTag,Fw::LogSeverity::FATAL,buff);
// should not have received packet
ASSERT_FALSE(this->m_receivedPacket);
// should have seen event port
ASSERT_TRUE(this->m_receivedFatalEvent);
ASSERT_EQ(this->m_fatalID,id);
// dispatch message
this->m_impl.doDispatch();
// should have received packet
ASSERT_TRUE(this->m_receivedPacket);
// verify contents
// first piece should be log packet descriptor
FwPacketDescriptorType desc;
stat = this->m_sentPacket.deserialize(desc);
ASSERT_EQ(Fw::FW_SERIALIZE_OK,stat);
ASSERT_EQ(desc,static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_LOG));
// next piece should be event ID
FwEventIdType sentId;
stat = this->m_sentPacket.deserialize(sentId);
ASSERT_EQ(Fw::FW_SERIALIZE_OK,stat);
ASSERT_EQ(sentId,id);
// next piece is time tag
Fw::Time recTimeTag(TB_NONE,0,0);
stat = this->m_sentPacket.deserialize(recTimeTag);
ASSERT_EQ(Fw::FW_SERIALIZE_OK,stat);
ASSERT_TRUE(timeTag == recTimeTag);
// next piece is event argument
U32 readVal;
stat = this->m_sentPacket.deserialize(readVal);
ASSERT_EQ(Fw::FW_SERIALIZE_OK,stat);
ASSERT_EQ(readVal, val);
// packet should be empty
ASSERT_EQ(this->m_sentPacket.getBuffLeft(),0u);
// Turn on all filters and make sure FATAL still gets through
this->clearHistory();
this->clearEvents();
this->sendCmd_SET_EVENT_FILTER(0,cmdSeq,FilterSeverity::WARNING_HI,Enabled::DISABLED);
ASSERT_CMD_RESPONSE_SIZE(1);
ASSERT_CMD_RESPONSE(
0,
ActiveLoggerImpl::OPCODE_SET_EVENT_FILTER,
cmdSeq,
Fw::CmdResponse::OK
);
this->sendCmd_SET_EVENT_FILTER(0,cmdSeq,FilterSeverity::WARNING_LO,Enabled::DISABLED);
this->sendCmd_SET_EVENT_FILTER(0,cmdSeq,FilterSeverity::COMMAND,Enabled::DISABLED);
this->sendCmd_SET_EVENT_FILTER(0,cmdSeq,FilterSeverity::ACTIVITY_HI,Enabled::DISABLED);
this->sendCmd_SET_EVENT_FILTER(0,cmdSeq,FilterSeverity::ACTIVITY_LO,Enabled::DISABLED);
this->sendCmd_SET_EVENT_FILTER(0,cmdSeq,FilterSeverity::DIAGNOSTIC,Enabled::DISABLED);
this->m_receivedPacket = false;
this->invoke_to_LogRecv(0,id,timeTag,Fw::LogSeverity::FATAL,buff);
// should not have received packet
ASSERT_FALSE(this->m_receivedPacket);
// dispatch message
this->m_impl.doDispatch();
// should have received packet
ASSERT_TRUE(this->m_receivedPacket);
// verify contents
// first piece should be log packet descriptor
stat = this->m_sentPacket.deserialize(desc);
ASSERT_EQ(Fw::FW_SERIALIZE_OK,stat);
ASSERT_EQ(desc,static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_LOG));
// next piece should be event ID
stat = this->m_sentPacket.deserialize(sentId);
ASSERT_EQ(Fw::FW_SERIALIZE_OK,stat);
ASSERT_EQ(sentId,id);
// next piece is time tag
stat = this->m_sentPacket.deserialize(recTimeTag);
ASSERT_EQ(Fw::FW_SERIALIZE_OK,stat);
ASSERT_TRUE(timeTag == recTimeTag);
// next piece is event argument
stat = this->m_sentPacket.deserialize(readVal);
ASSERT_EQ(Fw::FW_SERIALIZE_OK,stat);
ASSERT_EQ(readVal, val);
// packet should be empty
ASSERT_EQ(this->m_sentPacket.getBuffLeft(),0u);
// turn off filters
this->sendCmd_SET_EVENT_FILTER(0,cmdSeq,FilterSeverity::WARNING_HI,Enabled::ENABLED);
this->sendCmd_SET_EVENT_FILTER(0,cmdSeq,FilterSeverity::WARNING_LO,Enabled::ENABLED);
this->sendCmd_SET_EVENT_FILTER(0,cmdSeq,FilterSeverity::COMMAND,Enabled::ENABLED);
this->sendCmd_SET_EVENT_FILTER(0,cmdSeq,FilterSeverity::ACTIVITY_HI,Enabled::ENABLED);
this->sendCmd_SET_EVENT_FILTER(0,cmdSeq,FilterSeverity::ACTIVITY_LO,Enabled::ENABLED);
this->sendCmd_SET_EVENT_FILTER(0,cmdSeq,FilterSeverity::DIAGNOSTIC,Enabled::ENABLED);
}
void ActiveLoggerImplTester::writeEvent(FwEventIdType id, Fw::LogSeverity severity, U32 value) {
Fw::LogBuffer buff;
Fw::SerializeStatus stat = buff.serialize(value);
ASSERT_EQ(Fw::FW_SERIALIZE_OK,stat);
Fw::Time timeTag(TB_NONE,1,2);
this->m_receivedPacket = false;
this->invoke_to_LogRecv(0,id,timeTag,severity,buff);
// should not have received packet
ASSERT_FALSE(this->m_receivedPacket);
// dispatch message
this->m_impl.doDispatch();
// should have received packet
ASSERT_TRUE(this->m_receivedPacket);
// verify contents
// first piece should be log packet descriptor
FwPacketDescriptorType desc;
stat = this->m_sentPacket.deserialize(desc);
ASSERT_EQ(Fw::FW_SERIALIZE_OK,stat);
ASSERT_EQ(desc,static_cast<FwPacketDescriptorType>(Fw::ComPacket::FW_PACKET_LOG));
// next piece should be event ID
FwEventIdType sentId;
stat = this->m_sentPacket.deserialize(sentId);
ASSERT_EQ(Fw::FW_SERIALIZE_OK,stat);
ASSERT_EQ(sentId,id);
// next piece is time tag
Fw::Time recTimeTag(TB_NONE,1,2);
stat = this->m_sentPacket.deserialize(recTimeTag);
ASSERT_EQ(Fw::FW_SERIALIZE_OK,stat);
ASSERT_TRUE(timeTag == recTimeTag);
// next piece is event argument
U32 readVal;
stat = this->m_sentPacket.deserialize(readVal);
ASSERT_EQ(Fw::FW_SERIALIZE_OK,stat);
ASSERT_EQ(readVal, value);
// packet should be empty
ASSERT_EQ(this->m_sentPacket.getBuffLeft(),0u);
}
void ActiveLoggerImplTester::readEvent(FwEventIdType id, Fw::LogSeverity severity, U32 value, Os::File& file) {
static const BYTE delimiter = 0xA5;
// first read should be delimiter
BYTE de;
NATIVE_INT_TYPE readSize = sizeof(de);
ASSERT_EQ(file.read(&de,readSize,true),Os::File::OP_OK);
ASSERT_EQ(delimiter,de);
// next is LogPacket
Fw::ComBuffer comBuff;
// size is specific to this test
readSize = sizeof(FwPacketDescriptorType) + sizeof(FwEventIdType) + Fw::Time::SERIALIZED_SIZE + sizeof(U32);
ASSERT_EQ(file.read(comBuff.getBuffAddr(),readSize,true),Os::File::OP_OK);
comBuff.setBuffLen(readSize);
// deserialize LogPacket
Fw::LogPacket packet;
Fw::Time time(TB_NONE,1,2);
Fw::LogBuffer logBuff;
ASSERT_EQ(comBuff.deserialize(packet),Fw::FW_SERIALIZE_OK);
// read back values
ASSERT_EQ(id,packet.getId());
ASSERT_EQ(time,packet.getTimeTag());
logBuff = packet.getLogBuffer();
U32 readValue;
ASSERT_EQ(logBuff.deserialize(readValue),Fw::FW_SERIALIZE_OK);
ASSERT_EQ(value,readValue);
}
void ActiveLoggerImplTester::textLogIn(const FwEventIdType id, //!< The event ID
Fw::Time& timeTag, //!< The time
const Fw::LogSeverity severity, //!< The severity
const Fw::TextLogString& text //!< The event string
) {
TextLogEntry e = { id, timeTag, severity, text };
printTextLogHistoryEntry(e, stdout);
}
void ActiveLoggerImplTester ::
from_pingOut_handler(
const NATIVE_INT_TYPE portNum,
U32 key
)
{
this->pushFromPortEntry_pingOut(key);
}
} /* namespace SvcTest */
| 11,640 |
2,151 | # Copyright (c) 2014 Google Inc. All rights reserved.
# Use of this source code is governed by a BSD-style licence that can be
# found in the LICENSE file.
{
'variables': {
'custom_ar_target%': '',
'custom_ar_host%': '',
},
'conditions': [
['"<(custom_ar_target)"!=""', {
'make_global_settings': [
['AR', '<(custom_ar_target)'],
],
}],
['"<(custom_ar_host)"!=""', {
'make_global_settings': [
['AR.host', '<(custom_ar_host)'],
],
}],
],
'targets': [
{
'target_name': 'make_global_settings_ar_test',
'type': 'static_library',
'sources': [ 'foo.c' ],
},
],
}
| 303 |
412 | <gh_stars>100-1000
/*
* Datart
* <p>
* Copyright 2021
* <p>
* 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
* <p>
* http://www.apache.org/licenses/LICENSE-2.0
* <p>
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package datart.server.controller;
import datart.core.common.FileUtils;
import datart.core.entity.Download;
import datart.server.base.dto.ResponseData;
import datart.server.base.params.DownloadCreateParam;
import datart.server.service.DownloadService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.apache.tomcat.util.http.fileupload.util.Streams;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URLEncoder;
import java.util.List;
@Api
@RestController
@RequestMapping(value = "/download")
public class DownloadController extends BaseController {
private final DownloadService downloadService;
public DownloadController(DownloadService downloadService) {
this.downloadService = downloadService;
}
@ApiOperation(value = "get download tasks")
@GetMapping(value = "/tasks")
public ResponseData<List<Download>> listDownloadTasks() {
ResponseData.ResponseDataBuilder<List<Download>> builder = ResponseData.builder();
return ResponseData.success(downloadService.listDownloadTasks());
}
@ApiOperation(value = "submit a new download task")
@PostMapping(value = "/submit/task")
public ResponseData<Download> submitDownloadTask(@RequestBody @Validated DownloadCreateParam createParam) {
return ResponseData.success(downloadService.submitDownloadTask(createParam));
}
@ApiOperation(value = "get download file")
@GetMapping(value = "/files/{id}")
public void downloadFile(@PathVariable String id,
HttpServletResponse response) throws IOException {
Download download = downloadService.downloadFile(id);
response.setHeader("Content-Type", "application/octet-stream");
File file = new File(FileUtils.withBasePath(download.getPath()));
response.setHeader("Content-Disposition", String.format("attachment;filename=\"%s\"", URLEncoder.encode(file.getName(), "utf-8")));
try (InputStream inputStream = new FileInputStream(file)) {
Streams.copy(inputStream, response.getOutputStream(), true);
}
}
} | 946 |
19,127 | <filename>providers/implementations/ciphers/cipher_aes_ccm_hw.c
/*
* Copyright 2019-2021 The OpenSSL Project Authors. All Rights Reserved.
*
* Licensed under the Apache License 2.0 (the "License"). You may not use
* this file except in compliance with the License. You can obtain a copy
* in the file LICENSE in the source distribution or at
* https://www.openssl.org/source/license.html
*/
/* AES CCM mode */
/*
* This file uses the low level AES functions (which are deprecated for
* non-internal use) in order to implement provider AES ciphers.
*/
#include "internal/deprecated.h"
#include "cipher_aes_ccm.h"
#define AES_HW_CCM_SET_KEY_FN(fn_set_enc_key, fn_blk, fn_ccm_enc, fn_ccm_dec) \
fn_set_enc_key(key, keylen * 8, &actx->ccm.ks.ks); \
CRYPTO_ccm128_init(&ctx->ccm_ctx, ctx->m, ctx->l, &actx->ccm.ks.ks, \
(block128_f)fn_blk); \
ctx->str = ctx->enc ? (ccm128_f)fn_ccm_enc : (ccm128_f)fn_ccm_dec; \
ctx->key_set = 1;
static int ccm_generic_aes_initkey(PROV_CCM_CTX *ctx, const unsigned char *key,
size_t keylen)
{
PROV_AES_CCM_CTX *actx = (PROV_AES_CCM_CTX *)ctx;
#ifdef HWAES_CAPABLE
if (HWAES_CAPABLE) {
AES_HW_CCM_SET_KEY_FN(HWAES_set_encrypt_key, HWAES_encrypt, NULL, NULL);
} else
#endif /* HWAES_CAPABLE */
#ifdef VPAES_CAPABLE
if (VPAES_CAPABLE) {
AES_HW_CCM_SET_KEY_FN(vpaes_set_encrypt_key, vpaes_encrypt, NULL, NULL);
} else
#endif
{
AES_HW_CCM_SET_KEY_FN(AES_set_encrypt_key, AES_encrypt, NULL, NULL)
}
return 1;
}
static const PROV_CCM_HW aes_ccm = {
ccm_generic_aes_initkey,
ossl_ccm_generic_setiv,
ossl_ccm_generic_setaad,
ossl_ccm_generic_auth_encrypt,
ossl_ccm_generic_auth_decrypt,
ossl_ccm_generic_gettag
};
#if defined(S390X_aes_128_CAPABLE)
# include "cipher_aes_ccm_hw_s390x.inc"
#elif defined(AESNI_CAPABLE)
# include "cipher_aes_ccm_hw_aesni.inc"
#elif defined(SPARC_AES_CAPABLE)
# include "cipher_aes_ccm_hw_t4.inc"
#else
const PROV_CCM_HW *ossl_prov_aes_hw_ccm(size_t keybits)
{
return &aes_ccm;
}
#endif
| 1,077 |
2,360 | <filename>var/spack/repos/builtin/packages/py-pymsgbox/package.py
# Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
# Spack Project Developers. See the top-level COPYRIGHT file for details.
#
# SPDX-License-Identifier: (Apache-2.0 OR MIT)
from spack import *
class PyPymsgbox(PythonPackage):
"""A simple, cross-platform, pure Python module for
JavaScript-like message boxes."""
homepage = "https://github.com/asweigart/pymsgbox"
pypi = "PyMsgBox/PyMsgBox-1.0.9.tar.gz"
version('1.0.9', sha256='2194227de8bff7a3d6da541848705a155dcbb2a06ee120d9f280a1d7f51263ff')
depends_on('py-setuptools', type='build')
| 254 |
1,473 | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/stdpaths.h
// Purpose: wxStandardPaths for Win32
// Author: <NAME>
// Modified by:
// Created: 2004-10-19
// Copyright: (c) 2004 <NAME> <<EMAIL>>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_STDPATHS_H_
#define _WX_MSW_STDPATHS_H_
struct _GUID;
// ----------------------------------------------------------------------------
// wxStandardPaths
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_BASE wxStandardPaths : public wxStandardPathsBase
{
public:
// implement base class pure virtuals
virtual wxString GetExecutablePath() const;
virtual wxString GetConfigDir() const;
virtual wxString GetUserConfigDir() const;
virtual wxString GetDataDir() const;
virtual wxString GetUserDataDir() const;
virtual wxString GetUserLocalDataDir() const;
virtual wxString GetPluginsDir() const;
virtual wxString GetUserDir(Dir userDir) const wxOVERRIDE;
// MSW-specific methods
// This class supposes that data, plugins &c files are located under the
// program directory which is the directory containing the application
// binary itself. But sometimes this binary may be in a subdirectory of the
// main program directory, e.g. this happens in at least the following
// common cases:
// 1. The program is in "bin" subdirectory of the installation directory.
// 2. The program is in "debug" subdirectory of the directory containing
// sources and data files during development
//
// By calling this function you instruct the class to remove the last
// component of the path if it matches its argument. Notice that it may be
// called more than once, e.g. you can call both IgnoreAppSubDir("bin") and
// IgnoreAppSubDir("debug") to take care of both production and development
// cases above but that each call will only remove the last path component.
// Finally note that the argument can contain wild cards so you can also
// call IgnoreAppSubDir("vc*msw*") to ignore all build directories at once
// when using wxWidgets-inspired output directories names.
void IgnoreAppSubDir(const wxString& subdirPattern);
// This function is used to ignore all common build directories and is
// called from the ctor -- use DontIgnoreAppSubDir() to undo this.
void IgnoreAppBuildSubDirs();
// Undo the effects of all preceding IgnoreAppSubDir() calls.
void DontIgnoreAppSubDir();
// Returns the directory corresponding to the specified Windows shell CSIDL
static wxString MSWGetShellDir(int csidl);
protected:
// Ctor is protected, use wxStandardPaths::Get() instead of instantiating
// objects of this class directly.
//
// It calls IgnoreAppBuildSubDirs() and also sets up the object to use
// both vendor and application name by default.
wxStandardPaths();
// get the path corresponding to the given standard CSIDL_XXX constant
static wxString DoGetDirectory(int csidl);
static wxString DoGetKnownFolder(const _GUID& rfid);
// return the directory of the application itself
wxString GetAppDir() const;
// directory returned by GetAppDir()
mutable wxString m_appDir;
};
// ----------------------------------------------------------------------------
// wxStandardPathsWin16: this class is for internal use only
// ----------------------------------------------------------------------------
// override config file locations to be compatible with the values used by
// wxFileConfig (dating from Win16 days which explains the class name)
class WXDLLIMPEXP_BASE wxStandardPathsWin16 : public wxStandardPaths
{
public:
virtual wxString GetConfigDir() const;
virtual wxString GetUserConfigDir() const;
};
#endif // _WX_MSW_STDPATHS_H_
| 1,137 |
1,077 | <gh_stars>1000+
/**
* @file XPT2046.h
*
*/
#ifndef XPT2046_H
#define XPT2046_H
#define USE_XPT2046 1
#define XPT2046_HOR_RES 320
#define XPT2046_VER_RES 240
#define XPT2046_X_MIN 200
#define XPT2046_Y_MIN 200
#define XPT2046_X_MAX 3800
#define XPT2046_Y_MAX 3800
#define XPT2046_AVG 4
#define XPT2046_INV 0
#define CMD_X_READ 0b10010000
#define CMD_Y_READ 0b11010000
#ifdef __cplusplus
extern "C" {
#endif
/*********************
* INCLUDES
*********************/
#if USE_XPT2046
#include <autoconf.h>
#include <stdint.h>
#include <stdbool.h>
//#include "lvgl/lv_hal/lv_hal_indev.h"
#include "device.h"
#include "drivers/gpio.h"
#if 1
enum { LV_INDEV_STATE_REL = 0, LV_INDEV_STATE_PR };
typedef uint8_t lv_indev_state_t;
typedef int16_t lv_coord_t;
typedef struct {
lv_coord_t x;
lv_coord_t y;
} lv_point_t;
typedef struct {
union {
lv_point_t
point; /*For LV_INDEV_TYPE_POINTER the currently pressed point*/
uint32_t key; /*For LV_INDEV_TYPE_KEYPAD the currently pressed key*/
uint32_t btn; /*For LV_INDEV_TYPE_BUTTON the currently pressed button*/
int16_t enc_diff; /*For LV_INDEV_TYPE_ENCODER number of steps since the
previous read*/
};
void *user_data; /*'lv_indev_drv_t.priv' for this driver*/
lv_indev_state_t state; /*LV_INDEV_STATE_REL or LV_INDEV_STATE_PR*/
} lv_indev_data_t;
#endif
/*********************
* DEFINES
*********************/
/**********************
* TYPEDEFS
**********************/
/**********************
* GLOBAL PROTOTYPES
**********************/
void
xpt2046_init(void);
bool
xpt2046_read(lv_indev_data_t *data);
/**********************
* MACROS
**********************/
#endif /* USE_XPT2046 */
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* XPT2046_H */
| 839 |
504 | /* operator.h handle all numeric Javascript operators such as +, *, etc.
*/
/* (c) COPYRIGHT 1993-98 NOMBAS, INC.
* 64 SALEM ST.
* MEDFORD, MA 02155 USA
*
* ALL RIGHTS RESERVED
*
* This software is the property of Nombas, Inc. and is furnished under
* license by Nombas, Inc.; this software may be used only in accordance
* with the terms of said license. This copyright notice may not be removed,
* modified or obliterated without the prior written permission of Nombas, Inc.
*
* This software is a Trade Secret of Nombas, Inc.
*
* This software may not be copied, transmitted, provided to or otherwise made
* available to any other person, company, corporation or other entity except
* as specified in the terms of said license.
*
* No right, title, ownership or other interest in the software is hereby
* granted or transferred.
*
* The information contained herein is subject to change without notice and
* should not be construed as a commitment by Nombas, Inc.
*/
#ifndef _OPERATOR_H
#define _OPERATOR_H
#if (0!=JSE_COMPILER)
# define PRI_ASSIGN 1
# define PRI_CONDITIONAL 2
# define PRI_LOGICAL_OR 3
# define PRI_LOGICAL_AND 4
# define PRI_BIT_OR 5
# define PRI_BIT_XOR 6
# define PRI_BIT_AND 7
# define PRI_EQUALITY 8
# define PRI_RELATIONAL 9
# define PRI_SHIFT 10
# define PRI_ADDITIVE 11
# define PRI_MULT 12
# define PRI_UNARY 13
#endif
struct opDesc
{
setokval token;
jsecharptr as_text;
uword8 priority;
secodeelem operator;
};
#if (0!=JSE_COMPILER)
struct opDesc * NEAR_CALL getTokDescription(setokval token);
#endif
jsenumber NEAR_CALL
SpecialMathOnNonFiniteNumbers(struct Call *call,jsenumber lnum,
jsenumber rnum,secodeelem operation);
#if defined(JSE_OPERATOR_OVERLOADING) && (0!=JSE_OPERATOR_OVERLOADING)
jsebool NEAR_CALL
doOperatorOverloading( struct Call * call, wSEVar lhs, rSEVar rhs, secodeelem op );
# if (defined(JSE_INLINES) && (0!=JSE_INLINES)) && 0==JSE_MEMEXT_OBJECTS
# define IF_OPERATOR_NOT_OVERLOADED(call,lhs,rhs,op) \
if( SEVAR_GET_TYPE(lhs)!=VObject || \
!SEOBJ_IS_DYNAMIC(SEVAR_GET_OBJECT(lhs)) || \
!doOperatorOverloading(call,lhs,rhs,op) )
# else
# define IF_OPERATOR_NOT_OVERLOADED(call,lhs,rhs,op) \
if( !doOperatorOverloading(call,lhs,rhs,op) )
# endif
#else
# define IF_OPERATOR_NOT_OVERLOADED(call,lhs,rhs,op) /* nothing */
#endif
#endif
| 1,317 |
963 |
package cn.enilu.flash.dao.system;
import cn.enilu.flash.bean.entity.system.TaskLog;
import cn.enilu.flash.dao.BaseRepository;
public interface TaskLogRepository extends BaseRepository<TaskLog,Long> {
}
| 79 |
348 | <filename>docs/data/leg-t2/029/02904239.json
{"nom":"Roscoff","circ":"4ème circonscription","dpt":"Finistère","inscrits":2878,"abs":1187,"votants":1691,"blancs":75,"nuls":32,"exp":1584,"res":[{"nuance":"LR","nom":"<NAME>","voix":959},{"nuance":"REM","nom":"<NAME>","voix":625}]} | 114 |
1,909 | package org.knowm.xchange.deribit.v2.dto.trade;
public enum OrderState {
open,
filled,
rejected,
cancelled,
untriggered,
archive;
}
| 57 |
2,389 | <gh_stars>1000+
/*
Copyright 2020 The Kubernetes Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package io.kubernetes.client.util.credentials;
import static io.kubernetes.client.util.TestUtils.getApiKeyAuthFromClient;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.Is.is;
import io.kubernetes.client.openapi.ApiClient;
import org.junit.Test;
public class AccessTokenAuthenticationTest {
@Test
public void testTokenProvided() {
final ApiClient client = new ApiClient();
new AccessTokenAuthentication("token").provide(client);
assertThat(getApiKeyAuthFromClient(client).getApiKeyPrefix(), is("Bearer"));
assertThat(getApiKeyAuthFromClient(client).getApiKey(), is("token"));
}
@Test(expected = NullPointerException.class)
public void testTokenNonnull() {
new AccessTokenAuthentication(null);
}
}
| 411 |
14,668 | // Copyright 2021 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef TOOLS_CLANG_PLUGINS_TESTS_BASE_MEMORY_RAW_PTR_H_
#define TOOLS_CLANG_PLUGINS_TESTS_BASE_MEMORY_RAW_PTR_H_
namespace base {
template <typename T>
class raw_ptr {};
} // namespace base
using base::raw_ptr;
#endif // TOOLS_CLANG_PLUGINS_TESTS_BASE_MEMORY_RAW_PTR_H_
| 181 |
1,068 | #include "falconn/core/heap.h"
#include <vector>
#include "gtest/gtest.h"
namespace fc = falconn::core;
using fc::AugmentedHeap;
using fc::SimpleHeap;
using std::vector;
TEST(HeapTest, SimpleHeapTest1) {
SimpleHeap<float, int> h;
h.resize(10);
h.insert_unsorted(2.0, 2);
h.insert_unsorted(1.0, 1);
h.insert_unsorted(5.0, 5);
h.insert_unsorted(3.0, 3);
h.heapify();
float k;
int d;
h.extract_min(&k, &d);
ASSERT_EQ(1.0, k);
ASSERT_EQ(1, d);
h.extract_min(&k, &d);
ASSERT_EQ(2.0, k);
ASSERT_EQ(2, d);
h.insert(4.0, 4);
h.extract_min(&k, &d);
ASSERT_EQ(3.0, k);
ASSERT_EQ(3, d);
h.extract_min(&k, &d);
ASSERT_EQ(4.0, k);
ASSERT_EQ(4, d);
h.extract_min(&k, &d);
ASSERT_EQ(5.0, k);
ASSERT_EQ(5, d);
h.reset();
h.insert_unsorted(2.0, 2);
h.insert_unsorted(10.0, 10);
h.insert_unsorted(8.0, 8);
h.heapify();
h.extract_min(&k, &d);
ASSERT_EQ(2.0, k);
ASSERT_EQ(2, d);
h.extract_min(&k, &d);
ASSERT_EQ(8.0, k);
ASSERT_EQ(8, d);
h.insert(9.5, 9);
h.extract_min(&k, &d);
ASSERT_EQ(9.5, k);
ASSERT_EQ(9, d);
h.extract_min(&k, &d);
ASSERT_EQ(10.0, k);
ASSERT_EQ(10, d);
}
TEST(HeapTest, SimpleHeapTest2) {
// Same as above, but without initial resize
SimpleHeap<float, int> h;
h.insert_unsorted(2.0, 2);
h.insert_unsorted(1.0, 1);
h.insert_unsorted(5.0, 5);
h.insert_unsorted(3.0, 3);
h.heapify();
float k;
int d;
h.extract_min(&k, &d);
ASSERT_EQ(1.0, k);
ASSERT_EQ(1, d);
h.extract_min(&k, &d);
ASSERT_EQ(2.0, k);
ASSERT_EQ(2, d);
h.insert(4.0, 4);
h.extract_min(&k, &d);
ASSERT_EQ(3.0, k);
ASSERT_EQ(3, d);
h.extract_min(&k, &d);
ASSERT_EQ(4.0, k);
ASSERT_EQ(4, d);
h.extract_min(&k, &d);
ASSERT_EQ(5.0, k);
ASSERT_EQ(5, d);
h.reset();
h.insert_unsorted(2.0, 2);
h.insert_unsorted(10.0, 10);
h.insert_unsorted(8.0, 8);
h.heapify();
h.extract_min(&k, &d);
ASSERT_EQ(2.0, k);
ASSERT_EQ(2, d);
h.extract_min(&k, &d);
ASSERT_EQ(8.0, k);
ASSERT_EQ(8, d);
h.insert(9.5, 9);
h.extract_min(&k, &d);
ASSERT_EQ(9.5, k);
ASSERT_EQ(9, d);
h.extract_min(&k, &d);
ASSERT_EQ(10.0, k);
ASSERT_EQ(10, d);
}
TEST(HeapTest, SimpleHeapTest3) {
SimpleHeap<float, int> h;
h.insert_unsorted(2.0, 2);
h.insert_unsorted(1.0, 1);
h.insert_unsorted(5.0, 5);
h.insert_unsorted(3.0, 3);
h.heapify();
EXPECT_EQ(1.0, h.min_key());
h.replace_top(0.5, 0);
float k;
int d;
h.extract_min(&k, &d);
EXPECT_EQ(0.5, k);
EXPECT_EQ(0, d);
h.extract_min(&k, &d);
EXPECT_EQ(2.0, k);
EXPECT_EQ(2, d);
}
TEST(HeapTest, AugmentedHeapTest1) {
// Same as above, but without initial resize
AugmentedHeap<float, int> h;
h.insert_unsorted(2.0, 2);
h.insert_unsorted(1.0, 1);
h.insert_unsorted(5.0, 5);
h.insert_unsorted(3.0, 3);
h.heapify();
float k;
int d;
h.extract_min(&k, &d);
ASSERT_EQ(1.0, k);
ASSERT_EQ(1, d);
h.insert_guaranteed_top(1.0, 10);
h.extract_min(&k, &d);
ASSERT_EQ(1.0, k);
ASSERT_EQ(10, d);
h.extract_min(&k, &d);
ASSERT_EQ(2.0, k);
ASSERT_EQ(2, d);
h.insert(4.0, 4);
h.extract_min(&k, &d);
ASSERT_EQ(3.0, k);
ASSERT_EQ(3, d);
h.extract_min(&k, &d);
ASSERT_EQ(4.0, k);
ASSERT_EQ(4, d);
h.extract_min(&k, &d);
ASSERT_EQ(5.0, k);
ASSERT_EQ(5, d);
}
| 1,805 |
847 | <reponame>lumetdev/iOS-native-Meteor
// Copyright (c) 2014-2015 <NAME>
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#import "METDDPClient.h"
#import "METDDPConnection.h"
#import "METDDPHeartbeat.h"
#import "METNetworkReachabilityManager.h"
@class METDataUpdate;
@class METMethodInvocation;
@class METMethodInvocationContext;
@class METMethodInvocationCoordinator;
NS_ASSUME_NONNULL_BEGIN
typedef NS_OPTIONS(NSInteger, METMethodCallOptions) {
METMethodCallOptionsNone = 0,
METMethodCallOptionsReturnStubValue = 1 << 0,
METMethodCallOptionsBarrier = 1 << 1
};
@class METDocumentCache;
@interface METDDPClient () <METDDPConnectionDelegate, METDDPHeartbeatDelegate, METNetworkReachabilityManagerDelegate>
@property (assign, nonatomic, readwrite) METDDPConnectionStatus connectionStatus;
@property (strong, nonatomic) METNetworkReachabilityManager *networkReachabilityManager;
@property (nullable, copy, nonatomic, readonly) NSString *protocolVersion;
@property (nullable, copy, nonatomic, readonly) NSString *sessionID;
@property (strong, nonatomic, readwrite) METDatabase *database;
@property (assign, nonatomic, readwrite, getter=isLoggingIn) BOOL loggingIn;
@property (nullable, copy, nonatomic) METAccount *account;
- (void)processDataUpdate:(METDataUpdate *)update;
- (void)sendSubMessageForSubscription:(METSubscription *)subscription;
- (void)sendUnsubMessageForSubscription:(METSubscription *)subscription;
- (void)allSubscriptionsToBeRevivedAfterReconnectAreDone;
- (id)callMethodWithName:(NSString *)methodName parameters:(nullable NSArray *)parameters options:(METMethodCallOptions)options completionHandler:(nullable METMethodCompletionHandler)completionHandler;
- (id)callMethodWithName:(NSString *)methodName parameters:(nullable NSArray *)parameters options:(METMethodCallOptions)options receivedResultHandler:(nullable METMethodCompletionHandler)receivedResultHandler completionHandler:(nullable METMethodCompletionHandler)completionHandler;
@property (strong, nonatomic, readonly) METMethodInvocationCoordinator *methodInvocationCoordinator;
@property (nullable, strong, nonatomic, readonly) METMethodInvocationContext *currentMethodInvocationContext;
- (void)sendMethodMessageForMethodInvocation:(METMethodInvocation *)methodInvocation;
- (NSArray *)convertParameters:(NSArray *)parameters;
@end
NS_ASSUME_NONNULL_END
| 948 |
335 | /*
* ColourEdit.h
* ------------
* Purpose: Implementation of a coloured edit UI item.
* Notes : (currently none)
* Authors: OpenMPT Devs
* The OpenMPT source code is released under the BSD license. Read LICENSE for more details.
*/
#pragma once
#include "openmpt/all/BuildSettings.hpp"
OPENMPT_NAMESPACE_BEGIN
class CColourEdit : public CEdit
{
public:
CColourEdit();
~CColourEdit();
public:
void SetTextColor(COLORREF rgb);
void SetBackColor(COLORREF rgb);
private:
COLORREF m_crText;
COLORREF m_crBackGnd;
CBrush m_brBackGnd;
protected:
afx_msg HBRUSH CtlColor(CDC* pDC, UINT nCtlColor);
DECLARE_MESSAGE_MAP()
};
OPENMPT_NAMESPACE_END
| 254 |
717 | {
"name": "vuex-i18n-build",
"version": "1.1.0",
"license": "MIT",
"description": "Build directory for vuex-i18n",
"scripts": {
"build": "node ./build.js",
"rollup": "rollup -c rollup.config.js",
"minify": "uglifyjs ../dist/vuex-i18n.umd.js --output ../dist/vuex-i18n.min.js --compress"
},
"author": {
"name": "<NAME>",
"email": "<EMAIL>",
"url": "https://github.com/tikiatua"
},
"dependencies": {
"@babel/core": "^7.2.2",
"@babel/plugin-external-helpers": "^7.2.0",
"@babel/preset-env": "^7.2.3",
"rollup": "^1.0.0",
"rollup-plugin-babel": "^4.2.0",
"rollup-plugin-commonjs": "^9.2.0",
"uglify-es": "^3.3.9"
}
}
| 340 |
826 | /***************************************************************************
* Copyright 1998-2020 by authors (see AUTHORS.txt) *
* *
* This file is part of LuxCoreRender. *
* *
* Licensed under the Apache License, Version 2.0 (the "License"); *
* you may not use this file except in compliance with the License. *
* You may obtain a copy of the License at *
* *
* http://www.apache.org/licenses/LICENSE-2.0 *
* *
* Unless required by applicable law or agreed to in writing, software *
* distributed under the License is distributed on an "AS IS" BASIS, *
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.*
* See the License for the specific language governing permissions and *
* limitations under the License. *
***************************************************************************/
#ifndef _SLG_GLOSSYTRANSLUCENTMAT_H
#define _SLG_GLOSSYTRANSLUCENTMAT_H
#include "slg/materials/material.h"
namespace slg {
//------------------------------------------------------------------------------
// Glossy Translucent material
//------------------------------------------------------------------------------
class GlossyTranslucentMaterial : public Material {
public:
GlossyTranslucentMaterial(const Texture *frontTransp, const Texture *backTransp,
const Texture *emitted, const Texture *bump,
const Texture *kd, const Texture *kt, const Texture *ks, const Texture *ks2,
const Texture *u, const Texture *u2, const Texture *v, const Texture *v2,
const Texture *ka, const Texture *ka2, const Texture *d, const Texture *d2,
const Texture *i, const Texture *i2, const bool mbounce, const bool mbounce2);
virtual MaterialType GetType() const { return GLOSSYTRANSLUCENT; }
virtual BSDFEvent GetEventTypes() const { return GLOSSY | REFLECT | TRANSMIT; };
virtual luxrays::Spectrum Albedo(const HitPoint &hitPoint) const;
virtual luxrays::Spectrum Evaluate(const HitPoint &hitPoint,
const luxrays::Vector &localLightDir, const luxrays::Vector &localEyeDir, BSDFEvent *event,
float *directPdfW = NULL, float *reversePdfW = NULL) const;
virtual luxrays::Spectrum Sample(const HitPoint &hitPoint,
const luxrays::Vector &localFixedDir, luxrays::Vector *localSampledDir,
const float u0, const float u1, const float passThroughEvent,
float *pdfW, BSDFEvent *event) const;
virtual void Pdf(const HitPoint &hitPoint,
const luxrays::Vector &localLightDir, const luxrays::Vector &localEyeDir,
float *directPdfW, float *reversePdfW) const;
virtual void AddReferencedTextures(boost::unordered_set<const Texture *> &referencedTexs) const;
virtual void UpdateTextureReferences(const Texture *oldTex, const Texture *newTex);
virtual luxrays::Properties ToProperties(const ImageMapCache &imgMapCache, const bool useRealFileName) const;
const Texture *GetKd() const { return Kd; }
const Texture *GetKt() const { return Kt; }
const Texture *GetKs() const { return Ks; }
const Texture *GetKs_bf() const { return Ks_bf; }
const Texture *GetNu() const { return nu; }
const Texture *GetNu_bf() const { return nu_bf; }
const Texture *GetNv() const { return nv; }
const Texture *GetNv_bf() const { return nv_bf; }
const Texture *GetKa() const { return Ka; }
const Texture *GetKa_bf() const { return Ka_bf; }
const Texture *GetDepth() const { return depth; }
const Texture *GetDepth_bf() const { return depth_bf; }
const Texture *GetIndex() const { return index; }
const Texture *GetIndex_bf() const { return index_bf; }
const bool IsMultibounce() const { return multibounce; }
const bool IsMultibounce_bf() const { return multibounce_bf; }
private:
const Texture *Kd;
const Texture *Kt;
const Texture *Ks;
const Texture *Ks_bf;
const Texture *nu;
const Texture *nu_bf;
const Texture *nv;
const Texture *nv_bf;
const Texture *Ka;
const Texture *Ka_bf;
const Texture *depth;
const Texture *depth_bf;
const Texture *index;
const Texture *index_bf;
const bool multibounce;
const bool multibounce_bf;
};
}
#endif /* _SLG_GLOSSYTRANSLUCENTMAT_H */
| 1,692 |
692 | <gh_stars>100-1000
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Copyright by The HDF Group. *
* All rights reserved. *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* Common definitions used by h5slab example programs (h5slabread, h5slabwrite).
*
* Created by <NAME> 2010/7/13.
*/
#include <stdlib.h>
#include <string.h>
#include "hdf5.h"
#if 1
#define NX 65536
#define NY 65536 /* dataset dimensions */
#define CX 256 /* height of hyperslab */
#define CY 4096 /* width of hyperslab */
#else
#define NX 256
#define NY 256 /* dataset dimensions */
#define CX 32 /* height of hyperslab */
#define CY 16 /* width of hyperslab */
#endif
#define RC (NX/CX)
#define CC (NY/CY)
| 456 |
6,210 | /*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.cassandra.repair.asymmetric;
import java.util.List;
import java.util.Map;
import java.util.Set;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.ImmutableMap;
import org.apache.cassandra.dht.Range;
import org.apache.cassandra.dht.Token;
import org.apache.cassandra.locator.InetAddressAndPort;
import org.apache.cassandra.repair.TreeResponse;
import org.apache.cassandra.utils.MerkleTrees;
/**
* Just holds all differences between the hosts involved in a repair
*/
public class DifferenceHolder
{
private final ImmutableMap<InetAddressAndPort, HostDifferences> differences;
public DifferenceHolder(List<TreeResponse> trees)
{
ImmutableMap.Builder<InetAddressAndPort, HostDifferences> diffBuilder = ImmutableMap.builder();
for (int i = 0; i < trees.size() - 1; ++i)
{
TreeResponse r1 = trees.get(i);
// create the differences between r1 and all other hosts:
HostDifferences hd = new HostDifferences();
for (int j = i + 1; j < trees.size(); ++j)
{
TreeResponse r2 = trees.get(j);
hd.add(r2.endpoint, MerkleTrees.difference(r1.trees, r2.trees));
}
r1.trees.release();
// and add them to the diff map
diffBuilder.put(r1.endpoint, hd);
}
trees.get(trees.size() - 1).trees.release();
differences = diffBuilder.build();
}
@VisibleForTesting
DifferenceHolder(Map<InetAddressAndPort, HostDifferences> differences)
{
ImmutableMap.Builder<InetAddressAndPort, HostDifferences> diffBuilder = ImmutableMap.builder();
diffBuilder.putAll(differences);
this.differences = diffBuilder.build();
}
/**
* differences only holds one 'side' of the difference - if A and B mismatch, only A will be a key in the map
*/
public Set<InetAddressAndPort> keyHosts()
{
return differences.keySet();
}
public HostDifferences get(InetAddressAndPort hostWithDifference)
{
return differences.get(hostWithDifference);
}
public String toString()
{
return "DifferenceHolder{" +
"differences=" + differences +
'}';
}
public boolean hasDifferenceBetween(InetAddressAndPort node1, InetAddressAndPort node2, Range<Token> range)
{
HostDifferences diffsNode1 = differences.get(node1);
if (diffsNode1 != null && diffsNode1.hasDifferencesFor(node2, range))
return true;
HostDifferences diffsNode2 = differences.get(node2);
if (diffsNode2 != null && diffsNode2.hasDifferencesFor(node1, range))
return true;
return false;
}
}
| 1,322 |
343 | {
"homepage": "https://github.com/AutoDarkMode/Windows-Auto-Night-Mode",
"description": "Automatically switches between the dark and light theme of Windows 10 and Windows 11",
"version": "10.1.0.10",
"license": "GPL-3.0-only",
"url": "https://github.com/AutoDarkMode/Windows-Auto-Night-Mode/releases/download/10.1.0.10/AutoDarkModeX_10.1.0.10.zip",
"hash": "fa78d748e46fe81e6e3f19a5c54da424a6142f3e8b520684b41774af2e1b93f9",
"shortcuts": [
[
"AutoDarkModeApp.exe",
"Auto Dark Mode"
]
],
"checkver": "github",
"autoupdate": {
"url": "https://github.com/AutoDarkMode/Windows-Auto-Night-Mode/releases/download/$version/AutoDarkModeX_$version.zip",
"hash": {
"url": "https://github.com/AutoDarkMode/Windows-Auto-Night-Mode/releases/download/$version/AutoDarkModeX_$version.sha256",
"mode": "extract"
}
}
}
| 448 |
410 | <reponame>bkrrr/Giveme5W
{
"dId": "3a01b8dc9bf6e345bf2ddfc0fb88a4660542d7e107f4ab4f138fd0b1",
"title": "US to probe airline travel chaos",
"text": "The US government is to investigate two airlines- US Airways and Delta Air Lines' Comair subsidiary - after travel chaos over the Christmas weekend.\n\nStaff calling in sick at US Airways and computer failures at Comair left 30,000 passengers stranded and 10,000 pieces of baggage undelivered. US Airways is in Chapter 11 bankruptcy protection for the second time in two years, and battling to cut costs. It is currently trying to negotiate pay cuts with flight and baggage staff.\n\nTransportation Secretary <NAME> said he was \"deeply concerned\" at the disruption to passengers, and ordered a thorough investigation. Comair's computer breakdown plunged its flight-crew scheduling system into disarray. Altogether, some 1,100 flights were cancelled over the holiday long weekend. Mr Mineta said it was important to understand \"what happened, why it happened and whether the carriers properly planned for the holiday travel period and responded appropriately to consumer needs in the aftermath\".\n\nAdding to the atmosphere of chaos were mountains of luggage left to pile up when a third of US Airways' baggage handling staff called in sick. There was also a shortage of US Airways flight attendants, with nearly a fifth saying they were too sick to work, leading to many flight cancellations. However, union officials denied there had been a deliberate \"sickout\". They said that many people have flu at this time of year and that the airline is chronically understaffed.\n\nUS Airways ended up cancelling over 100 flights on Christmas Day, stranding passengers in as many as 119 airports. Ground crews at US Airways, the seventh-largest US airline, which is now in Chapter 11 bankruptcy protection, face a court-imposed pay cut next month. The airline needs to negotiate other paycuts if it is to find a route out of bankruptcy. It is looking for paycuts totalling $800m.\n\n\"US Airways has a full-scale employee mutiny on its hands,\" commented <NAME>, an industry consultant. Disruptions to flight schedules could discourage customers from flying with US Airways, reducing revenues. US Airways had to cancel approximately 65 flights on Thursday, 180 on Friday, 140 on Saturday, 43 on Sunday and 15 on Monday, said industry officials. The airline said it was \"embarrassed by the situation\" and \"deeply regrets any inconvenience caused to customers,\" The probe will focus on the industry's compliance with a 1999 agreement aimed at improving the quality of passenger service that has so far allowed airlines to avoid congressionally-mandated standards. Analysts said the Christmas chaos cast doubt on US Airway's ability to emerge from bankruptcy - and was likely to worsen the finances of troubled Delta, parent of Comair. Comair \"deeply regrets the inconvenience to all of our customers caused by the severe winter storm in the Ohio River Valley during the busy holiday season, exacerbated by problems with the airline's crew scheduling system, causing additional flight delays and cancellations,\" the Delta subsidiary said in a statement.",
"description": "",
"category": "business",
"filename": "348.txt",
"date_publish": "2004-12-28T00:00:00"
} | 747 |
365 | #!/usr/bin/env python
# A process which emits a process communications event on its stdout,
# and subsequently waits for a line to be sent back to its stdin by
# loop_listener.py.
import sys
import time
from supervisor import childutils
def main(max):
start = time.time()
report = open('/tmp/report', 'w')
i = 0
while 1:
childutils.pcomm.stdout('the_data')
data = sys.stdin.readline()
report.write(str(i) + ' @ %s\n' % childutils.get_asctime())
report.flush()
i+=1
if max and i >= max:
end = time.time()
report.write('%s per second\n' % (i / (end - start)))
sys.exit(0)
if __name__ == '__main__':
max = 0
if len(sys.argv) > 1:
max = int(sys.argv[1])
main(max)
| 360 |
852 | <reponame>ckamtsikis/cmssw<filename>SimG4Core/Geometry/interface/DDG4DispContainer.h<gh_stars>100-1000
#ifndef SimG4Core_DDG4DispContainer_H
#define SimG4Core_DDG4DispContainer_H
#include "SimG4Core/Geometry/interface/DDG4Dispatchable.h"
#include <vector>
using DDG4DispContainer = std::vector<DDG4Dispatchable *>;
#endif
| 134 |
471 | <reponame>Zhongren233/forest
package com.dtflys.test.http.retry;
import com.dtflys.forest.backend.HttpBackend;
import com.dtflys.forest.config.ForestConfiguration;
import com.dtflys.forest.exceptions.ForestRuntimeException;
import com.dtflys.forest.http.ForestRequest;
import com.dtflys.test.http.BaseClientTest;
import okhttp3.mockwebserver.MockResponse;
import okhttp3.mockwebserver.MockWebServer;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import java.util.concurrent.atomic.AtomicReference;
import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
/**
* @author gongjun[<EMAIL>]
* @since 2021-09-16 22:25
*/
public class TestSuccessWhenClient extends BaseClientTest {
public final static String EXPECTED = "{\"status\": \"error\"}";
@Rule
public MockWebServer server = new MockWebServer();
private static ForestConfiguration configuration;
private final SuccessWhenClient successWhenClient;
private final SuccessWhenClient2 successWhenClient2;
@BeforeClass
public static void prepareClient() {
configuration = ForestConfiguration.createConfiguration();
}
public TestSuccessWhenClient(HttpBackend backend) {
super(backend, configuration);
configuration.setVariableValue("port", server.getPort());
successWhenClient = configuration.createInstance(SuccessWhenClient.class);
successWhenClient2 = configuration.createInstance(SuccessWhenClient2.class);
}
@Test
public void testRetry_with_successWhen() {
server.enqueue(new MockResponse().setBody(EXPECTED).setResponseCode(203));
server.enqueue(new MockResponse().setBody(EXPECTED).setResponseCode(203));
server.enqueue(new MockResponse().setBody(EXPECTED).setResponseCode(203));
server.enqueue(new MockResponse().setBody(EXPECTED).setResponseCode(203));
AtomicReference<Boolean> isError = new AtomicReference<>(false);
ForestRequest<String> request = successWhenClient.testRetryRequest_with_successWhen(3, (ex, req, res) -> {
isError.set(true);
});
assertThat(request).isNotNull();
assertThat(request.getSuccessWhen()).isNotNull().isInstanceOf(TestSuccessWhen.class);
try {
request.execute();
} catch (Throwable ignored) {}
assertThat(request.getRetryCount()).isEqualTo(3);
assertThat(isError.get()).isTrue();
}
@Test
public void testRetry_with_error_successWhen() {
server.enqueue(new MockResponse().setBody(EXPECTED).setResponseCode(203));
server.enqueue(new MockResponse().setBody(EXPECTED).setResponseCode(203));
server.enqueue(new MockResponse().setBody(EXPECTED).setResponseCode(203));
server.enqueue(new MockResponse().setBody(EXPECTED).setResponseCode(203));
AtomicReference<Boolean> isError = new AtomicReference<>(false);
ForestRequest<String> request = successWhenClient.testRetryRequest_with_error_successWhen(3, (ex, req, res) -> {
isError.set(true);
});
assertThat(request).isNotNull();
assertThat(request.getSuccessWhen()).isNotNull().isInstanceOf(ErrorSuccessWhen.class);
ForestRuntimeException exception = null;
try {
request.execute();
} catch (ForestRuntimeException ex) {
exception = ex;
}
assertThat(request.getMaxRetryCount()).isEqualTo(3);
assertThat(request.getCurrentRetryCount()).isEqualTo(0);
assertThat(isError.get()).isFalse();
assertThat(exception).isNotNull();
}
@Test
public void testRetry_base() {
server.enqueue(new MockResponse().setBody(EXPECTED).setResponseCode(203));
server.enqueue(new MockResponse().setBody(EXPECTED).setResponseCode(203));
server.enqueue(new MockResponse().setBody(EXPECTED).setResponseCode(203));
server.enqueue(new MockResponse().setBody(EXPECTED).setResponseCode(203));
AtomicReference<Boolean> isError = new AtomicReference<>(false);
ForestRequest<String> request = successWhenClient2.testRetryRequest(3, (ex, req, res) -> {
isError.set(true);
});
assertThat(request).isNotNull();
assertThat(request.getSuccessWhen()).isNotNull().isInstanceOf(TestSuccessWhen.class);
try {
request.execute();
} catch (Throwable ignored) {}
assertThat(request.getCurrentRetryCount()).isEqualTo(3);
assertThat(isError.get()).isTrue();
}
@Test
public void testRetry_base_success() {
server.enqueue(new MockResponse().setBody(EXPECTED).setResponseCode(203));
AtomicReference<Boolean> isError = new AtomicReference<>(false);
ForestRequest<String> request = successWhenClient2.testRetryRequest_success(3, (ex, req, res) -> {
isError.set(true);
});
assertThat(request).isNotNull();
assertThat(request.getSuccessWhen()).isNotNull().isInstanceOf(TestSuccessWhen2.class);
try {
request.execute();
} catch (Throwable ignored) {}
assertThat(request.getCurrentRetryCount()).isEqualTo(0);
assertThat(isError.get()).isFalse();
}
}
| 1,979 |
1,771 | <gh_stars>1000+
'''
This module implements the b-bit MinHash.
http://research.microsoft.com/pubs/120078/wfc0398-liPS.pdf
b-bit MinHash reduces storage space by storing only the b lowest bits
of each minimum hashed value, without significant loss of accuracy.
'''
import struct
import numpy as np
class bBitMinHash(object):
'''
The b-bit MinHash object
'''
__slots__ = ('seed', 'b', 'r', 'hashvalues')
# seed as int64
# b as uint8
# r as float64
# num_perm as int32
_serial_fmt_params = '<qBdi'
# each block as uint64
_serial_fmt_block = 'Q'
def __init__(self, minhash, b=1, r=0.0):
'''
Initialize a b-bit MinHash given an existing full MinHash
object and parameter b - the number of bits to store for
each minimum hashed values in the MinHash object.
'''
b = int(b)
r = float(r)
if b > 32 or b < 0:
raise ValueError("b must be an integer in [0, 32]")
if r > 1.0:
raise ValueError("r must be a float in [0.0, 1.0]")
bmask = (1 << b) - 1
self.hashvalues = np.bitwise_and(minhash.hashvalues, bmask)\
.astype(np.uint32)
self.seed = minhash.seed
self.b = b
self.r = r
def __eq__(self, other):
'''
Check for full equality of two b-bit MinHash objects.
'''
return type(self) is type(other) and \
self.seed == other.seed and \
self.b == other.b and \
self.r == other.r and \
np.array_equal(self.hashvalues, other.hashvalues)
def jaccard(self, other):
'''
Estimate the Jaccard similarity (resemblance) between this b-bit
MinHash and the other.
'''
if self.b != other.b:
raise ValueError("Cannot compare two b-bit MinHashes with different\
b values")
if self.seed != other.seed:
raise ValueError("Cannot compare two b-bit MinHashes with different\
set of permutations")
intersection = np.count_nonzero(self.hashvalues==other.hashvalues)
raw_est = float(intersection) / float(self.hashvalues.size)
a1 = self._calc_a(self.r, self.b)
a2 = self._calc_a(other.r, other.b)
c1, c2 = self._calc_c(a1, a2, self.r, other.r)
return (raw_est - c1) / (1 - c2)
def bytesize(self):
'''
Get the serialized size of this b-bit MinHash in number of bytes.
'''
return self._bytesize()[-1]
def __getstate__(self):
'''
This function is called when pickling the b-bit MinHash object.
Returns a bytearray which will then be pickled.
'''
slot_size, n, num_blocks, total = self._bytesize()
buffer = bytearray(total)
blocks = np.zeros((num_blocks,), dtype=np.uint64)
for i in range(num_blocks):
# Obtain the current segment of n hashed values
start = i * n
hvs = self.hashvalues[start:start+n]
# Store the n b-bit hashed values in the current block
for j, hv in enumerate(hvs):
blocks[i] |= np.uint64(hv << (n - 1 - j) * slot_size)
fmt = self._serial_fmt_params + \
"%d%s" % (num_blocks, self._serial_fmt_block)
struct.pack_into(fmt, buffer, 0, self.seed, self.b, self.r, \
self.hashvalues.size, *blocks)
return buffer
def __setstate__(self, buf):
'''
This function is called when unpickling the b-bit MinHash object.
Initialize the object with data in the buffer.
'''
try:
self.seed, self.b, self.r, num_perm = \
struct.unpack_from(self._serial_fmt_params, buf, 0)
except TypeError:
self.seed, self.b, self.r, num_perm = \
struct.unpack_from(self._serial_fmt_params, buffer(buf), 0)
offset = struct.calcsize(self._serial_fmt_params)
self.hashvalues = np.zeros((num_perm,), dtype=np.uint32)
# Reconstruct the hash values
slot_size, n, num_blocks, total = self._bytesize()
fmt = "%d%s" % (num_blocks, self._serial_fmt_block)
try:
blocks = struct.unpack_from(fmt, buf, offset)
except TypeError:
blocks = struct.unpack_from(fmt, buffer(buf), offset)
mask = (1 << slot_size) - 1
for i in range(num_blocks):
start = i * n
for j, _ in enumerate(self.hashvalues[start:start+n]):
hv = (blocks[i] >> (n - 1 - j) * slot_size) & mask
self.hashvalues[start+j] = np.uint32(hv)
def _calc_a(self, r, b):
'''
Compute the function A(r, b)
'''
if r == 0.0:
# Find the limit of A(r, b) as r -> 0.
return 1.0 / (1 << b)
return r * (1 - r) ** (2 ** b - 1) / (1 - (1 - r) ** (2 * b))
def _calc_c(self, a1, a2, r1, r2):
'''
Compute the functions C1 and C2
'''
if r1 == 0.0 and r2 == 0.0:
# Find the limits of C1 and C2 as r1 -> 0 and r2 -> 0
# Since the b-value must be the same and r1 = r2,
# we have A1(r1, b1) = A2(r2, b2) = A,
# then the limits for both C1 and C2 are A.
return a1, a2
div = 1 / (r1 + r2)
c1 = (a1 * r2 + a2 * r1) * div
c2 = (a1 * r1 + a2 * r2) * div
return c1, c2
def _find_slot_size(self, b):
if b == 1:
return 1
if b == 2:
return 2
if b <= 4:
return 4
if b <= 8:
return 8
if b <= 16:
return 16
if b <= 32:
return 32
raise ValueError("Incorrect value of b")
def _bytesize(self):
block_size = struct.calcsize(self._serial_fmt_block)
# Get the size of the slot for storing one b-bit hashed value
slot_size = self._find_slot_size(self.b)
# Get the number of slots to be stored in each block
num_slots_per_block = int(block_size * 8 / slot_size)
# Get the number of blocks required
num_blocks = int(np.ceil(float(self.hashvalues.size) /\
num_slots_per_block))
# Get the total serialized size
total = struct.calcsize(self._serial_fmt_params + \
"%d%s" % (num_blocks, self._serial_fmt_block))
return slot_size, num_slots_per_block, num_blocks, total
| 3,205 |
7,399 | <reponame>zqdely/redis
/*
* Copyright (c), Microsoft Open Technologies, Inc.
* All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* - Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef WIN32_INTEROP_WSIOCP_H
#define WIN32_INTEROP_WSIOCP_H
#include "win32_wsiocp2.h"
/* structs and functions for using IOCP with windows sockets */
/* structure used for async write requests.
* contains overlapped, WSABuf, and callback info
* NOTE: OVERLAPPED must be first member */
typedef struct asendreq {
OVERLAPPED ov;
WSABUF wbuf;
WSIOCP_Request req;
aeFileProc *proc;
aeEventLoop *eventLoop;
} asendreq;
/* structure used for async accept requests.
* contains overlapped, accept socket, accept buffer
* NOTE: OVERLAPPED must be first member */
typedef struct aacceptreq {
OVERLAPPED ov;
SOCKET accept;
void *buf;
struct aacceptreq *next;
} aacceptreq;
/* per socket information */
typedef struct iocpSockState {
int masks;
int fd;
aacceptreq *reqs;
int wreqs;
OVERLAPPED ov_read;
list wreqlist;
int unknownComplete;
} iocpSockState;
#define READ_QUEUED 0x000100
#define SOCKET_ATTACHED 0x000400
#define ACCEPT_PENDING 0x000800
#define LISTEN_SOCK 0x001000
#define CONNECT_PENDING 0x002000
#define CLOSE_PENDING 0x004000
void WSIOCP_Init(HANDLE iocp);
void WSIOCP_Cleanup();
iocpSockState* WSIOCP_GetExistingSocketState(int fd);
iocpSockState* WSIOCP_GetSocketState(int fd);
BOOL WSIOCP_CloseSocketState(iocpSockState* pSocketState);
void* CallocMemoryNoCOW(size_t size);
void FreeMemoryNoCOW(void * ptr);
#endif
| 1,018 |
554 | <filename>tests/api/test___init__.py
import json
import os
import pytest
from atm.api import create_app
from atm.core import ATM
from atm.database import Database
DB_PATH = '/tmp/atm.db'
DB_CACHE_PATH = os.path.join(os.path.join(os.path.dirname(__file__), os.pardir), 'modelhub')
@pytest.fixture
def db():
if os.path.exists(DB_PATH):
os.remove(DB_PATH)
db = Database(dialect='sqlite', database=DB_PATH)
# load cached ModelHub state. This database snapshot has one dataset
# (pollution.csv) and two dataruns, one complete and one with 33/100
# classifiers finished.
db.from_csv(DB_CACHE_PATH)
return db
@pytest.fixture
def atm():
return ATM(database=DB_PATH)
@pytest.fixture
def client(atm):
app = create_app(atm)
app.config['TESTING'] = True
client = app.test_client()
yield client
def test_create_app(atm):
app = create_app(atm)
assert app.name == 'atm.api'
assert not app.config['DEBUG']
def test_create_app_debug(atm):
app = create_app(atm, debug=True)
assert app.name == 'atm.api'
assert app.config['DEBUG']
def test_get_home(client):
res = client.get('/', follow_redirects=False)
assert res.status == '302 FOUND'
assert res.location == 'http://localhost/static/swagger/swagger-ui/index.html'
def test_get_dataset(client):
res = client.get('api/datasets')
data = json.loads(res.data.decode('utf-8'))
assert res.status == '200 OK'
assert data.get('num_results') == 1
def test_options_dataset(client):
res = client.options('api/datasets')
expected_headers = [
('Content-Type', 'text/html; charset=utf-8'),
('Access-Control-Allow-Headers', 'Content-Type, Authorization'),
('Access-Control-Allow-Origin', '*'),
('Access-Control-Allow-Credentials', 'true'),
]
assert set(expected_headers).issubset(set(res.headers.to_list()))
def test_get_datarun(client):
res = client.get('api/dataruns')
data = json.loads(res.data.decode('utf-8'))
assert res.status == '200 OK'
assert data.get('num_results') == 2
def test_get_hyperpartition(client):
res = client.get('api/hyperpartitions')
data = json.loads(res.data.decode('utf-8'))
assert res.status == '200 OK'
assert data.get('num_results') == 40
def test_get_classifier(client):
res = client.get('api/classifiers')
data = json.loads(res.data.decode('utf-8'))
assert res.status == '200 OK'
assert data.get('num_results') == 133
| 989 |
6,992 | /*
* Copyright 2004, 2005, 2006 Acegi Technology Pty 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
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.security.access.intercept.aopalliance;
import java.lang.reflect.Method;
import org.junit.jupiter.api.Test;
import org.springframework.security.TargetObject;
import org.springframework.security.access.SecurityConfig;
import org.springframework.security.access.method.MethodSecurityMetadataSource;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
/**
* Tests {@link MethodSecurityMetadataSourceAdvisor}.
*
* @author <NAME>
*/
public class MethodSecurityMetadataSourceAdvisorTests {
@Test
public void testAdvisorReturnsFalseWhenMethodInvocationNotDefined() throws Exception {
Class<TargetObject> clazz = TargetObject.class;
Method method = clazz.getMethod("makeLowerCase", new Class[] { String.class });
MethodSecurityMetadataSource mds = mock(MethodSecurityMetadataSource.class);
given(mds.getAttributes(method, clazz)).willReturn(null);
MethodSecurityMetadataSourceAdvisor advisor = new MethodSecurityMetadataSourceAdvisor("", mds, "");
assertThat(advisor.getPointcut().getMethodMatcher().matches(method, clazz)).isFalse();
}
@Test
public void testAdvisorReturnsTrueWhenMethodInvocationIsDefined() throws Exception {
Class<TargetObject> clazz = TargetObject.class;
Method method = clazz.getMethod("countLength", new Class[] { String.class });
MethodSecurityMetadataSource mds = mock(MethodSecurityMetadataSource.class);
given(mds.getAttributes(method, clazz)).willReturn(SecurityConfig.createList("ROLE_A"));
MethodSecurityMetadataSourceAdvisor advisor = new MethodSecurityMetadataSourceAdvisor("", mds, "");
assertThat(advisor.getPointcut().getMethodMatcher().matches(method, clazz)).isTrue();
}
}
| 688 |
2,571 | // ***************************************************************
// Copyright (c) 2021 Jittor.
// All Rights Reserved.
// Maintainers: <NAME> <<EMAIL>>.
//
// This file is subject to the terms and conditions defined in
// file 'LICENSE.txt', which is part of this source code package.
// ***************************************************************
#ifdef HAS_CUDA
#include <cuda_runtime.h>
#include "helper_cuda.h"
#include <mutex>
#include "misc/cuda_flags.h"
#include "mem/allocator/sfrl_allocator.h"
#include "mem/allocator/cuda_dual_allocator.h"
#include "event_queue.h"
#endif
#include "ops/fetch_op.h"
#include "mem/allocator.h"
#include "executor.h"
namespace jittor {
#ifdef HAS_CUDA
#pragma GCC visibility push(hidden)
namespace fetcher_local {
cudaStream_t stream;
cudaEvent_t event;
volatile int64 n_to_fetch;
std::mutex m;
list<FetchResult> fetch_tasks;
static void fetch_caller() {
fetch_tasks.front().call();
fetch_tasks.pop_front();
}
static void to_fetch(CUDA_HOST_FUNC_ARGS) {
event_queue.push(fetch_caller);
}
struct Init {
Init() {
if (!get_device_count()) return;
checkCudaErrors(cudaStreamCreateWithFlags(&stream, cudaStreamNonBlocking));
checkCudaErrors(cudaEventCreate(&event, cudaEventDisableTiming));
}
~Init() {
if (!get_device_count()) return;
// do not call deleter on exit
for (auto& f : fetch_tasks)
f.func.deleter = nullptr;
peekCudaErrors(cudaDeviceSynchronize());
peekCudaErrors(cudaStreamDestroy(stream));
peekCudaErrors(cudaEventDestroy(event));
}
} ;
}
using namespace fetcher_local;
#endif
list<VarPtr> fetcher;
// this list will be free at each execution
list<VarPtr> fetcher_to_free;
FetchOp::FetchOp(vector<Var*>&& inputs, FetchFunc&& func)
: fetch_vars(inputs), func(move(func)) {
#ifdef HAS_CUDA
// stream needs to be created after nccl plugin
static Init init_fetch;
#endif
VarPtr vp(0, ns_int32);
outputs_holder.emplace_back(vp);
fetcher.emplace_front(move(vp));
fetcher_iter = fetcher.begin();
bool all_finished = true;
for (auto v : fetch_vars)
if (!v->is_finished()) {
all_finished = false;
v->flags.set(NodeFlags::_stop_fuse);
v->flags.set(NodeFlags::_fetch);
}
flags.set(NodeFlags::_cpu);
flags.set(NodeFlags::_cuda);
flags.set(NodeFlags::_fetch);
flags.set(NodeFlags::_stop_grad);
fetcher_iter->ptr->flags.set(NodeFlags::_fetch);
// fetcher_to_free.clear();
if (all_finished) {
// if all finished, run immediately
run();
}
// if too many fetchers are bufferd, force flush
while (fetcher.size() > 20) {
LOGvvvv << "too many fetchers(">>fetcher.size() >>
") are bufferd, force flush";
exe.run_sync({fetcher.back().ptr}, false);
}
}
void FetchOp::run() {
vector<Allocation> allocations(fetch_vars.size());
vector<ArrayArgs> arrays(fetch_vars.size());
#ifdef HAS_CUDA
bool has_cuda_memcpy = false;
event_queue.flush();
#endif
LOGvvvv << "fetch" << fetch_vars.size() << "vars" << fetch_vars;
int i = 0;
for (auto v : fetch_vars) {
auto& allocation = allocations[i];
#ifdef HAS_CUDA
if (v->allocator->is_cuda()) {
checkCudaErrors(cudaEventRecord(event, 0));
checkCudaErrors(cudaStreamWaitEvent(stream, event, 0));
new (&allocation) Allocation(&cuda_dual_allocator, v->size);
// mostly device to device
checkCudaErrors(cudaMemcpyAsync(
allocation.ptr, v->mem_ptr, v->size, cudaMemcpyDefault, stream));
auto host_ptr = cuda_dual_allocator.get_dual_allocation(
allocation.allocation).host_ptr;
// device to host
checkCudaErrors(cudaMemcpyAsync(
host_ptr, allocation.ptr, v->size, cudaMemcpyDefault, stream));
allocation.ptr = host_ptr;
has_cuda_memcpy = true;
} else
#endif
{
new (&allocation) Allocation(cpu_allocator, v->size);
std::memcpy(allocation.ptr, v->mem_ptr, v->size);
}
arrays[i].ptr = allocation.ptr;
arrays[i].shape = v->shape;
arrays[i].dtype = v->dtype();
i++;
}
#ifdef HAS_CUDA
if (has_cuda_memcpy) {
fetch_tasks.push_back({move(func), move(allocations), move(arrays)});
checkCudaErrors(_cudaLaunchHostFunc(stream, &to_fetch, 0));
} else
#endif
{
FetchResult fr{move(func), move(allocations), move(arrays)};
fr.call();
}
fetcher_to_free.emplace_front(move(*fetcher_iter));
fetcher.erase(fetcher_iter);
}
} // jittor
| 2,061 |
2,693 | <reponame>Chillee/benchmark<gh_stars>1000+
from fastNLP.io.dataset_loader import ZhConllPOSReader
def cut_long_sentence(sent, max_sample_length=200):
sent_no_space = sent.replace(' ', '')
cutted_sentence = []
if len(sent_no_space) > max_sample_length:
parts = sent.strip().split()
new_line = ''
length = 0
for part in parts:
length += len(part)
new_line += part + ' '
if length > max_sample_length:
new_line = new_line[:-1]
cutted_sentence.append(new_line)
length = 0
new_line = ''
if new_line != '':
cutted_sentence.append(new_line[:-1])
else:
cutted_sentence.append(sent)
return cutted_sentence
if __name__ == '__main__':
reader = ZhConllPOSReader()
d = reader.load('/home/hyan/train.conllx')
print(d) | 442 |
314 | """
Unit testing for particular segmentation module
Copyright (C) 2014-2018 <NAME> <<EMAIL>>
"""
import logging
import os
import sys
import unittest
import numpy as np
import pandas as pd
sys.path.append(os.path.abspath(os.path.join('..', '..'))) # Add path to root
from imsegm.graph_cuts import (
compute_pairwise_cost_from_transitions,
count_label_transitions_connected_segments,
estim_class_model_gmm,
segment_graph_cut_general,
)
from imsegm.labeling import histogram_regions_labels_norm
from imsegm.superpixels import segment_slic_img2d
from imsegm.utilities.data_samples import ANNOT_DROSOPHILA_OVARY_2D, IMAGE_DROSOPHILA_OVARY_2D, load_sample_image
from tests import PATH_OUTPUT
class TestGraphCut(unittest.TestCase):
img = load_sample_image(IMAGE_DROSOPHILA_OVARY_2D)
annot = load_sample_image(ANNOT_DROSOPHILA_OVARY_2D)
def test_count_transitions_segment(self):
img = self.img[:, :, 0]
annot = self.annot.astype(int)
slic = segment_slic_img2d(img, sp_size=15, relative_compact=0.2)
label_hist = histogram_regions_labels_norm(slic, annot)
labels = np.argmax(label_hist, axis=1)
trans = count_label_transitions_connected_segments({'a': slic}, {'a': labels})
path_csv = os.path.join(PATH_OUTPUT, 'labels_transitions.csv')
pd.DataFrame(trans).to_csv(path_csv)
gc_regul = compute_pairwise_cost_from_transitions(trans, 10.)
np.random.seed(0)
features = np.tile(labels, (5, 1)).T.astype(float)
features += np.random.random(features.shape) - 0.5
gmm = estim_class_model_gmm(features, 4)
proba = gmm.predict_proba(features)
segment_graph_cut_general(slic, proba, gc_regul)
if __name__ == '__main__':
logging.basicConfig(level=logging.DEBUG)
unittest.main()
| 767 |
573 | // Copyright 2015, VIXL authors
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// * Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
// * Neither the name of ARM Limited nor the names of its contributors may be
// used to endorse or promote products derived from this software without
// specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// ---------------------------------------------------------------------
// This file is auto generated using tools/generate_simulator_traces.py.
//
// PLEASE DO NOT EDIT.
// ---------------------------------------------------------------------
#ifndef VIXL_SIM_FMULX_S_S_S_TRACE_AARCH64_H_
#define VIXL_SIM_FMULX_S_S_S_TRACE_AARCH64_H_
const uint32_t kExpected_NEON_fmulx_S_S_S[] = {
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00009fc0, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00009fc0, 0x00000000, 0x00000000, 0x00000000,
0x00009fc0, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00009fc0, 0x00000000, 0x00000000, 0x00000000,
0x00009fc0, 0x00000000, 0x00000000, 0x00000000,
0x00009fc0, 0x00000000, 0x00000000, 0x00000000,
0x00009fc0, 0x00000000, 0x00000000, 0x00000000,
0x00009fc0, 0x00000000, 0x00000000, 0x00000000,
0x00009fc0, 0x00000000, 0x00000000, 0x00000000,
0x00013f80, 0x00000000, 0x00000000, 0x00000000,
0x00009fc0, 0x00000000, 0x00000000, 0x00000000,
0x00009fc0, 0x00000000, 0x00000000, 0x00000000,
0x00013f80, 0x00000000, 0x00000000, 0x00000000,
0x00013f80, 0x00000000, 0x00000000, 0x00000000,
0x00009fc0, 0x00000000, 0x00000000, 0x00000000,
0x00013f80, 0x00000000, 0x00000000, 0x00000000,
0x00013f80, 0x00000000, 0x00000000, 0x00000000,
0x00013f80, 0x00000000, 0x00000000, 0x00000000,
0x00013f80, 0x00000000, 0x00000000, 0x00000000,
0x00013f80, 0x00000000, 0x00000000, 0x00000000,
0x00013f80, 0x00000000, 0x00000000, 0x00000000,
0x0001df40, 0x00000000, 0x00000000, 0x00000000,
0x00013f80, 0x00000000, 0x00000000, 0x00000000,
0x00013f80, 0x00000000, 0x00000000, 0x00000000,
0x0001df40, 0x00000000, 0x00000000, 0x00000000,
0x000c7b00, 0x00000000, 0x00000000, 0x00000000,
0x00013f80, 0x00000000, 0x00000000, 0x00000000,
0x0001df40, 0x00000000, 0x00000000, 0x00000000,
0x000c7b00, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x0001df40, 0x00000000, 0x00000000, 0x00000000,
0x000c7b00, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x000c7b00, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80009fc0, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80009fc0, 0x00000000, 0x00000000, 0x00000000,
0x80009fc0, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80009fc0, 0x00000000, 0x00000000, 0x00000000,
0x80009fc0, 0x00000000, 0x00000000, 0x00000000,
0x80009fc0, 0x00000000, 0x00000000, 0x00000000,
0x80009fc0, 0x00000000, 0x00000000, 0x00000000,
0x80009fc0, 0x00000000, 0x00000000, 0x00000000,
0x80009fc0, 0x00000000, 0x00000000, 0x00000000,
0x80013f80, 0x00000000, 0x00000000, 0x00000000,
0x80009fc0, 0x00000000, 0x00000000, 0x00000000,
0x80009fc0, 0x00000000, 0x00000000, 0x00000000,
0x80013f80, 0x00000000, 0x00000000, 0x00000000,
0x80013f80, 0x00000000, 0x00000000, 0x00000000,
0x80009fc0, 0x00000000, 0x00000000, 0x00000000,
0x80013f80, 0x00000000, 0x00000000, 0x00000000,
0x80013f80, 0x00000000, 0x00000000, 0x00000000,
0x80013f80, 0x00000000, 0x00000000, 0x00000000,
0x80013f80, 0x00000000, 0x00000000, 0x00000000,
0x80013f80, 0x00000000, 0x00000000, 0x00000000,
0x80013f80, 0x00000000, 0x00000000, 0x00000000,
0x8001df40, 0x00000000, 0x00000000, 0x00000000,
0x80013f80, 0x00000000, 0x00000000, 0x00000000,
0x80013f80, 0x00000000, 0x00000000, 0x00000000,
0x8001df40, 0x00000000, 0x00000000, 0x00000000,
0x800c7b00, 0x00000000, 0x00000000, 0x00000000,
0x80013f80, 0x00000000, 0x00000000, 0x00000000,
0x8001df40, 0x00000000, 0x00000000, 0x00000000,
0x800c7b00, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x8001df40, 0x00000000, 0x00000000, 0x00000000,
0x800c7b00, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x800c7b00, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00001fc0, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00001fc0, 0x00000000, 0x00000000, 0x00000000,
0x00001fc0, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00001fc0, 0x00000000, 0x00000000, 0x00000000,
0x00001fc0, 0x00000000, 0x00000000, 0x00000000,
0x00001fc0, 0x00000000, 0x00000000, 0x00000000,
0x00001fc0, 0x00000000, 0x00000000, 0x00000000,
0x00001fc0, 0x00000000, 0x00000000, 0x00000000,
0x00001fc0, 0x00000000, 0x00000000, 0x00000000,
0x00003f80, 0x00000000, 0x00000000, 0x00000000,
0x00001fc0, 0x00000000, 0x00000000, 0x00000000,
0x00001fc0, 0x00000000, 0x00000000, 0x00000000,
0x00003f80, 0x00000000, 0x00000000, 0x00000000,
0x00003f80, 0x00000000, 0x00000000, 0x00000000,
0x00001fc0, 0x00000000, 0x00000000, 0x00000000,
0x00003f80, 0x00000000, 0x00000000, 0x00000000,
0x00003f80, 0x00000000, 0x00000000, 0x00000000,
0x00003f80, 0x00000000, 0x00000000, 0x00000000,
0x00003f80, 0x00000000, 0x00000000, 0x00000000,
0x00003f80, 0x00000000, 0x00000000, 0x00000000,
0x00003f80, 0x00000000, 0x00000000, 0x00000000,
0x00005f40, 0x00000000, 0x00000000, 0x00000000,
0x00003f80, 0x00000000, 0x00000000, 0x00000000,
0x00003f80, 0x00000000, 0x00000000, 0x00000000,
0x00005f40, 0x00000000, 0x00000000, 0x00000000,
0x00027b00, 0x00000000, 0x00000000, 0x00000000,
0x00003f80, 0x00000000, 0x00000000, 0x00000000,
0x00005f40, 0x00000000, 0x00000000, 0x00000000,
0x00027b00, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x00005f40, 0x00000000, 0x00000000, 0x00000000,
0x00027b00, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x00027b00, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80001fc0, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80001fc0, 0x00000000, 0x00000000, 0x00000000,
0x80001fc0, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80001fc0, 0x00000000, 0x00000000, 0x00000000,
0x80001fc0, 0x00000000, 0x00000000, 0x00000000,
0x80001fc0, 0x00000000, 0x00000000, 0x00000000,
0x80001fc0, 0x00000000, 0x00000000, 0x00000000,
0x80001fc0, 0x00000000, 0x00000000, 0x00000000,
0x80001fc0, 0x00000000, 0x00000000, 0x00000000,
0x80003f80, 0x00000000, 0x00000000, 0x00000000,
0x80001fc0, 0x00000000, 0x00000000, 0x00000000,
0x80001fc0, 0x00000000, 0x00000000, 0x00000000,
0x80003f80, 0x00000000, 0x00000000, 0x00000000,
0x80003f80, 0x00000000, 0x00000000, 0x00000000,
0x80001fc0, 0x00000000, 0x00000000, 0x00000000,
0x80003f80, 0x00000000, 0x00000000, 0x00000000,
0x80003f80, 0x00000000, 0x00000000, 0x00000000,
0x80003f80, 0x00000000, 0x00000000, 0x00000000,
0x80003f80, 0x00000000, 0x00000000, 0x00000000,
0x80003f80, 0x00000000, 0x00000000, 0x00000000,
0x80003f80, 0x00000000, 0x00000000, 0x00000000,
0x80005f40, 0x00000000, 0x00000000, 0x00000000,
0x80003f80, 0x00000000, 0x00000000, 0x00000000,
0x80003f80, 0x00000000, 0x00000000, 0x00000000,
0x80005f40, 0x00000000, 0x00000000, 0x00000000,
0x80027b00, 0x00000000, 0x00000000, 0x00000000,
0x80003f80, 0x00000000, 0x00000000, 0x00000000,
0x80005f40, 0x00000000, 0x00000000, 0x00000000,
0x80027b00, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x80005f40, 0x00000000, 0x00000000, 0x00000000,
0x80027b00, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x80027b00, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00001fe0, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00001fe0, 0x00000000, 0x00000000, 0x00000000,
0x00001fe0, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00001fe0, 0x00000000, 0x00000000, 0x00000000,
0x00001fe0, 0x00000000, 0x00000000, 0x00000000,
0x00001fe0, 0x00000000, 0x00000000, 0x00000000,
0x00001fe0, 0x00000000, 0x00000000, 0x00000000,
0x00001fe0, 0x00000000, 0x00000000, 0x00000000,
0x00001fe0, 0x00000000, 0x00000000, 0x00000000,
0x00003fc0, 0x00000000, 0x00000000, 0x00000000,
0x00001fe0, 0x00000000, 0x00000000, 0x00000000,
0x00001fe0, 0x00000000, 0x00000000, 0x00000000,
0x00003fc0, 0x00000000, 0x00000000, 0x00000000,
0x00003fc0, 0x00000000, 0x00000000, 0x00000000,
0x00001fe0, 0x00000000, 0x00000000, 0x00000000,
0x00003fc0, 0x00000000, 0x00000000, 0x00000000,
0x00003fc0, 0x00000000, 0x00000000, 0x00000000,
0x00003fc0, 0x00000000, 0x00000000, 0x00000000,
0x00003fc0, 0x00000000, 0x00000000, 0x00000000,
0x00003fc0, 0x00000000, 0x00000000, 0x00000000,
0x00003fc0, 0x00000000, 0x00000000, 0x00000000,
0x00005fa0, 0x00000000, 0x00000000, 0x00000000,
0x00003fc0, 0x00000000, 0x00000000, 0x00000000,
0x00003fc0, 0x00000000, 0x00000000, 0x00000000,
0x00005fa0, 0x00000000, 0x00000000, 0x00000000,
0x00027d80, 0x00000000, 0x00000000, 0x00000000,
0x00003fc0, 0x00000000, 0x00000000, 0x00000000,
0x00005fa0, 0x00000000, 0x00000000, 0x00000000,
0x00027d80, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x00005fa0, 0x00000000, 0x00000000, 0x00000000,
0x00027d80, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x00027d80, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80001fe0, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80001fe0, 0x00000000, 0x00000000, 0x00000000,
0x80001fe0, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80001fe0, 0x00000000, 0x00000000, 0x00000000,
0x80001fe0, 0x00000000, 0x00000000, 0x00000000,
0x80001fe0, 0x00000000, 0x00000000, 0x00000000,
0x80001fe0, 0x00000000, 0x00000000, 0x00000000,
0x80001fe0, 0x00000000, 0x00000000, 0x00000000,
0x80001fe0, 0x00000000, 0x00000000, 0x00000000,
0x80003fc0, 0x00000000, 0x00000000, 0x00000000,
0x80001fe0, 0x00000000, 0x00000000, 0x00000000,
0x80001fe0, 0x00000000, 0x00000000, 0x00000000,
0x80003fc0, 0x00000000, 0x00000000, 0x00000000,
0x80003fc0, 0x00000000, 0x00000000, 0x00000000,
0x80001fe0, 0x00000000, 0x00000000, 0x00000000,
0x80003fc0, 0x00000000, 0x00000000, 0x00000000,
0x80003fc0, 0x00000000, 0x00000000, 0x00000000,
0x80003fc0, 0x00000000, 0x00000000, 0x00000000,
0x80003fc0, 0x00000000, 0x00000000, 0x00000000,
0x80003fc0, 0x00000000, 0x00000000, 0x00000000,
0x80003fc0, 0x00000000, 0x00000000, 0x00000000,
0x80005fa0, 0x00000000, 0x00000000, 0x00000000,
0x80003fc0, 0x00000000, 0x00000000, 0x00000000,
0x80003fc0, 0x00000000, 0x00000000, 0x00000000,
0x80005fa0, 0x00000000, 0x00000000, 0x00000000,
0x80027d80, 0x00000000, 0x00000000, 0x00000000,
0x80003fc0, 0x00000000, 0x00000000, 0x00000000,
0x80005fa0, 0x00000000, 0x00000000, 0x00000000,
0x80027d80, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x80005fa0, 0x00000000, 0x00000000, 0x00000000,
0x80027d80, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x80027d80, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x40000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x40000000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x40000000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x40000000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xc0000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xc0000000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xc0000000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xc0000000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x00800001, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x00800001, 0x00000000, 0x00000000, 0x00000000,
0x00c00000, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x00800001, 0x00000000, 0x00000000, 0x00000000,
0x00c00000, 0x00000000, 0x00000000, 0x00000000,
0x02200000, 0x00000000, 0x00000000, 0x00000000,
0x00800001, 0x00000000, 0x00000000, 0x00000000,
0x00c00000, 0x00000000, 0x00000000, 0x00000000,
0x02200000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x00c00000, 0x00000000, 0x00000000, 0x00000000,
0x02200000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x02200000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0x80800001, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0x80800001, 0x00000000, 0x00000000, 0x00000000,
0x80c00000, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0x80800001, 0x00000000, 0x00000000, 0x00000000,
0x80c00000, 0x00000000, 0x00000000, 0x00000000,
0x82200000, 0x00000000, 0x00000000, 0x00000000,
0x80800001, 0x00000000, 0x00000000, 0x00000000,
0x80c00000, 0x00000000, 0x00000000, 0x00000000,
0x82200000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x80c00000, 0x00000000, 0x00000000, 0x00000000,
0x82200000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x82200000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80091a2b, 0x00000000, 0x00000000, 0x00000000,
0x803fffff, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x803fffff, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x3e7ffffe, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x3e7ffffe, 0x00000000, 0x00000000, 0x00000000,
0x3e7fffff, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x3e7ffffe, 0x00000000, 0x00000000, 0x00000000,
0x3e7fffff, 0x00000000, 0x00000000, 0x00000000,
0x3e800000, 0x00000000, 0x00000000, 0x00000000,
0x3e7ffffe, 0x00000000, 0x00000000, 0x00000000,
0x3e7fffff, 0x00000000, 0x00000000, 0x00000000,
0x3e800000, 0x00000000, 0x00000000, 0x00000000,
0x3efffffe, 0x00000000, 0x00000000, 0x00000000,
0x3e7fffff, 0x00000000, 0x00000000, 0x00000000,
0x3e800000, 0x00000000, 0x00000000, 0x00000000,
0x3efffffe, 0x00000000, 0x00000000, 0x00000000,
0x3effffff, 0x00000000, 0x00000000, 0x00000000,
0x3e800000, 0x00000000, 0x00000000, 0x00000000,
0x3efffffe, 0x00000000, 0x00000000, 0x00000000,
0x3effffff, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3efffffe, 0x00000000, 0x00000000, 0x00000000,
0x3effffff, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3f3fffff, 0x00000000, 0x00000000, 0x00000000,
0x3effffff, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3f3fffff, 0x00000000, 0x00000000, 0x00000000,
0x409fffff, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3f3fffff, 0x00000000, 0x00000000, 0x00000000,
0x409fffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x3f3fffff, 0x00000000, 0x00000000, 0x00000000,
0x409fffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x409fffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00091a2b, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00091a2b, 0x00000000, 0x00000000, 0x00000000,
0x003fffff, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00091a2b, 0x00000000, 0x00000000, 0x00000000,
0x003fffff, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00091a2b, 0x00000000, 0x00000000, 0x00000000,
0x003fffff, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x003fffff, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0xbe7ffffe, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0xbe7ffffe, 0x00000000, 0x00000000, 0x00000000,
0xbe7fffff, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0xbe7ffffe, 0x00000000, 0x00000000, 0x00000000,
0xbe7fffff, 0x00000000, 0x00000000, 0x00000000,
0xbe800000, 0x00000000, 0x00000000, 0x00000000,
0xbe7ffffe, 0x00000000, 0x00000000, 0x00000000,
0xbe7fffff, 0x00000000, 0x00000000, 0x00000000,
0xbe800000, 0x00000000, 0x00000000, 0x00000000,
0xbefffffe, 0x00000000, 0x00000000, 0x00000000,
0xbe7fffff, 0x00000000, 0x00000000, 0x00000000,
0xbe800000, 0x00000000, 0x00000000, 0x00000000,
0xbefffffe, 0x00000000, 0x00000000, 0x00000000,
0xbeffffff, 0x00000000, 0x00000000, 0x00000000,
0xbe800000, 0x00000000, 0x00000000, 0x00000000,
0xbefffffe, 0x00000000, 0x00000000, 0x00000000,
0xbeffffff, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbefffffe, 0x00000000, 0x00000000, 0x00000000,
0xbeffffff, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbf3fffff, 0x00000000, 0x00000000, 0x00000000,
0xbeffffff, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbf3fffff, 0x00000000, 0x00000000, 0x00000000,
0xc09fffff, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbf3fffff, 0x00000000, 0x00000000, 0x00000000,
0xc09fffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xbf3fffff, 0x00000000, 0x00000000, 0x00000000,
0xc09fffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xc09fffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80091a2b, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80091a2b, 0x00000000, 0x00000000, 0x00000000,
0x803fffff, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80091a2b, 0x00000000, 0x00000000, 0x00000000,
0x803fffff, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80091a2b, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x3e7fffff, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x3e7fffff, 0x00000000, 0x00000000, 0x00000000,
0x3e800000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x3e7fffff, 0x00000000, 0x00000000, 0x00000000,
0x3e800000, 0x00000000, 0x00000000, 0x00000000,
0x3e800001, 0x00000000, 0x00000000, 0x00000000,
0x3e7fffff, 0x00000000, 0x00000000, 0x00000000,
0x3e800000, 0x00000000, 0x00000000, 0x00000000,
0x3e800001, 0x00000000, 0x00000000, 0x00000000,
0x3effffff, 0x00000000, 0x00000000, 0x00000000,
0x3e800000, 0x00000000, 0x00000000, 0x00000000,
0x3e800001, 0x00000000, 0x00000000, 0x00000000,
0x3effffff, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3e800001, 0x00000000, 0x00000000, 0x00000000,
0x3effffff, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3f000001, 0x00000000, 0x00000000, 0x00000000,
0x3effffff, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3f000001, 0x00000000, 0x00000000, 0x00000000,
0x3f400000, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3f000001, 0x00000000, 0x00000000, 0x00000000,
0x3f400000, 0x00000000, 0x00000000, 0x00000000,
0x40a00000, 0x00000000, 0x00000000, 0x00000000,
0x3f000001, 0x00000000, 0x00000000, 0x00000000,
0x3f400000, 0x00000000, 0x00000000, 0x00000000,
0x40a00000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x3f400000, 0x00000000, 0x00000000, 0x00000000,
0x40a00000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x40a00000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00091a2b, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00091a2b, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00091a2b, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00091a2b, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0xbe7fffff, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0xbe7fffff, 0x00000000, 0x00000000, 0x00000000,
0xbe800000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0xbe7fffff, 0x00000000, 0x00000000, 0x00000000,
0xbe800000, 0x00000000, 0x00000000, 0x00000000,
0xbe800001, 0x00000000, 0x00000000, 0x00000000,
0xbe7fffff, 0x00000000, 0x00000000, 0x00000000,
0xbe800000, 0x00000000, 0x00000000, 0x00000000,
0xbe800001, 0x00000000, 0x00000000, 0x00000000,
0xbeffffff, 0x00000000, 0x00000000, 0x00000000,
0xbe800000, 0x00000000, 0x00000000, 0x00000000,
0xbe800001, 0x00000000, 0x00000000, 0x00000000,
0xbeffffff, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbe800001, 0x00000000, 0x00000000, 0x00000000,
0xbeffffff, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbf000001, 0x00000000, 0x00000000, 0x00000000,
0xbeffffff, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbf000001, 0x00000000, 0x00000000, 0x00000000,
0xbf400000, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbf000001, 0x00000000, 0x00000000, 0x00000000,
0xbf400000, 0x00000000, 0x00000000, 0x00000000,
0xc0a00000, 0x00000000, 0x00000000, 0x00000000,
0xbf000001, 0x00000000, 0x00000000, 0x00000000,
0xbf400000, 0x00000000, 0x00000000, 0x00000000,
0xc0a00000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xbf400000, 0x00000000, 0x00000000, 0x00000000,
0xc0a00000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xc0a00000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80091a2b, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80091a2b, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80091a2b, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80091a2b, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x3e800000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x3e800000, 0x00000000, 0x00000000, 0x00000000,
0x3e800001, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x3e800000, 0x00000000, 0x00000000, 0x00000000,
0x3e800001, 0x00000000, 0x00000000, 0x00000000,
0x3e800002, 0x00000000, 0x00000000, 0x00000000,
0x3e800000, 0x00000000, 0x00000000, 0x00000000,
0x3e800001, 0x00000000, 0x00000000, 0x00000000,
0x3e800002, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3e800001, 0x00000000, 0x00000000, 0x00000000,
0x3e800002, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3f000001, 0x00000000, 0x00000000, 0x00000000,
0x3e800002, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3f000001, 0x00000000, 0x00000000, 0x00000000,
0x3f000002, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3f000001, 0x00000000, 0x00000000, 0x00000000,
0x3f000002, 0x00000000, 0x00000000, 0x00000000,
0x3f400002, 0x00000000, 0x00000000, 0x00000000,
0x3f000001, 0x00000000, 0x00000000, 0x00000000,
0x3f000002, 0x00000000, 0x00000000, 0x00000000,
0x3f400002, 0x00000000, 0x00000000, 0x00000000,
0x40a00001, 0x00000000, 0x00000000, 0x00000000,
0x3f000002, 0x00000000, 0x00000000, 0x00000000,
0x3f400002, 0x00000000, 0x00000000, 0x00000000,
0x40a00001, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x3f400002, 0x00000000, 0x00000000, 0x00000000,
0x40a00001, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x40a00001, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00091a2b, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00091a2b, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00091a2b, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x00091a2b, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0xbe800000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0xbe800000, 0x00000000, 0x00000000, 0x00000000,
0xbe800001, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0xbe800000, 0x00000000, 0x00000000, 0x00000000,
0xbe800001, 0x00000000, 0x00000000, 0x00000000,
0xbe800002, 0x00000000, 0x00000000, 0x00000000,
0xbe800000, 0x00000000, 0x00000000, 0x00000000,
0xbe800001, 0x00000000, 0x00000000, 0x00000000,
0xbe800002, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbe800001, 0x00000000, 0x00000000, 0x00000000,
0xbe800002, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbf000001, 0x00000000, 0x00000000, 0x00000000,
0xbe800002, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbf000001, 0x00000000, 0x00000000, 0x00000000,
0xbf000002, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbf000001, 0x00000000, 0x00000000, 0x00000000,
0xbf000002, 0x00000000, 0x00000000, 0x00000000,
0xbf400002, 0x00000000, 0x00000000, 0x00000000,
0xbf000001, 0x00000000, 0x00000000, 0x00000000,
0xbf000002, 0x00000000, 0x00000000, 0x00000000,
0xbf400002, 0x00000000, 0x00000000, 0x00000000,
0xc0a00001, 0x00000000, 0x00000000, 0x00000000,
0xbf000002, 0x00000000, 0x00000000, 0x00000000,
0xbf400002, 0x00000000, 0x00000000, 0x00000000,
0xc0a00001, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xbf400002, 0x00000000, 0x00000000, 0x00000000,
0xc0a00001, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xc0a00001, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80091a2b, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80091a2b, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80091a2b, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x80123456, 0x00000000, 0x00000000, 0x00000000,
0x807fffff, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x807fffff, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x3efffffe, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x3efffffe, 0x00000000, 0x00000000, 0x00000000,
0x3effffff, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x3efffffe, 0x00000000, 0x00000000, 0x00000000,
0x3effffff, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3efffffe, 0x00000000, 0x00000000, 0x00000000,
0x3effffff, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3f7ffffe, 0x00000000, 0x00000000, 0x00000000,
0x3effffff, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3f7ffffe, 0x00000000, 0x00000000, 0x00000000,
0x3f7fffff, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3f7ffffe, 0x00000000, 0x00000000, 0x00000000,
0x3f7fffff, 0x00000000, 0x00000000, 0x00000000,
0x3f800000, 0x00000000, 0x00000000, 0x00000000,
0x3f7ffffe, 0x00000000, 0x00000000, 0x00000000,
0x3f7fffff, 0x00000000, 0x00000000, 0x00000000,
0x3f800000, 0x00000000, 0x00000000, 0x00000000,
0x3fbfffff, 0x00000000, 0x00000000, 0x00000000,
0x3f7fffff, 0x00000000, 0x00000000, 0x00000000,
0x3f800000, 0x00000000, 0x00000000, 0x00000000,
0x3fbfffff, 0x00000000, 0x00000000, 0x00000000,
0x411fffff, 0x00000000, 0x00000000, 0x00000000,
0x3f800000, 0x00000000, 0x00000000, 0x00000000,
0x3fbfffff, 0x00000000, 0x00000000, 0x00000000,
0x411fffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x3fbfffff, 0x00000000, 0x00000000, 0x00000000,
0x411fffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x411fffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00123456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00123456, 0x00000000, 0x00000000, 0x00000000,
0x007fffff, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00123456, 0x00000000, 0x00000000, 0x00000000,
0x007fffff, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x00123456, 0x00000000, 0x00000000, 0x00000000,
0x007fffff, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x007fffff, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0xbefffffe, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0xbefffffe, 0x00000000, 0x00000000, 0x00000000,
0xbeffffff, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0xbefffffe, 0x00000000, 0x00000000, 0x00000000,
0xbeffffff, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbefffffe, 0x00000000, 0x00000000, 0x00000000,
0xbeffffff, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbf7ffffe, 0x00000000, 0x00000000, 0x00000000,
0xbeffffff, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbf7ffffe, 0x00000000, 0x00000000, 0x00000000,
0xbf7fffff, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbf7ffffe, 0x00000000, 0x00000000, 0x00000000,
0xbf7fffff, 0x00000000, 0x00000000, 0x00000000,
0xbf800000, 0x00000000, 0x00000000, 0x00000000,
0xbf7ffffe, 0x00000000, 0x00000000, 0x00000000,
0xbf7fffff, 0x00000000, 0x00000000, 0x00000000,
0xbf800000, 0x00000000, 0x00000000, 0x00000000,
0xbfbfffff, 0x00000000, 0x00000000, 0x00000000,
0xbf7fffff, 0x00000000, 0x00000000, 0x00000000,
0xbf800000, 0x00000000, 0x00000000, 0x00000000,
0xbfbfffff, 0x00000000, 0x00000000, 0x00000000,
0xc11fffff, 0x00000000, 0x00000000, 0x00000000,
0xbf800000, 0x00000000, 0x00000000, 0x00000000,
0xbfbfffff, 0x00000000, 0x00000000, 0x00000000,
0xc11fffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xbfbfffff, 0x00000000, 0x00000000, 0x00000000,
0xc11fffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xc11fffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80123456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80123456, 0x00000000, 0x00000000, 0x00000000,
0x807fffff, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80123456, 0x00000000, 0x00000000, 0x00000000,
0x807fffff, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x80123456, 0x00000000, 0x00000000, 0x00000000,
0x807fffff, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x807fffff, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x3effffff, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x3effffff, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x3effffff, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3f000001, 0x00000000, 0x00000000, 0x00000000,
0x3effffff, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3f000001, 0x00000000, 0x00000000, 0x00000000,
0x3f7fffff, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3f000001, 0x00000000, 0x00000000, 0x00000000,
0x3f7fffff, 0x00000000, 0x00000000, 0x00000000,
0x3f800000, 0x00000000, 0x00000000, 0x00000000,
0x3f000001, 0x00000000, 0x00000000, 0x00000000,
0x3f7fffff, 0x00000000, 0x00000000, 0x00000000,
0x3f800000, 0x00000000, 0x00000000, 0x00000000,
0x3f800001, 0x00000000, 0x00000000, 0x00000000,
0x3f7fffff, 0x00000000, 0x00000000, 0x00000000,
0x3f800000, 0x00000000, 0x00000000, 0x00000000,
0x3f800001, 0x00000000, 0x00000000, 0x00000000,
0x3fc00000, 0x00000000, 0x00000000, 0x00000000,
0x3f800000, 0x00000000, 0x00000000, 0x00000000,
0x3f800001, 0x00000000, 0x00000000, 0x00000000,
0x3fc00000, 0x00000000, 0x00000000, 0x00000000,
0x41200000, 0x00000000, 0x00000000, 0x00000000,
0x3f800001, 0x00000000, 0x00000000, 0x00000000,
0x3fc00000, 0x00000000, 0x00000000, 0x00000000,
0x41200000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x3fc00000, 0x00000000, 0x00000000, 0x00000000,
0x41200000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x41200000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00123456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00123456, 0x00000000, 0x00000000, 0x00000000,
0x007fffff, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00123456, 0x00000000, 0x00000000, 0x00000000,
0x007fffff, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x00123456, 0x00000000, 0x00000000, 0x00000000,
0x007fffff, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x007fffff, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0xbeffffff, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0xbeffffff, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0xbeffffff, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbf000001, 0x00000000, 0x00000000, 0x00000000,
0xbeffffff, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbf000001, 0x00000000, 0x00000000, 0x00000000,
0xbf7fffff, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbf000001, 0x00000000, 0x00000000, 0x00000000,
0xbf7fffff, 0x00000000, 0x00000000, 0x00000000,
0xbf800000, 0x00000000, 0x00000000, 0x00000000,
0xbf000001, 0x00000000, 0x00000000, 0x00000000,
0xbf7fffff, 0x00000000, 0x00000000, 0x00000000,
0xbf800000, 0x00000000, 0x00000000, 0x00000000,
0xbf800001, 0x00000000, 0x00000000, 0x00000000,
0xbf7fffff, 0x00000000, 0x00000000, 0x00000000,
0xbf800000, 0x00000000, 0x00000000, 0x00000000,
0xbf800001, 0x00000000, 0x00000000, 0x00000000,
0xbfc00000, 0x00000000, 0x00000000, 0x00000000,
0xbf800000, 0x00000000, 0x00000000, 0x00000000,
0xbf800001, 0x00000000, 0x00000000, 0x00000000,
0xbfc00000, 0x00000000, 0x00000000, 0x00000000,
0xc1200000, 0x00000000, 0x00000000, 0x00000000,
0xbf800001, 0x00000000, 0x00000000, 0x00000000,
0xbfc00000, 0x00000000, 0x00000000, 0x00000000,
0xc1200000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xbfc00000, 0x00000000, 0x00000000, 0x00000000,
0xc1200000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xc1200000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80123456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80123456, 0x00000000, 0x00000000, 0x00000000,
0x807fffff, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80123456, 0x00000000, 0x00000000, 0x00000000,
0x807fffff, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x80123456, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00800001, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00800001, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00800001, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3f000001, 0x00000000, 0x00000000, 0x00000000,
0x00800001, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3f000001, 0x00000000, 0x00000000, 0x00000000,
0x3f000002, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3f000001, 0x00000000, 0x00000000, 0x00000000,
0x3f000002, 0x00000000, 0x00000000, 0x00000000,
0x3f800000, 0x00000000, 0x00000000, 0x00000000,
0x3f000001, 0x00000000, 0x00000000, 0x00000000,
0x3f000002, 0x00000000, 0x00000000, 0x00000000,
0x3f800000, 0x00000000, 0x00000000, 0x00000000,
0x3f800001, 0x00000000, 0x00000000, 0x00000000,
0x3f000002, 0x00000000, 0x00000000, 0x00000000,
0x3f800000, 0x00000000, 0x00000000, 0x00000000,
0x3f800001, 0x00000000, 0x00000000, 0x00000000,
0x3f800002, 0x00000000, 0x00000000, 0x00000000,
0x3f800000, 0x00000000, 0x00000000, 0x00000000,
0x3f800001, 0x00000000, 0x00000000, 0x00000000,
0x3f800002, 0x00000000, 0x00000000, 0x00000000,
0x3fc00002, 0x00000000, 0x00000000, 0x00000000,
0x3f800001, 0x00000000, 0x00000000, 0x00000000,
0x3f800002, 0x00000000, 0x00000000, 0x00000000,
0x3fc00002, 0x00000000, 0x00000000, 0x00000000,
0x41200001, 0x00000000, 0x00000000, 0x00000000,
0x3f800002, 0x00000000, 0x00000000, 0x00000000,
0x3fc00002, 0x00000000, 0x00000000, 0x00000000,
0x41200001, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x3fc00002, 0x00000000, 0x00000000, 0x00000000,
0x41200001, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x41200001, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00123456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00123456, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00123456, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x00123456, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80800001, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80800001, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80800001, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbf000001, 0x00000000, 0x00000000, 0x00000000,
0x80800001, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbf000001, 0x00000000, 0x00000000, 0x00000000,
0xbf000002, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbf000001, 0x00000000, 0x00000000, 0x00000000,
0xbf000002, 0x00000000, 0x00000000, 0x00000000,
0xbf800000, 0x00000000, 0x00000000, 0x00000000,
0xbf000001, 0x00000000, 0x00000000, 0x00000000,
0xbf000002, 0x00000000, 0x00000000, 0x00000000,
0xbf800000, 0x00000000, 0x00000000, 0x00000000,
0xbf800001, 0x00000000, 0x00000000, 0x00000000,
0xbf000002, 0x00000000, 0x00000000, 0x00000000,
0xbf800000, 0x00000000, 0x00000000, 0x00000000,
0xbf800001, 0x00000000, 0x00000000, 0x00000000,
0xbf800002, 0x00000000, 0x00000000, 0x00000000,
0xbf800000, 0x00000000, 0x00000000, 0x00000000,
0xbf800001, 0x00000000, 0x00000000, 0x00000000,
0xbf800002, 0x00000000, 0x00000000, 0x00000000,
0xbfc00002, 0x00000000, 0x00000000, 0x00000000,
0xbf800001, 0x00000000, 0x00000000, 0x00000000,
0xbf800002, 0x00000000, 0x00000000, 0x00000000,
0xbfc00002, 0x00000000, 0x00000000, 0x00000000,
0xc1200001, 0x00000000, 0x00000000, 0x00000000,
0xbf800002, 0x00000000, 0x00000000, 0x00000000,
0xbfc00002, 0x00000000, 0x00000000, 0x00000000,
0xc1200001, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xbfc00002, 0x00000000, 0x00000000, 0x00000000,
0xc1200001, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xc1200001, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80123456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80123456, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80123456, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x801b4e81, 0x00000000, 0x00000000, 0x00000000,
0x80bffffe, 0x00000000, 0x00000000, 0x00000000,
0x80000002, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80bffffe, 0x00000000, 0x00000000, 0x00000000,
0x80000002, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00c00000, 0x00000000, 0x00000000, 0x00000000,
0x80000002, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00c00000, 0x00000000, 0x00000000, 0x00000000,
0x3f3fffff, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00c00000, 0x00000000, 0x00000000, 0x00000000,
0x3f3fffff, 0x00000000, 0x00000000, 0x00000000,
0x3f400000, 0x00000000, 0x00000000, 0x00000000,
0x00c00000, 0x00000000, 0x00000000, 0x00000000,
0x3f3fffff, 0x00000000, 0x00000000, 0x00000000,
0x3f400000, 0x00000000, 0x00000000, 0x00000000,
0x3f400002, 0x00000000, 0x00000000, 0x00000000,
0x3f3fffff, 0x00000000, 0x00000000, 0x00000000,
0x3f400000, 0x00000000, 0x00000000, 0x00000000,
0x3f400002, 0x00000000, 0x00000000, 0x00000000,
0x3fbfffff, 0x00000000, 0x00000000, 0x00000000,
0x3f400000, 0x00000000, 0x00000000, 0x00000000,
0x3f400002, 0x00000000, 0x00000000, 0x00000000,
0x3fbfffff, 0x00000000, 0x00000000, 0x00000000,
0x3fc00000, 0x00000000, 0x00000000, 0x00000000,
0x3f400002, 0x00000000, 0x00000000, 0x00000000,
0x3fbfffff, 0x00000000, 0x00000000, 0x00000000,
0x3fc00000, 0x00000000, 0x00000000, 0x00000000,
0x3fc00002, 0x00000000, 0x00000000, 0x00000000,
0x3fbfffff, 0x00000000, 0x00000000, 0x00000000,
0x3fc00000, 0x00000000, 0x00000000, 0x00000000,
0x3fc00002, 0x00000000, 0x00000000, 0x00000000,
0x40100000, 0x00000000, 0x00000000, 0x00000000,
0x3fc00000, 0x00000000, 0x00000000, 0x00000000,
0x3fc00002, 0x00000000, 0x00000000, 0x00000000,
0x40100000, 0x00000000, 0x00000000, 0x00000000,
0x41700000, 0x00000000, 0x00000000, 0x00000000,
0x3fc00002, 0x00000000, 0x00000000, 0x00000000,
0x40100000, 0x00000000, 0x00000000, 0x00000000,
0x41700000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x40100000, 0x00000000, 0x00000000, 0x00000000,
0x41700000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x41700000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x001b4e81, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x001b4e81, 0x00000000, 0x00000000, 0x00000000,
0x00bffffe, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x001b4e81, 0x00000000, 0x00000000, 0x00000000,
0x00bffffe, 0x00000000, 0x00000000, 0x00000000,
0x00000002, 0x00000000, 0x00000000, 0x00000000,
0x001b4e81, 0x00000000, 0x00000000, 0x00000000,
0x00bffffe, 0x00000000, 0x00000000, 0x00000000,
0x00000002, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00bffffe, 0x00000000, 0x00000000, 0x00000000,
0x00000002, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80c00000, 0x00000000, 0x00000000, 0x00000000,
0x00000002, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80c00000, 0x00000000, 0x00000000, 0x00000000,
0xbf3fffff, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80c00000, 0x00000000, 0x00000000, 0x00000000,
0xbf3fffff, 0x00000000, 0x00000000, 0x00000000,
0xbf400000, 0x00000000, 0x00000000, 0x00000000,
0x80c00000, 0x00000000, 0x00000000, 0x00000000,
0xbf3fffff, 0x00000000, 0x00000000, 0x00000000,
0xbf400000, 0x00000000, 0x00000000, 0x00000000,
0xbf400002, 0x00000000, 0x00000000, 0x00000000,
0xbf3fffff, 0x00000000, 0x00000000, 0x00000000,
0xbf400000, 0x00000000, 0x00000000, 0x00000000,
0xbf400002, 0x00000000, 0x00000000, 0x00000000,
0xbfbfffff, 0x00000000, 0x00000000, 0x00000000,
0xbf400000, 0x00000000, 0x00000000, 0x00000000,
0xbf400002, 0x00000000, 0x00000000, 0x00000000,
0xbfbfffff, 0x00000000, 0x00000000, 0x00000000,
0xbfc00000, 0x00000000, 0x00000000, 0x00000000,
0xbf400002, 0x00000000, 0x00000000, 0x00000000,
0xbfbfffff, 0x00000000, 0x00000000, 0x00000000,
0xbfc00000, 0x00000000, 0x00000000, 0x00000000,
0xbfc00002, 0x00000000, 0x00000000, 0x00000000,
0xbfbfffff, 0x00000000, 0x00000000, 0x00000000,
0xbfc00000, 0x00000000, 0x00000000, 0x00000000,
0xbfc00002, 0x00000000, 0x00000000, 0x00000000,
0xc0100000, 0x00000000, 0x00000000, 0x00000000,
0xbfc00000, 0x00000000, 0x00000000, 0x00000000,
0xbfc00002, 0x00000000, 0x00000000, 0x00000000,
0xc0100000, 0x00000000, 0x00000000, 0x00000000,
0xc1700000, 0x00000000, 0x00000000, 0x00000000,
0xbfc00002, 0x00000000, 0x00000000, 0x00000000,
0xc0100000, 0x00000000, 0x00000000, 0x00000000,
0xc1700000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xc0100000, 0x00000000, 0x00000000, 0x00000000,
0xc1700000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xc1700000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x801b4e81, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x801b4e81, 0x00000000, 0x00000000, 0x00000000,
0x80bffffe, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x801b4e81, 0x00000000, 0x00000000, 0x00000000,
0x80bffffe, 0x00000000, 0x00000000, 0x00000000,
0x80000002, 0x00000000, 0x00000000, 0x00000000,
0x80b60b5c, 0x00000000, 0x00000000, 0x00000000,
0x821fffff, 0x00000000, 0x00000000, 0x00000000,
0x8000000a, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x821fffff, 0x00000000, 0x00000000, 0x00000000,
0x8000000a, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x02200000, 0x00000000, 0x00000000, 0x00000000,
0x8000000a, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x02200000, 0x00000000, 0x00000000, 0x00000000,
0x409fffff, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x02200000, 0x00000000, 0x00000000, 0x00000000,
0x409fffff, 0x00000000, 0x00000000, 0x00000000,
0x40a00000, 0x00000000, 0x00000000, 0x00000000,
0x02200000, 0x00000000, 0x00000000, 0x00000000,
0x409fffff, 0x00000000, 0x00000000, 0x00000000,
0x40a00000, 0x00000000, 0x00000000, 0x00000000,
0x40a00001, 0x00000000, 0x00000000, 0x00000000,
0x409fffff, 0x00000000, 0x00000000, 0x00000000,
0x40a00000, 0x00000000, 0x00000000, 0x00000000,
0x40a00001, 0x00000000, 0x00000000, 0x00000000,
0x411fffff, 0x00000000, 0x00000000, 0x00000000,
0x40a00000, 0x00000000, 0x00000000, 0x00000000,
0x40a00001, 0x00000000, 0x00000000, 0x00000000,
0x411fffff, 0x00000000, 0x00000000, 0x00000000,
0x41200000, 0x00000000, 0x00000000, 0x00000000,
0x40a00001, 0x00000000, 0x00000000, 0x00000000,
0x411fffff, 0x00000000, 0x00000000, 0x00000000,
0x41200000, 0x00000000, 0x00000000, 0x00000000,
0x41200001, 0x00000000, 0x00000000, 0x00000000,
0x411fffff, 0x00000000, 0x00000000, 0x00000000,
0x41200000, 0x00000000, 0x00000000, 0x00000000,
0x41200001, 0x00000000, 0x00000000, 0x00000000,
0x41700000, 0x00000000, 0x00000000, 0x00000000,
0x41200000, 0x00000000, 0x00000000, 0x00000000,
0x41200001, 0x00000000, 0x00000000, 0x00000000,
0x41700000, 0x00000000, 0x00000000, 0x00000000,
0x42c80000, 0x00000000, 0x00000000, 0x00000000,
0x41200001, 0x00000000, 0x00000000, 0x00000000,
0x41700000, 0x00000000, 0x00000000, 0x00000000,
0x42c80000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x41700000, 0x00000000, 0x00000000, 0x00000000,
0x42c80000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x42c80000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00b60b5c, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00b60b5c, 0x00000000, 0x00000000, 0x00000000,
0x021fffff, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00b60b5c, 0x00000000, 0x00000000, 0x00000000,
0x021fffff, 0x00000000, 0x00000000, 0x00000000,
0x0000000a, 0x00000000, 0x00000000, 0x00000000,
0x00b60b5c, 0x00000000, 0x00000000, 0x00000000,
0x021fffff, 0x00000000, 0x00000000, 0x00000000,
0x0000000a, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x021fffff, 0x00000000, 0x00000000, 0x00000000,
0x0000000a, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x82200000, 0x00000000, 0x00000000, 0x00000000,
0x0000000a, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x82200000, 0x00000000, 0x00000000, 0x00000000,
0xc09fffff, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x82200000, 0x00000000, 0x00000000, 0x00000000,
0xc09fffff, 0x00000000, 0x00000000, 0x00000000,
0xc0a00000, 0x00000000, 0x00000000, 0x00000000,
0x82200000, 0x00000000, 0x00000000, 0x00000000,
0xc09fffff, 0x00000000, 0x00000000, 0x00000000,
0xc0a00000, 0x00000000, 0x00000000, 0x00000000,
0xc0a00001, 0x00000000, 0x00000000, 0x00000000,
0xc09fffff, 0x00000000, 0x00000000, 0x00000000,
0xc0a00000, 0x00000000, 0x00000000, 0x00000000,
0xc0a00001, 0x00000000, 0x00000000, 0x00000000,
0xc11fffff, 0x00000000, 0x00000000, 0x00000000,
0xc0a00000, 0x00000000, 0x00000000, 0x00000000,
0xc0a00001, 0x00000000, 0x00000000, 0x00000000,
0xc11fffff, 0x00000000, 0x00000000, 0x00000000,
0xc1200000, 0x00000000, 0x00000000, 0x00000000,
0xc0a00001, 0x00000000, 0x00000000, 0x00000000,
0xc11fffff, 0x00000000, 0x00000000, 0x00000000,
0xc1200000, 0x00000000, 0x00000000, 0x00000000,
0xc1200001, 0x00000000, 0x00000000, 0x00000000,
0xc11fffff, 0x00000000, 0x00000000, 0x00000000,
0xc1200000, 0x00000000, 0x00000000, 0x00000000,
0xc1200001, 0x00000000, 0x00000000, 0x00000000,
0xc1700000, 0x00000000, 0x00000000, 0x00000000,
0xc1200000, 0x00000000, 0x00000000, 0x00000000,
0xc1200001, 0x00000000, 0x00000000, 0x00000000,
0xc1700000, 0x00000000, 0x00000000, 0x00000000,
0xc2c80000, 0x00000000, 0x00000000, 0x00000000,
0xc1200001, 0x00000000, 0x00000000, 0x00000000,
0xc1700000, 0x00000000, 0x00000000, 0x00000000,
0xc2c80000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xc1700000, 0x00000000, 0x00000000, 0x00000000,
0xc2c80000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xc2c80000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80b60b5c, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80b60b5c, 0x00000000, 0x00000000, 0x00000000,
0x821fffff, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80b60b5c, 0x00000000, 0x00000000, 0x00000000,
0x821fffff, 0x00000000, 0x00000000, 0x00000000,
0x8000000a, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x40000000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x40000000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x40000000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x40000000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xc0000000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xc0000000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xc0000000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xc0000000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00091a2b, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00091a2b, 0x00000000, 0x00000000, 0x00000000,
0x00091a2b, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00091a2b, 0x00000000, 0x00000000, 0x00000000,
0x00091a2b, 0x00000000, 0x00000000, 0x00000000,
0x00091a2b, 0x00000000, 0x00000000, 0x00000000,
0x00091a2b, 0x00000000, 0x00000000, 0x00000000,
0x00091a2b, 0x00000000, 0x00000000, 0x00000000,
0x00091a2b, 0x00000000, 0x00000000, 0x00000000,
0x00123456, 0x00000000, 0x00000000, 0x00000000,
0x00091a2b, 0x00000000, 0x00000000, 0x00000000,
0x00091a2b, 0x00000000, 0x00000000, 0x00000000,
0x00123456, 0x00000000, 0x00000000, 0x00000000,
0x00123456, 0x00000000, 0x00000000, 0x00000000,
0x00091a2b, 0x00000000, 0x00000000, 0x00000000,
0x00123456, 0x00000000, 0x00000000, 0x00000000,
0x00123456, 0x00000000, 0x00000000, 0x00000000,
0x00123456, 0x00000000, 0x00000000, 0x00000000,
0x00123456, 0x00000000, 0x00000000, 0x00000000,
0x00123456, 0x00000000, 0x00000000, 0x00000000,
0x00123456, 0x00000000, 0x00000000, 0x00000000,
0x001b4e81, 0x00000000, 0x00000000, 0x00000000,
0x00123456, 0x00000000, 0x00000000, 0x00000000,
0x00123456, 0x00000000, 0x00000000, 0x00000000,
0x001b4e81, 0x00000000, 0x00000000, 0x00000000,
0x00b60b5c, 0x00000000, 0x00000000, 0x00000000,
0x00123456, 0x00000000, 0x00000000, 0x00000000,
0x001b4e81, 0x00000000, 0x00000000, 0x00000000,
0x00b60b5c, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x001b4e81, 0x00000000, 0x00000000, 0x00000000,
0x00b60b5c, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x00b60b5c, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80091a2b, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80091a2b, 0x00000000, 0x00000000, 0x00000000,
0x80091a2b, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80091a2b, 0x00000000, 0x00000000, 0x00000000,
0x80091a2b, 0x00000000, 0x00000000, 0x00000000,
0x80091a2b, 0x00000000, 0x00000000, 0x00000000,
0x80091a2b, 0x00000000, 0x00000000, 0x00000000,
0x80091a2b, 0x00000000, 0x00000000, 0x00000000,
0x80091a2b, 0x00000000, 0x00000000, 0x00000000,
0x80123456, 0x00000000, 0x00000000, 0x00000000,
0x80091a2b, 0x00000000, 0x00000000, 0x00000000,
0x80091a2b, 0x00000000, 0x00000000, 0x00000000,
0x80123456, 0x00000000, 0x00000000, 0x00000000,
0x80123456, 0x00000000, 0x00000000, 0x00000000,
0x80091a2b, 0x00000000, 0x00000000, 0x00000000,
0x80123456, 0x00000000, 0x00000000, 0x00000000,
0x80123456, 0x00000000, 0x00000000, 0x00000000,
0x80123456, 0x00000000, 0x00000000, 0x00000000,
0x80123456, 0x00000000, 0x00000000, 0x00000000,
0x80123456, 0x00000000, 0x00000000, 0x00000000,
0x80123456, 0x00000000, 0x00000000, 0x00000000,
0x801b4e81, 0x00000000, 0x00000000, 0x00000000,
0x80123456, 0x00000000, 0x00000000, 0x00000000,
0x80123456, 0x00000000, 0x00000000, 0x00000000,
0x801b4e81, 0x00000000, 0x00000000, 0x00000000,
0x80b60b5c, 0x00000000, 0x00000000, 0x00000000,
0x80123456, 0x00000000, 0x00000000, 0x00000000,
0x801b4e81, 0x00000000, 0x00000000, 0x00000000,
0x80b60b5c, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x801b4e81, 0x00000000, 0x00000000, 0x00000000,
0x80b60b5c, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x80b60b5c, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x003fffff, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x003fffff, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x003fffff, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x003fffff, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x007fffff, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x007fffff, 0x00000000, 0x00000000, 0x00000000,
0x007fffff, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x007fffff, 0x00000000, 0x00000000, 0x00000000,
0x007fffff, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x007fffff, 0x00000000, 0x00000000, 0x00000000,
0x007fffff, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x00bffffe, 0x00000000, 0x00000000, 0x00000000,
0x007fffff, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x00bffffe, 0x00000000, 0x00000000, 0x00000000,
0x021fffff, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x00bffffe, 0x00000000, 0x00000000, 0x00000000,
0x021fffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x00bffffe, 0x00000000, 0x00000000, 0x00000000,
0x021fffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x021fffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x803fffff, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x803fffff, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x803fffff, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x803fffff, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x807fffff, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x807fffff, 0x00000000, 0x00000000, 0x00000000,
0x807fffff, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x807fffff, 0x00000000, 0x00000000, 0x00000000,
0x807fffff, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0x807fffff, 0x00000000, 0x00000000, 0x00000000,
0x807fffff, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0x80bffffe, 0x00000000, 0x00000000, 0x00000000,
0x807fffff, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0x80bffffe, 0x00000000, 0x00000000, 0x00000000,
0x821fffff, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0x80bffffe, 0x00000000, 0x00000000, 0x00000000,
0x821fffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x80bffffe, 0x00000000, 0x00000000, 0x00000000,
0x821fffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x821fffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x00000002, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x00000002, 0x00000000, 0x00000000, 0x00000000,
0x0000000a, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x00000002, 0x00000000, 0x00000000, 0x00000000,
0x0000000a, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x00000002, 0x00000000, 0x00000000, 0x00000000,
0x0000000a, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x0000000a, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x80000002, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x80000002, 0x00000000, 0x00000000, 0x00000000,
0x8000000a, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x80000002, 0x00000000, 0x00000000, 0x00000000,
0x8000000a, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x80000002, 0x00000000, 0x00000000, 0x00000000,
0x8000000a, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x8000000a, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xc0000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xc0000000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xc0000000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0xc0000000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x40000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x40000000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x40000000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0x40000000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0x80800001, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0x80800001, 0x00000000, 0x00000000, 0x00000000,
0x80c00000, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0x80800001, 0x00000000, 0x00000000, 0x00000000,
0x80c00000, 0x00000000, 0x00000000, 0x00000000,
0x82200000, 0x00000000, 0x00000000, 0x00000000,
0x80800001, 0x00000000, 0x00000000, 0x00000000,
0x80c00000, 0x00000000, 0x00000000, 0x00000000,
0x82200000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0x80c00000, 0x00000000, 0x00000000, 0x00000000,
0x82200000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x82200000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x00800001, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x00800001, 0x00000000, 0x00000000, 0x00000000,
0x00c00000, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x00800001, 0x00000000, 0x00000000, 0x00000000,
0x00c00000, 0x00000000, 0x00000000, 0x00000000,
0x02200000, 0x00000000, 0x00000000, 0x00000000,
0x00800001, 0x00000000, 0x00000000, 0x00000000,
0x00c00000, 0x00000000, 0x00000000, 0x00000000,
0x02200000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x00c00000, 0x00000000, 0x00000000, 0x00000000,
0x02200000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x02200000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00091a2b, 0x00000000, 0x00000000, 0x00000000,
0x003fffff, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x003fffff, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0xbe7ffffe, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0xbe7ffffe, 0x00000000, 0x00000000, 0x00000000,
0xbe7fffff, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0xbe7ffffe, 0x00000000, 0x00000000, 0x00000000,
0xbe7fffff, 0x00000000, 0x00000000, 0x00000000,
0xbe800000, 0x00000000, 0x00000000, 0x00000000,
0xbe7ffffe, 0x00000000, 0x00000000, 0x00000000,
0xbe7fffff, 0x00000000, 0x00000000, 0x00000000,
0xbe800000, 0x00000000, 0x00000000, 0x00000000,
0xbefffffe, 0x00000000, 0x00000000, 0x00000000,
0xbe7fffff, 0x00000000, 0x00000000, 0x00000000,
0xbe800000, 0x00000000, 0x00000000, 0x00000000,
0xbefffffe, 0x00000000, 0x00000000, 0x00000000,
0xbeffffff, 0x00000000, 0x00000000, 0x00000000,
0xbe800000, 0x00000000, 0x00000000, 0x00000000,
0xbefffffe, 0x00000000, 0x00000000, 0x00000000,
0xbeffffff, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbefffffe, 0x00000000, 0x00000000, 0x00000000,
0xbeffffff, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbf3fffff, 0x00000000, 0x00000000, 0x00000000,
0xbeffffff, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbf3fffff, 0x00000000, 0x00000000, 0x00000000,
0xc09fffff, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbf3fffff, 0x00000000, 0x00000000, 0x00000000,
0xc09fffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xbf3fffff, 0x00000000, 0x00000000, 0x00000000,
0xc09fffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xc09fffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x80091a2b, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x80091a2b, 0x00000000, 0x00000000, 0x00000000,
0x803fffff, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x80091a2b, 0x00000000, 0x00000000, 0x00000000,
0x803fffff, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80091a2b, 0x00000000, 0x00000000, 0x00000000,
0x803fffff, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x803fffff, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x3e7ffffe, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x3e7ffffe, 0x00000000, 0x00000000, 0x00000000,
0x3e7fffff, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x3e7ffffe, 0x00000000, 0x00000000, 0x00000000,
0x3e7fffff, 0x00000000, 0x00000000, 0x00000000,
0x3e800000, 0x00000000, 0x00000000, 0x00000000,
0x3e7ffffe, 0x00000000, 0x00000000, 0x00000000,
0x3e7fffff, 0x00000000, 0x00000000, 0x00000000,
0x3e800000, 0x00000000, 0x00000000, 0x00000000,
0x3efffffe, 0x00000000, 0x00000000, 0x00000000,
0x3e7fffff, 0x00000000, 0x00000000, 0x00000000,
0x3e800000, 0x00000000, 0x00000000, 0x00000000,
0x3efffffe, 0x00000000, 0x00000000, 0x00000000,
0x3effffff, 0x00000000, 0x00000000, 0x00000000,
0x3e800000, 0x00000000, 0x00000000, 0x00000000,
0x3efffffe, 0x00000000, 0x00000000, 0x00000000,
0x3effffff, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3efffffe, 0x00000000, 0x00000000, 0x00000000,
0x3effffff, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3f3fffff, 0x00000000, 0x00000000, 0x00000000,
0x3effffff, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3f3fffff, 0x00000000, 0x00000000, 0x00000000,
0x409fffff, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3f3fffff, 0x00000000, 0x00000000, 0x00000000,
0x409fffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x3f3fffff, 0x00000000, 0x00000000, 0x00000000,
0x409fffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x409fffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x00091a2b, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x00091a2b, 0x00000000, 0x00000000, 0x00000000,
0x003fffff, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x00091a2b, 0x00000000, 0x00000000, 0x00000000,
0x003fffff, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00091a2b, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0xbe7fffff, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0xbe7fffff, 0x00000000, 0x00000000, 0x00000000,
0xbe800000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0xbe7fffff, 0x00000000, 0x00000000, 0x00000000,
0xbe800000, 0x00000000, 0x00000000, 0x00000000,
0xbe800001, 0x00000000, 0x00000000, 0x00000000,
0xbe7fffff, 0x00000000, 0x00000000, 0x00000000,
0xbe800000, 0x00000000, 0x00000000, 0x00000000,
0xbe800001, 0x00000000, 0x00000000, 0x00000000,
0xbeffffff, 0x00000000, 0x00000000, 0x00000000,
0xbe800000, 0x00000000, 0x00000000, 0x00000000,
0xbe800001, 0x00000000, 0x00000000, 0x00000000,
0xbeffffff, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbe800001, 0x00000000, 0x00000000, 0x00000000,
0xbeffffff, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbf000001, 0x00000000, 0x00000000, 0x00000000,
0xbeffffff, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbf000001, 0x00000000, 0x00000000, 0x00000000,
0xbf400000, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbf000001, 0x00000000, 0x00000000, 0x00000000,
0xbf400000, 0x00000000, 0x00000000, 0x00000000,
0xc0a00000, 0x00000000, 0x00000000, 0x00000000,
0xbf000001, 0x00000000, 0x00000000, 0x00000000,
0xbf400000, 0x00000000, 0x00000000, 0x00000000,
0xc0a00000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xbf400000, 0x00000000, 0x00000000, 0x00000000,
0xc0a00000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xc0a00000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x80091a2b, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x80091a2b, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x80091a2b, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80091a2b, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x3e7fffff, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x3e7fffff, 0x00000000, 0x00000000, 0x00000000,
0x3e800000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x3e7fffff, 0x00000000, 0x00000000, 0x00000000,
0x3e800000, 0x00000000, 0x00000000, 0x00000000,
0x3e800001, 0x00000000, 0x00000000, 0x00000000,
0x3e7fffff, 0x00000000, 0x00000000, 0x00000000,
0x3e800000, 0x00000000, 0x00000000, 0x00000000,
0x3e800001, 0x00000000, 0x00000000, 0x00000000,
0x3effffff, 0x00000000, 0x00000000, 0x00000000,
0x3e800000, 0x00000000, 0x00000000, 0x00000000,
0x3e800001, 0x00000000, 0x00000000, 0x00000000,
0x3effffff, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3e800001, 0x00000000, 0x00000000, 0x00000000,
0x3effffff, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3f000001, 0x00000000, 0x00000000, 0x00000000,
0x3effffff, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3f000001, 0x00000000, 0x00000000, 0x00000000,
0x3f400000, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3f000001, 0x00000000, 0x00000000, 0x00000000,
0x3f400000, 0x00000000, 0x00000000, 0x00000000,
0x40a00000, 0x00000000, 0x00000000, 0x00000000,
0x3f000001, 0x00000000, 0x00000000, 0x00000000,
0x3f400000, 0x00000000, 0x00000000, 0x00000000,
0x40a00000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x3f400000, 0x00000000, 0x00000000, 0x00000000,
0x40a00000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x40a00000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x00091a2b, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x00091a2b, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x00091a2b, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00091a2b, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0xbe800000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0xbe800000, 0x00000000, 0x00000000, 0x00000000,
0xbe800001, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0xbe800000, 0x00000000, 0x00000000, 0x00000000,
0xbe800001, 0x00000000, 0x00000000, 0x00000000,
0xbe800002, 0x00000000, 0x00000000, 0x00000000,
0xbe800000, 0x00000000, 0x00000000, 0x00000000,
0xbe800001, 0x00000000, 0x00000000, 0x00000000,
0xbe800002, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbe800001, 0x00000000, 0x00000000, 0x00000000,
0xbe800002, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbf000001, 0x00000000, 0x00000000, 0x00000000,
0xbe800002, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbf000001, 0x00000000, 0x00000000, 0x00000000,
0xbf000002, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbf000001, 0x00000000, 0x00000000, 0x00000000,
0xbf000002, 0x00000000, 0x00000000, 0x00000000,
0xbf400002, 0x00000000, 0x00000000, 0x00000000,
0xbf000001, 0x00000000, 0x00000000, 0x00000000,
0xbf000002, 0x00000000, 0x00000000, 0x00000000,
0xbf400002, 0x00000000, 0x00000000, 0x00000000,
0xc0a00001, 0x00000000, 0x00000000, 0x00000000,
0xbf000002, 0x00000000, 0x00000000, 0x00000000,
0xbf400002, 0x00000000, 0x00000000, 0x00000000,
0xc0a00001, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xbf400002, 0x00000000, 0x00000000, 0x00000000,
0xc0a00001, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xc0a00001, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x80091a2b, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x80091a2b, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x80091a2b, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x80091a2b, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80400000, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x3e800000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x3e800000, 0x00000000, 0x00000000, 0x00000000,
0x3e800001, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x3e800000, 0x00000000, 0x00000000, 0x00000000,
0x3e800001, 0x00000000, 0x00000000, 0x00000000,
0x3e800002, 0x00000000, 0x00000000, 0x00000000,
0x3e800000, 0x00000000, 0x00000000, 0x00000000,
0x3e800001, 0x00000000, 0x00000000, 0x00000000,
0x3e800002, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3e800001, 0x00000000, 0x00000000, 0x00000000,
0x3e800002, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3f000001, 0x00000000, 0x00000000, 0x00000000,
0x3e800002, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3f000001, 0x00000000, 0x00000000, 0x00000000,
0x3f000002, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3f000001, 0x00000000, 0x00000000, 0x00000000,
0x3f000002, 0x00000000, 0x00000000, 0x00000000,
0x3f400002, 0x00000000, 0x00000000, 0x00000000,
0x3f000001, 0x00000000, 0x00000000, 0x00000000,
0x3f000002, 0x00000000, 0x00000000, 0x00000000,
0x3f400002, 0x00000000, 0x00000000, 0x00000000,
0x40a00001, 0x00000000, 0x00000000, 0x00000000,
0x3f000002, 0x00000000, 0x00000000, 0x00000000,
0x3f400002, 0x00000000, 0x00000000, 0x00000000,
0x40a00001, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x3f400002, 0x00000000, 0x00000000, 0x00000000,
0x40a00001, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x40a00001, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x00091a2b, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x00091a2b, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x00091a2b, 0x00000000, 0x00000000, 0x00000000,
0x00400000, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x00123456, 0x00000000, 0x00000000, 0x00000000,
0x007fffff, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x007fffff, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0xbefffffe, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0xbefffffe, 0x00000000, 0x00000000, 0x00000000,
0xbeffffff, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0xbefffffe, 0x00000000, 0x00000000, 0x00000000,
0xbeffffff, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbefffffe, 0x00000000, 0x00000000, 0x00000000,
0xbeffffff, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbf7ffffe, 0x00000000, 0x00000000, 0x00000000,
0xbeffffff, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbf7ffffe, 0x00000000, 0x00000000, 0x00000000,
0xbf7fffff, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbf7ffffe, 0x00000000, 0x00000000, 0x00000000,
0xbf7fffff, 0x00000000, 0x00000000, 0x00000000,
0xbf800000, 0x00000000, 0x00000000, 0x00000000,
0xbf7ffffe, 0x00000000, 0x00000000, 0x00000000,
0xbf7fffff, 0x00000000, 0x00000000, 0x00000000,
0xbf800000, 0x00000000, 0x00000000, 0x00000000,
0xbfbfffff, 0x00000000, 0x00000000, 0x00000000,
0xbf7fffff, 0x00000000, 0x00000000, 0x00000000,
0xbf800000, 0x00000000, 0x00000000, 0x00000000,
0xbfbfffff, 0x00000000, 0x00000000, 0x00000000,
0xc11fffff, 0x00000000, 0x00000000, 0x00000000,
0xbf800000, 0x00000000, 0x00000000, 0x00000000,
0xbfbfffff, 0x00000000, 0x00000000, 0x00000000,
0xc11fffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xbfbfffff, 0x00000000, 0x00000000, 0x00000000,
0xc11fffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xc11fffff, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x80123456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x80123456, 0x00000000, 0x00000000, 0x00000000,
0x807fffff, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x80123456, 0x00000000, 0x00000000, 0x00000000,
0x807fffff, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x80123456, 0x00000000, 0x00000000, 0x00000000,
0x807fffff, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x807fffff, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x3efffffe, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x3efffffe, 0x00000000, 0x00000000, 0x00000000,
0x3effffff, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x3efffffe, 0x00000000, 0x00000000, 0x00000000,
0x3effffff, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3efffffe, 0x00000000, 0x00000000, 0x00000000,
0x3effffff, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3f7ffffe, 0x00000000, 0x00000000, 0x00000000,
0x3effffff, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3f7ffffe, 0x00000000, 0x00000000, 0x00000000,
0x3f7fffff, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3f7ffffe, 0x00000000, 0x00000000, 0x00000000,
0x3f7fffff, 0x00000000, 0x00000000, 0x00000000,
0x3f800000, 0x00000000, 0x00000000, 0x00000000,
0x3f7ffffe, 0x00000000, 0x00000000, 0x00000000,
0x3f7fffff, 0x00000000, 0x00000000, 0x00000000,
0x3f800000, 0x00000000, 0x00000000, 0x00000000,
0x3fbfffff, 0x00000000, 0x00000000, 0x00000000,
0x3f7fffff, 0x00000000, 0x00000000, 0x00000000,
0x3f800000, 0x00000000, 0x00000000, 0x00000000,
0x3fbfffff, 0x00000000, 0x00000000, 0x00000000,
0x411fffff, 0x00000000, 0x00000000, 0x00000000,
0x3f800000, 0x00000000, 0x00000000, 0x00000000,
0x3fbfffff, 0x00000000, 0x00000000, 0x00000000,
0x411fffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x3fbfffff, 0x00000000, 0x00000000, 0x00000000,
0x411fffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x411fffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x00123456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x00123456, 0x00000000, 0x00000000, 0x00000000,
0x007fffff, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x00123456, 0x00000000, 0x00000000, 0x00000000,
0x007fffff, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x00123456, 0x00000000, 0x00000000, 0x00000000,
0x007fffff, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x007fffff, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0xbeffffff, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0xbeffffff, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0xbeffffff, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbf000001, 0x00000000, 0x00000000, 0x00000000,
0xbeffffff, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbf000001, 0x00000000, 0x00000000, 0x00000000,
0xbf7fffff, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbf000001, 0x00000000, 0x00000000, 0x00000000,
0xbf7fffff, 0x00000000, 0x00000000, 0x00000000,
0xbf800000, 0x00000000, 0x00000000, 0x00000000,
0xbf000001, 0x00000000, 0x00000000, 0x00000000,
0xbf7fffff, 0x00000000, 0x00000000, 0x00000000,
0xbf800000, 0x00000000, 0x00000000, 0x00000000,
0xbf800001, 0x00000000, 0x00000000, 0x00000000,
0xbf7fffff, 0x00000000, 0x00000000, 0x00000000,
0xbf800000, 0x00000000, 0x00000000, 0x00000000,
0xbf800001, 0x00000000, 0x00000000, 0x00000000,
0xbfc00000, 0x00000000, 0x00000000, 0x00000000,
0xbf800000, 0x00000000, 0x00000000, 0x00000000,
0xbf800001, 0x00000000, 0x00000000, 0x00000000,
0xbfc00000, 0x00000000, 0x00000000, 0x00000000,
0xc1200000, 0x00000000, 0x00000000, 0x00000000,
0xbf800001, 0x00000000, 0x00000000, 0x00000000,
0xbfc00000, 0x00000000, 0x00000000, 0x00000000,
0xc1200000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xbfc00000, 0x00000000, 0x00000000, 0x00000000,
0xc1200000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xc1200000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x80123456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x80123456, 0x00000000, 0x00000000, 0x00000000,
0x807fffff, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x80123456, 0x00000000, 0x00000000, 0x00000000,
0x807fffff, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x80123456, 0x00000000, 0x00000000, 0x00000000,
0x807fffff, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x807fffff, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x3effffff, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x3effffff, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x3effffff, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3f000001, 0x00000000, 0x00000000, 0x00000000,
0x3effffff, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3f000001, 0x00000000, 0x00000000, 0x00000000,
0x3f7fffff, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3f000001, 0x00000000, 0x00000000, 0x00000000,
0x3f7fffff, 0x00000000, 0x00000000, 0x00000000,
0x3f800000, 0x00000000, 0x00000000, 0x00000000,
0x3f000001, 0x00000000, 0x00000000, 0x00000000,
0x3f7fffff, 0x00000000, 0x00000000, 0x00000000,
0x3f800000, 0x00000000, 0x00000000, 0x00000000,
0x3f800001, 0x00000000, 0x00000000, 0x00000000,
0x3f7fffff, 0x00000000, 0x00000000, 0x00000000,
0x3f800000, 0x00000000, 0x00000000, 0x00000000,
0x3f800001, 0x00000000, 0x00000000, 0x00000000,
0x3fc00000, 0x00000000, 0x00000000, 0x00000000,
0x3f800000, 0x00000000, 0x00000000, 0x00000000,
0x3f800001, 0x00000000, 0x00000000, 0x00000000,
0x3fc00000, 0x00000000, 0x00000000, 0x00000000,
0x41200000, 0x00000000, 0x00000000, 0x00000000,
0x3f800001, 0x00000000, 0x00000000, 0x00000000,
0x3fc00000, 0x00000000, 0x00000000, 0x00000000,
0x41200000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x3fc00000, 0x00000000, 0x00000000, 0x00000000,
0x41200000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x41200000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x00123456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x00123456, 0x00000000, 0x00000000, 0x00000000,
0x007fffff, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x00123456, 0x00000000, 0x00000000, 0x00000000,
0x007fffff, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x00123456, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80800001, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80800001, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80800001, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbf000001, 0x00000000, 0x00000000, 0x00000000,
0x80800001, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbf000001, 0x00000000, 0x00000000, 0x00000000,
0xbf000002, 0x00000000, 0x00000000, 0x00000000,
0xbf000000, 0x00000000, 0x00000000, 0x00000000,
0xbf000001, 0x00000000, 0x00000000, 0x00000000,
0xbf000002, 0x00000000, 0x00000000, 0x00000000,
0xbf800000, 0x00000000, 0x00000000, 0x00000000,
0xbf000001, 0x00000000, 0x00000000, 0x00000000,
0xbf000002, 0x00000000, 0x00000000, 0x00000000,
0xbf800000, 0x00000000, 0x00000000, 0x00000000,
0xbf800001, 0x00000000, 0x00000000, 0x00000000,
0xbf000002, 0x00000000, 0x00000000, 0x00000000,
0xbf800000, 0x00000000, 0x00000000, 0x00000000,
0xbf800001, 0x00000000, 0x00000000, 0x00000000,
0xbf800002, 0x00000000, 0x00000000, 0x00000000,
0xbf800000, 0x00000000, 0x00000000, 0x00000000,
0xbf800001, 0x00000000, 0x00000000, 0x00000000,
0xbf800002, 0x00000000, 0x00000000, 0x00000000,
0xbfc00002, 0x00000000, 0x00000000, 0x00000000,
0xbf800001, 0x00000000, 0x00000000, 0x00000000,
0xbf800002, 0x00000000, 0x00000000, 0x00000000,
0xbfc00002, 0x00000000, 0x00000000, 0x00000000,
0xc1200001, 0x00000000, 0x00000000, 0x00000000,
0xbf800002, 0x00000000, 0x00000000, 0x00000000,
0xbfc00002, 0x00000000, 0x00000000, 0x00000000,
0xc1200001, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xbfc00002, 0x00000000, 0x00000000, 0x00000000,
0xc1200001, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xc1200001, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x80123456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x80123456, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x80123456, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x80123456, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80800000, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00800001, 0x00000000, 0x00000000, 0x00000000,
0x80000001, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00800001, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00800001, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3f000001, 0x00000000, 0x00000000, 0x00000000,
0x00800001, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3f000001, 0x00000000, 0x00000000, 0x00000000,
0x3f000002, 0x00000000, 0x00000000, 0x00000000,
0x3f000000, 0x00000000, 0x00000000, 0x00000000,
0x3f000001, 0x00000000, 0x00000000, 0x00000000,
0x3f000002, 0x00000000, 0x00000000, 0x00000000,
0x3f800000, 0x00000000, 0x00000000, 0x00000000,
0x3f000001, 0x00000000, 0x00000000, 0x00000000,
0x3f000002, 0x00000000, 0x00000000, 0x00000000,
0x3f800000, 0x00000000, 0x00000000, 0x00000000,
0x3f800001, 0x00000000, 0x00000000, 0x00000000,
0x3f000002, 0x00000000, 0x00000000, 0x00000000,
0x3f800000, 0x00000000, 0x00000000, 0x00000000,
0x3f800001, 0x00000000, 0x00000000, 0x00000000,
0x3f800002, 0x00000000, 0x00000000, 0x00000000,
0x3f800000, 0x00000000, 0x00000000, 0x00000000,
0x3f800001, 0x00000000, 0x00000000, 0x00000000,
0x3f800002, 0x00000000, 0x00000000, 0x00000000,
0x3fc00002, 0x00000000, 0x00000000, 0x00000000,
0x3f800001, 0x00000000, 0x00000000, 0x00000000,
0x3f800002, 0x00000000, 0x00000000, 0x00000000,
0x3fc00002, 0x00000000, 0x00000000, 0x00000000,
0x41200001, 0x00000000, 0x00000000, 0x00000000,
0x3f800002, 0x00000000, 0x00000000, 0x00000000,
0x3fc00002, 0x00000000, 0x00000000, 0x00000000,
0x41200001, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x3fc00002, 0x00000000, 0x00000000, 0x00000000,
0x41200001, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x41200001, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x00123456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x00123456, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x00123456, 0x00000000, 0x00000000, 0x00000000,
0x00800000, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x001b4e81, 0x00000000, 0x00000000, 0x00000000,
0x00bffffe, 0x00000000, 0x00000000, 0x00000000,
0x00000002, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x00bffffe, 0x00000000, 0x00000000, 0x00000000,
0x00000002, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80c00000, 0x00000000, 0x00000000, 0x00000000,
0x00000002, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80c00000, 0x00000000, 0x00000000, 0x00000000,
0xbf3fffff, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x80c00000, 0x00000000, 0x00000000, 0x00000000,
0xbf3fffff, 0x00000000, 0x00000000, 0x00000000,
0xbf400000, 0x00000000, 0x00000000, 0x00000000,
0x80c00000, 0x00000000, 0x00000000, 0x00000000,
0xbf3fffff, 0x00000000, 0x00000000, 0x00000000,
0xbf400000, 0x00000000, 0x00000000, 0x00000000,
0xbf400002, 0x00000000, 0x00000000, 0x00000000,
0xbf3fffff, 0x00000000, 0x00000000, 0x00000000,
0xbf400000, 0x00000000, 0x00000000, 0x00000000,
0xbf400002, 0x00000000, 0x00000000, 0x00000000,
0xbfbfffff, 0x00000000, 0x00000000, 0x00000000,
0xbf400000, 0x00000000, 0x00000000, 0x00000000,
0xbf400002, 0x00000000, 0x00000000, 0x00000000,
0xbfbfffff, 0x00000000, 0x00000000, 0x00000000,
0xbfc00000, 0x00000000, 0x00000000, 0x00000000,
0xbf400002, 0x00000000, 0x00000000, 0x00000000,
0xbfbfffff, 0x00000000, 0x00000000, 0x00000000,
0xbfc00000, 0x00000000, 0x00000000, 0x00000000,
0xbfc00002, 0x00000000, 0x00000000, 0x00000000,
0xbfbfffff, 0x00000000, 0x00000000, 0x00000000,
0xbfc00000, 0x00000000, 0x00000000, 0x00000000,
0xbfc00002, 0x00000000, 0x00000000, 0x00000000,
0xc0100000, 0x00000000, 0x00000000, 0x00000000,
0xbfc00000, 0x00000000, 0x00000000, 0x00000000,
0xbfc00002, 0x00000000, 0x00000000, 0x00000000,
0xc0100000, 0x00000000, 0x00000000, 0x00000000,
0xc1700000, 0x00000000, 0x00000000, 0x00000000,
0xbfc00002, 0x00000000, 0x00000000, 0x00000000,
0xc0100000, 0x00000000, 0x00000000, 0x00000000,
0xc1700000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xc0100000, 0x00000000, 0x00000000, 0x00000000,
0xc1700000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xc1700000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x801b4e81, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x801b4e81, 0x00000000, 0x00000000, 0x00000000,
0x80bffffe, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x801b4e81, 0x00000000, 0x00000000, 0x00000000,
0x80bffffe, 0x00000000, 0x00000000, 0x00000000,
0x80000002, 0x00000000, 0x00000000, 0x00000000,
0x801b4e81, 0x00000000, 0x00000000, 0x00000000,
0x80bffffe, 0x00000000, 0x00000000, 0x00000000,
0x80000002, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x80bffffe, 0x00000000, 0x00000000, 0x00000000,
0x80000002, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00c00000, 0x00000000, 0x00000000, 0x00000000,
0x80000002, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00c00000, 0x00000000, 0x00000000, 0x00000000,
0x3f3fffff, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00c00000, 0x00000000, 0x00000000, 0x00000000,
0x3f3fffff, 0x00000000, 0x00000000, 0x00000000,
0x3f400000, 0x00000000, 0x00000000, 0x00000000,
0x00c00000, 0x00000000, 0x00000000, 0x00000000,
0x3f3fffff, 0x00000000, 0x00000000, 0x00000000,
0x3f400000, 0x00000000, 0x00000000, 0x00000000,
0x3f400002, 0x00000000, 0x00000000, 0x00000000,
0x3f3fffff, 0x00000000, 0x00000000, 0x00000000,
0x3f400000, 0x00000000, 0x00000000, 0x00000000,
0x3f400002, 0x00000000, 0x00000000, 0x00000000,
0x3fbfffff, 0x00000000, 0x00000000, 0x00000000,
0x3f400000, 0x00000000, 0x00000000, 0x00000000,
0x3f400002, 0x00000000, 0x00000000, 0x00000000,
0x3fbfffff, 0x00000000, 0x00000000, 0x00000000,
0x3fc00000, 0x00000000, 0x00000000, 0x00000000,
0x3f400002, 0x00000000, 0x00000000, 0x00000000,
0x3fbfffff, 0x00000000, 0x00000000, 0x00000000,
0x3fc00000, 0x00000000, 0x00000000, 0x00000000,
0x3fc00002, 0x00000000, 0x00000000, 0x00000000,
0x3fbfffff, 0x00000000, 0x00000000, 0x00000000,
0x3fc00000, 0x00000000, 0x00000000, 0x00000000,
0x3fc00002, 0x00000000, 0x00000000, 0x00000000,
0x40100000, 0x00000000, 0x00000000, 0x00000000,
0x3fc00000, 0x00000000, 0x00000000, 0x00000000,
0x3fc00002, 0x00000000, 0x00000000, 0x00000000,
0x40100000, 0x00000000, 0x00000000, 0x00000000,
0x41700000, 0x00000000, 0x00000000, 0x00000000,
0x3fc00002, 0x00000000, 0x00000000, 0x00000000,
0x40100000, 0x00000000, 0x00000000, 0x00000000,
0x41700000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x40100000, 0x00000000, 0x00000000, 0x00000000,
0x41700000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x41700000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x001b4e81, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x001b4e81, 0x00000000, 0x00000000, 0x00000000,
0x00bffffe, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x001b4e81, 0x00000000, 0x00000000, 0x00000000,
0x00bffffe, 0x00000000, 0x00000000, 0x00000000,
0x00000002, 0x00000000, 0x00000000, 0x00000000,
0x00b60b5c, 0x00000000, 0x00000000, 0x00000000,
0x021fffff, 0x00000000, 0x00000000, 0x00000000,
0x0000000a, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x021fffff, 0x00000000, 0x00000000, 0x00000000,
0x0000000a, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x82200000, 0x00000000, 0x00000000, 0x00000000,
0x0000000a, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x82200000, 0x00000000, 0x00000000, 0x00000000,
0xc09fffff, 0x00000000, 0x00000000, 0x00000000,
0x80000000, 0x00000000, 0x00000000, 0x00000000,
0x82200000, 0x00000000, 0x00000000, 0x00000000,
0xc09fffff, 0x00000000, 0x00000000, 0x00000000,
0xc0a00000, 0x00000000, 0x00000000, 0x00000000,
0x82200000, 0x00000000, 0x00000000, 0x00000000,
0xc09fffff, 0x00000000, 0x00000000, 0x00000000,
0xc0a00000, 0x00000000, 0x00000000, 0x00000000,
0xc0a00001, 0x00000000, 0x00000000, 0x00000000,
0xc09fffff, 0x00000000, 0x00000000, 0x00000000,
0xc0a00000, 0x00000000, 0x00000000, 0x00000000,
0xc0a00001, 0x00000000, 0x00000000, 0x00000000,
0xc11fffff, 0x00000000, 0x00000000, 0x00000000,
0xc0a00000, 0x00000000, 0x00000000, 0x00000000,
0xc0a00001, 0x00000000, 0x00000000, 0x00000000,
0xc11fffff, 0x00000000, 0x00000000, 0x00000000,
0xc1200000, 0x00000000, 0x00000000, 0x00000000,
0xc0a00001, 0x00000000, 0x00000000, 0x00000000,
0xc11fffff, 0x00000000, 0x00000000, 0x00000000,
0xc1200000, 0x00000000, 0x00000000, 0x00000000,
0xc1200001, 0x00000000, 0x00000000, 0x00000000,
0xc11fffff, 0x00000000, 0x00000000, 0x00000000,
0xc1200000, 0x00000000, 0x00000000, 0x00000000,
0xc1200001, 0x00000000, 0x00000000, 0x00000000,
0xc1700000, 0x00000000, 0x00000000, 0x00000000,
0xc1200000, 0x00000000, 0x00000000, 0x00000000,
0xc1200001, 0x00000000, 0x00000000, 0x00000000,
0xc1700000, 0x00000000, 0x00000000, 0x00000000,
0xc2c80000, 0x00000000, 0x00000000, 0x00000000,
0xc1200001, 0x00000000, 0x00000000, 0x00000000,
0xc1700000, 0x00000000, 0x00000000, 0x00000000,
0xc2c80000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xc1700000, 0x00000000, 0x00000000, 0x00000000,
0xc2c80000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xc2c80000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x80b60b5c, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x80b60b5c, 0x00000000, 0x00000000, 0x00000000,
0x821fffff, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x80b60b5c, 0x00000000, 0x00000000, 0x00000000,
0x821fffff, 0x00000000, 0x00000000, 0x00000000,
0x8000000a, 0x00000000, 0x00000000, 0x00000000,
0x80b60b5c, 0x00000000, 0x00000000, 0x00000000,
0x821fffff, 0x00000000, 0x00000000, 0x00000000,
0x8000000a, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x821fffff, 0x00000000, 0x00000000, 0x00000000,
0x8000000a, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x02200000, 0x00000000, 0x00000000, 0x00000000,
0x8000000a, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x02200000, 0x00000000, 0x00000000, 0x00000000,
0x409fffff, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x02200000, 0x00000000, 0x00000000, 0x00000000,
0x409fffff, 0x00000000, 0x00000000, 0x00000000,
0x40a00000, 0x00000000, 0x00000000, 0x00000000,
0x02200000, 0x00000000, 0x00000000, 0x00000000,
0x409fffff, 0x00000000, 0x00000000, 0x00000000,
0x40a00000, 0x00000000, 0x00000000, 0x00000000,
0x40a00001, 0x00000000, 0x00000000, 0x00000000,
0x409fffff, 0x00000000, 0x00000000, 0x00000000,
0x40a00000, 0x00000000, 0x00000000, 0x00000000,
0x40a00001, 0x00000000, 0x00000000, 0x00000000,
0x411fffff, 0x00000000, 0x00000000, 0x00000000,
0x40a00000, 0x00000000, 0x00000000, 0x00000000,
0x40a00001, 0x00000000, 0x00000000, 0x00000000,
0x411fffff, 0x00000000, 0x00000000, 0x00000000,
0x41200000, 0x00000000, 0x00000000, 0x00000000,
0x40a00001, 0x00000000, 0x00000000, 0x00000000,
0x411fffff, 0x00000000, 0x00000000, 0x00000000,
0x41200000, 0x00000000, 0x00000000, 0x00000000,
0x41200001, 0x00000000, 0x00000000, 0x00000000,
0x411fffff, 0x00000000, 0x00000000, 0x00000000,
0x41200000, 0x00000000, 0x00000000, 0x00000000,
0x41200001, 0x00000000, 0x00000000, 0x00000000,
0x41700000, 0x00000000, 0x00000000, 0x00000000,
0x41200000, 0x00000000, 0x00000000, 0x00000000,
0x41200001, 0x00000000, 0x00000000, 0x00000000,
0x41700000, 0x00000000, 0x00000000, 0x00000000,
0x42c80000, 0x00000000, 0x00000000, 0x00000000,
0x41200001, 0x00000000, 0x00000000, 0x00000000,
0x41700000, 0x00000000, 0x00000000, 0x00000000,
0x42c80000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x41700000, 0x00000000, 0x00000000, 0x00000000,
0x42c80000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x42c80000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x00b60b5c, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x00b60b5c, 0x00000000, 0x00000000, 0x00000000,
0x021fffff, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x00b60b5c, 0x00000000, 0x00000000, 0x00000000,
0x021fffff, 0x00000000, 0x00000000, 0x00000000,
0x0000000a, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xc0000000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xc0000000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xc0000000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xc0000000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0x7fc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x40000000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x40000000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xff800000, 0x00000000, 0x00000000, 0x00000000,
0x40000000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x40000000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0x7f800000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fd23456, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0x7fc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffcfffff, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffc00000, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffd23456, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
0xffc00001, 0x00000000, 0x00000000, 0x00000000,
};
const unsigned kExpectedCount_NEON_fmulx_S_S_S = 5776;
#endif // VIXL_SIM_FMULX_S_S_S_TRACE_AARCH64_H_
| 116,487 |
369 | /*
* Copyright © 2019 <NAME>, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package io.cdap.cdap.master.environment.k8s;
import com.google.common.io.Closeables;
import com.google.common.util.concurrent.AbstractService;
import com.google.common.util.concurrent.Service;
import com.google.inject.AbstractModule;
import com.google.inject.Binding;
import com.google.inject.Injector;
import com.google.inject.Key;
import com.google.inject.Module;
import com.google.inject.Scopes;
import io.cdap.cdap.app.guice.EntityVerifierModule;
import io.cdap.cdap.app.store.Store;
import io.cdap.cdap.common.conf.CConfiguration;
import io.cdap.cdap.common.conf.Constants;
import io.cdap.cdap.common.guice.DFSLocationModule;
import io.cdap.cdap.common.logging.LoggingContext;
import io.cdap.cdap.common.logging.ServiceLoggingContext;
import io.cdap.cdap.common.namespace.guice.NamespaceQueryAdminModule;
import io.cdap.cdap.data.runtime.DataSetsModules;
import io.cdap.cdap.data.runtime.SystemDatasetRuntimeModule;
import io.cdap.cdap.data2.audit.AuditModule;
import io.cdap.cdap.data2.metadata.writer.MessagingMetadataPublisher;
import io.cdap.cdap.data2.metadata.writer.MetadataPublisher;
import io.cdap.cdap.internal.app.store.DefaultStore;
import io.cdap.cdap.master.spi.environment.MasterEnvironment;
import io.cdap.cdap.master.spi.environment.MasterEnvironmentContext;
import io.cdap.cdap.messaging.guice.MessagingClientModule;
import io.cdap.cdap.metadata.MetadataService;
import io.cdap.cdap.metadata.MetadataServiceModule;
import io.cdap.cdap.metadata.MetadataSubscriberService;
import io.cdap.cdap.proto.id.NamespaceId;
import io.cdap.cdap.security.auth.TokenManager;
import io.cdap.cdap.security.authorization.AuthorizationEnforcementModule;
import io.cdap.cdap.security.impersonation.CurrentUGIProvider;
import io.cdap.cdap.security.impersonation.DefaultOwnerAdmin;
import io.cdap.cdap.security.impersonation.OwnerAdmin;
import io.cdap.cdap.security.impersonation.SecurityUtil;
import io.cdap.cdap.security.impersonation.UGIProvider;
import io.cdap.cdap.security.spi.authorization.NoOpAccessController;
import io.cdap.cdap.security.spi.authorization.PermissionManager;
import io.cdap.cdap.spi.metadata.MetadataStorage;
import org.apache.twill.zookeeper.ZKClientService;
import java.util.Arrays;
import java.util.List;
import javax.annotation.Nullable;
/**
* The main class to run metadata service. Also, the dataset op executor is running this process as well.
*/
public class MetadataServiceMain extends AbstractServiceMain<EnvironmentOptions> {
/**
* Main entry point
*/
public static void main(String[] args) throws Exception {
main(MetadataServiceMain.class, args);
}
@Override
protected List<Module> getServiceModules(MasterEnvironment masterEnv,
EnvironmentOptions options, CConfiguration cConf) {
return Arrays.asList(
new MessagingClientModule(),
new NamespaceQueryAdminModule(),
getDataFabricModule(),
// Always use local table implementations, which use LevelDB.
// In K8s, there won't be HBase and the cdap-site should be set to use SQL store for StructuredTable.
new SystemDatasetRuntimeModule().getStandaloneModules(),
new DataSetsModules().getStandaloneModules(),
new MetadataServiceModule(),
new AuditModule(),
new EntityVerifierModule(),
new AuthorizationEnforcementModule().getDistributedModules(),
new DFSLocationModule(),
new AbstractModule() {
@Override
protected void configure() {
bind(Store.class).to(DefaultStore.class);
// Current impersonation is not supported
bind(UGIProvider.class).to(CurrentUGIProvider.class).in(Scopes.SINGLETON);
bind(PermissionManager.class).to(NoOpAccessController.class);
bind(OwnerAdmin.class).to(DefaultOwnerAdmin.class);
// TODO (CDAP-14677): find a better way to inject metadata publisher
bind(MetadataPublisher.class).to(MessagingMetadataPublisher.class);
}
}
);
}
@Override
protected void addServices(Injector injector, List<? super Service> services,
List<? super AutoCloseable> closeableResources,
MasterEnvironment masterEnv, MasterEnvironmentContext masterEnvContext,
EnvironmentOptions options) {
services.add(injector.getInstance(MetadataService.class));
services.add(injector.getInstance(MetadataSubscriberService.class));
Binding<ZKClientService> zkBinding = injector.getExistingBinding(Key.get(ZKClientService.class));
if (zkBinding != null) {
services.add(zkBinding.getProvider().get());
}
CConfiguration cConf = injector.getInstance(CConfiguration.class);
if (SecurityUtil.isInternalAuthEnabled(cConf)) {
services.add(injector.getInstance(TokenManager.class));
}
// Add a service just for closing MetadataStorage to release resource.
// MetadataStorage is binded as Singleton, so ok to get the instance and close it.
MetadataStorage metadataStorage = injector.getInstance(MetadataStorage.class);
services.add(new AbstractService() {
@Override
protected void doStart() {
notifyStarted();
}
@Override
protected void doStop() {
Closeables.closeQuietly(metadataStorage);
notifyStopped();
}
});
}
@Nullable
@Override
protected LoggingContext getLoggingContext(EnvironmentOptions options) {
return new ServiceLoggingContext(NamespaceId.SYSTEM.getNamespace(),
Constants.Logging.COMPONENT_NAME,
Constants.Service.METADATA_SERVICE);
}
}
| 2,221 |
2,338 | //===----- RISCVMergeBaseOffset.cpp - Optimise address calculations ------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// Merge the offset of address calculation into the offset field
// of instructions in a global address lowering sequence. This pass transforms:
// lui vreg1, %hi(s)
// addi vreg2, vreg1, %lo(s)
// addi vreg3, verg2, Offset
//
// Into:
// lui vreg1, %hi(s+Offset)
// addi vreg2, vreg1, %lo(s+Offset)
//
// The transformation is carried out under certain conditions:
// 1) The offset field in the base of global address lowering sequence is zero.
// 2) The lowered global address has only one use.
//
// The offset field can be in a different form. This pass handles all of them.
//===----------------------------------------------------------------------===//
#include "RISCV.h"
#include "RISCVTargetMachine.h"
#include "llvm/CodeGen/Passes.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/TargetRegistry.h"
#include "llvm/Target/TargetOptions.h"
#include <set>
using namespace llvm;
#define DEBUG_TYPE "riscv-merge-base-offset"
#define RISCV_MERGE_BASE_OFFSET_NAME "RISCV Merge Base Offset"
namespace {
struct RISCVMergeBaseOffsetOpt : public MachineFunctionPass {
static char ID;
const MachineFunction *MF;
bool runOnMachineFunction(MachineFunction &Fn) override;
bool detectLuiAddiGlobal(MachineInstr &LUI, MachineInstr *&ADDI);
bool detectAndFoldOffset(MachineInstr &HiLUI, MachineInstr &LoADDI);
void foldOffset(MachineInstr &HiLUI, MachineInstr &LoADDI, MachineInstr &Tail,
int64_t Offset);
bool matchLargeOffset(MachineInstr &TailAdd, Register GSReg, int64_t &Offset);
RISCVMergeBaseOffsetOpt() : MachineFunctionPass(ID) {}
MachineFunctionProperties getRequiredProperties() const override {
return MachineFunctionProperties().set(
MachineFunctionProperties::Property::IsSSA);
}
void getAnalysisUsage(AnalysisUsage &AU) const override {
AU.setPreservesCFG();
MachineFunctionPass::getAnalysisUsage(AU);
}
StringRef getPassName() const override {
return RISCV_MERGE_BASE_OFFSET_NAME;
}
private:
MachineRegisterInfo *MRI;
std::set<MachineInstr *> DeadInstrs;
};
} // end anonymous namespace
char RISCVMergeBaseOffsetOpt::ID = 0;
INITIALIZE_PASS(RISCVMergeBaseOffsetOpt, DEBUG_TYPE,
RISCV_MERGE_BASE_OFFSET_NAME, false, false)
// Detect the pattern:
// lui vreg1, %hi(s)
// addi vreg2, vreg1, %lo(s)
//
// Pattern only accepted if:
// 1) ADDI has only one use.
// 2) LUI has only one use; which is the ADDI.
// 3) Both ADDI and LUI have GlobalAddress type which indicates that these
// are generated from global address lowering.
// 4) Offset value in the Global Address is 0.
bool RISCVMergeBaseOffsetOpt::detectLuiAddiGlobal(MachineInstr &HiLUI,
MachineInstr *&LoADDI) {
if (HiLUI.getOpcode() != RISCV::LUI ||
HiLUI.getOperand(1).getTargetFlags() != RISCVII::MO_HI ||
HiLUI.getOperand(1).getType() != MachineOperand::MO_GlobalAddress ||
HiLUI.getOperand(1).getOffset() != 0 ||
!MRI->hasOneUse(HiLUI.getOperand(0).getReg()))
return false;
Register HiLuiDestReg = HiLUI.getOperand(0).getReg();
LoADDI = MRI->use_begin(HiLuiDestReg)->getParent();
if (LoADDI->getOpcode() != RISCV::ADDI ||
LoADDI->getOperand(2).getTargetFlags() != RISCVII::MO_LO ||
LoADDI->getOperand(2).getType() != MachineOperand::MO_GlobalAddress ||
LoADDI->getOperand(2).getOffset() != 0 ||
!MRI->hasOneUse(LoADDI->getOperand(0).getReg()))
return false;
return true;
}
// Update the offset in HiLUI and LoADDI instructions.
// Delete the tail instruction and update all the uses to use the
// output from LoADDI.
void RISCVMergeBaseOffsetOpt::foldOffset(MachineInstr &HiLUI,
MachineInstr &LoADDI,
MachineInstr &Tail, int64_t Offset) {
// Put the offset back in HiLUI and the LoADDI
HiLUI.getOperand(1).setOffset(Offset);
LoADDI.getOperand(2).setOffset(Offset);
// Delete the tail instruction.
DeadInstrs.insert(&Tail);
MRI->replaceRegWith(Tail.getOperand(0).getReg(),
LoADDI.getOperand(0).getReg());
LLVM_DEBUG(dbgs() << " Merged offset " << Offset << " into base.\n"
<< " " << HiLUI << " " << LoADDI;);
}
// Detect patterns for large offsets that are passed into an ADD instruction.
//
// Base address lowering is of the form:
// HiLUI: lui vreg1, %hi(s)
// LoADDI: addi vreg2, vreg1, %lo(s)
// / \
// / \
// / \
// / The large offset can be of two forms: \
// 1) Offset that has non zero bits in lower 2) Offset that has non zero
// 12 bits and upper 20 bits bits in upper 20 bits only
// OffseLUI: lui vreg3, 4
// OffsetTail: addi voff, vreg3, 188 OffsetTail: lui voff, 128
// \ /
// \ /
// \ /
// \ /
// TailAdd: add vreg4, vreg2, voff
bool RISCVMergeBaseOffsetOpt::matchLargeOffset(MachineInstr &TailAdd,
Register GAReg,
int64_t &Offset) {
assert((TailAdd.getOpcode() == RISCV::ADD) && "Expected ADD instruction!");
Register Rs = TailAdd.getOperand(1).getReg();
Register Rt = TailAdd.getOperand(2).getReg();
Register Reg = Rs == GAReg ? Rt : Rs;
// Can't fold if the register has more than one use.
if (!MRI->hasOneUse(Reg))
return false;
// This can point to an ADDI or a LUI:
MachineInstr &OffsetTail = *MRI->getVRegDef(Reg);
if (OffsetTail.getOpcode() == RISCV::ADDI) {
// The offset value has non zero bits in both %hi and %lo parts.
// Detect an ADDI that feeds from a LUI instruction.
MachineOperand &AddiImmOp = OffsetTail.getOperand(2);
if (AddiImmOp.getTargetFlags() != RISCVII::MO_None)
return false;
int64_t OffLo = AddiImmOp.getImm();
MachineInstr &OffsetLui =
*MRI->getVRegDef(OffsetTail.getOperand(1).getReg());
MachineOperand &LuiImmOp = OffsetLui.getOperand(1);
if (OffsetLui.getOpcode() != RISCV::LUI ||
LuiImmOp.getTargetFlags() != RISCVII::MO_None ||
!MRI->hasOneUse(OffsetLui.getOperand(0).getReg()))
return false;
int64_t OffHi = OffsetLui.getOperand(1).getImm();
Offset = (OffHi << 12) + OffLo;
LLVM_DEBUG(dbgs() << " Offset Instrs: " << OffsetTail
<< " " << OffsetLui);
DeadInstrs.insert(&OffsetTail);
DeadInstrs.insert(&OffsetLui);
return true;
} else if (OffsetTail.getOpcode() == RISCV::LUI) {
// The offset value has all zero bits in the lower 12 bits. Only LUI
// exists.
LLVM_DEBUG(dbgs() << " Offset Instr: " << OffsetTail);
Offset = OffsetTail.getOperand(1).getImm() << 12;
DeadInstrs.insert(&OffsetTail);
return true;
}
return false;
}
bool RISCVMergeBaseOffsetOpt::detectAndFoldOffset(MachineInstr &HiLUI,
MachineInstr &LoADDI) {
Register DestReg = LoADDI.getOperand(0).getReg();
assert(MRI->hasOneUse(DestReg) && "expected one use for LoADDI");
// LoADDI has only one use.
MachineInstr &Tail = *MRI->use_begin(DestReg)->getParent();
switch (Tail.getOpcode()) {
default:
LLVM_DEBUG(dbgs() << "Don't know how to get offset from this instr:"
<< Tail);
return false;
case RISCV::ADDI: {
// Offset is simply an immediate operand.
int64_t Offset = Tail.getOperand(2).getImm();
LLVM_DEBUG(dbgs() << " Offset Instr: " << Tail);
foldOffset(HiLUI, LoADDI, Tail, Offset);
return true;
}
case RISCV::ADD: {
// The offset is too large to fit in the immediate field of ADDI.
// This can be in two forms:
// 1) LUI hi_Offset followed by:
// ADDI lo_offset
// This happens in case the offset has non zero bits in
// both hi 20 and lo 12 bits.
// 2) LUI (offset20)
// This happens in case the lower 12 bits of the offset are zeros.
int64_t Offset;
if (!matchLargeOffset(Tail, DestReg, Offset))
return false;
foldOffset(HiLUI, LoADDI, Tail, Offset);
return true;
}
case RISCV::LB:
case RISCV::LH:
case RISCV::LW:
case RISCV::LBU:
case RISCV::LHU:
case RISCV::LWU:
case RISCV::LD:
case RISCV::FLH:
case RISCV::FLW:
case RISCV::FLD:
case RISCV::SB:
case RISCV::SH:
case RISCV::SW:
case RISCV::SD:
case RISCV::FSH:
case RISCV::FSW:
case RISCV::FSD: {
// Transforms the sequence: Into:
// HiLUI: lui vreg1, %hi(foo) ---> lui vreg1, %hi(foo+8)
// LoADDI: addi vreg2, vreg1, %lo(foo) ---> lw vreg3, lo(foo+8)(vreg1)
// Tail: lw vreg3, 8(vreg2)
if (Tail.getOperand(1).isFI())
return false;
// Register defined by LoADDI should be used in the base part of the
// load\store instruction. Otherwise, no folding possible.
Register BaseAddrReg = Tail.getOperand(1).getReg();
if (DestReg != BaseAddrReg)
return false;
MachineOperand &TailImmOp = Tail.getOperand(2);
int64_t Offset = TailImmOp.getImm();
// Update the offsets in global address lowering.
HiLUI.getOperand(1).setOffset(Offset);
// Update the immediate in the Tail instruction to add the offset.
Tail.RemoveOperand(2);
MachineOperand &ImmOp = LoADDI.getOperand(2);
ImmOp.setOffset(Offset);
Tail.addOperand(ImmOp);
// Update the base reg in the Tail instruction to feed from LUI.
// Output of HiLUI is only used in LoADDI, no need to use
// MRI->replaceRegWith().
Tail.getOperand(1).setReg(HiLUI.getOperand(0).getReg());
DeadInstrs.insert(&LoADDI);
return true;
}
}
return false;
}
bool RISCVMergeBaseOffsetOpt::runOnMachineFunction(MachineFunction &Fn) {
if (skipFunction(Fn.getFunction()))
return false;
bool MadeChange = false;
DeadInstrs.clear();
MRI = &Fn.getRegInfo();
for (MachineBasicBlock &MBB : Fn) {
LLVM_DEBUG(dbgs() << "MBB: " << MBB.getName() << "\n");
for (MachineInstr &HiLUI : MBB) {
MachineInstr *LoADDI = nullptr;
if (!detectLuiAddiGlobal(HiLUI, LoADDI))
continue;
LLVM_DEBUG(dbgs() << " Found lowered global address with one use: "
<< *LoADDI->getOperand(2).getGlobal() << "\n");
// If the use count is only one, merge the offset
MadeChange |= detectAndFoldOffset(HiLUI, *LoADDI);
}
}
// Delete dead instructions.
for (auto *MI : DeadInstrs)
MI->eraseFromParent();
return MadeChange;
}
/// Returns an instance of the Merge Base Offset Optimization pass.
FunctionPass *llvm::createRISCVMergeBaseOffsetOptPass() {
return new RISCVMergeBaseOffsetOpt();
}
| 4,963 |
5,169 | <reponame>Gantios/Specs
{
"name": "scrypt-cryptoswift",
"version": "1.2",
"summary": "Scrypt implementation in vanilla Swift for iOS ans macOS",
"description": "Scrypt implementation in vanilla Swift, intended for use together with a Cryptoswift pod",
"homepage": "https://github.com/shamatar/scrypt-cryptoswift",
"license": "Apache License 2.0",
"authors": {
"<NAME>": "<EMAIL>"
},
"source": {
"git": "https://github.com/shamatar/scrypt-cryptoswift.git",
"tag": "1.2"
},
"social_media_url": "https://twitter.com/shamatar",
"swift_version": "4.1",
"module_name": "scrypt_cryptoswift",
"platforms": {
"ios": "9.0",
"osx": "10.11"
},
"public_header_files": "scrypt-cryptoswift/scrypt_cryptoswift.h",
"source_files": [
"scrypt-cryptoswift/**/*.{swift}",
"scrypt-cryptoswift/scrypt_cryptoswift.h"
],
"pod_target_xcconfig": {
"DEFINES_MODULE": "YES"
},
"dependencies": {
"CryptoSwift": [
"~> 0.11"
]
}
}
| 426 |
777 | <gh_stars>100-1000
# Copyright 2015 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import json
from telemetry.page import legacy_page_test
from telemetry.value import histogram_util
from telemetry.value import scalar
from telemetry.value import skip
_NAME = 'V8.DetachedContextAgeInGC'
_UNITS = 'garbage_collections'
_DISPLAY_NAME = 'V8_DetachedContextAgeInGC'
_TYPE = histogram_util.RENDERER_HISTOGRAM
_DESCRIPTION = 'Number of GCs needed to collect detached context'
def _GetMaxDetachedContextAge(tab, data_start):
data = histogram_util.GetHistogram(_TYPE, _NAME, tab)
delta = histogram_util.SubtractHistogram(data, data_start)
if not 'buckets' in delta:
return
buckets = json.loads(delta)['buckets']
if buckets:
return max(x.get('high', x['low']) for x in buckets)
class V8DetachedContextAgeInGC(legacy_page_test.LegacyPageTest):
def __init__(self):
super(V8DetachedContextAgeInGC, self).__init__()
self._data_start = None
def CustomizeBrowserOptions(self, options):
options.AppendExtraBrowserArgs(['--enable-stats-collection-bindings'])
def DidNavigateToPage(self, page, tab):
del page # unused
self._data_start = histogram_util.GetHistogram(_TYPE, _NAME, tab)
def ValidateAndMeasurePage(self, page, tab, results):
del page # unused
# Trigger GC to get histogram data.
# Seven GCs should be enough to collect any detached context.
# If a detached context survives more GCs then there is a leak.
MAX_AGE = 8
for _ in xrange(MAX_AGE):
tab.CollectGarbage()
value = _GetMaxDetachedContextAge(tab, self._data_start)
if value is None:
results.AddValue(skip.SkipValue(
results.current_page, 'No detached contexts'))
else:
results.AddValue(scalar.ScalarValue(
results.current_page, _DISPLAY_NAME, _UNITS, value,
description=_DESCRIPTION))
| 692 |
1,100 | /*********************************************************************************
* (Generic Heap using Comparator) Revise Heap in Listing 23.9, using a generic *
* parameter and a Comparator for comparing objects. Define a new constructor *
* with a Comparator as its argument as follows: *
* *
* Heap(Comparator<? super E> comparator) *
*********************************************************************************/
import java.util.Comparator;
public class Exercise_23_09 {
public static void main(String[] args) {
// Create an array of 10 GeometricObjects
GeometricObject[] list = {new Circle(5), new Rectangle(4, 5),
new Circle(5.5), new Rectangle(2.4, 5), new Circle(0.5),
new Rectangle(4, 65), new Circle(4.5), new Rectangle(4.4, 1),
new Circle(6.5), new Rectangle(4, 5)};
Heap<GeometricObject> heap = new Heap<>(new GeometricObjectComparator());
for (int i = 0; i < list.length; i++) {
heap.add(list[i]);
}
for (int i = list.length - 1; i > 0; i--) {
list[i] = heap.remove();
}
for (GeometricObject e: list)
System.out.printf("%.2f ", e.getArea());
System.out.println();
}
} | 530 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.