max_stars_count
int64 301
224k
| text
stringlengths 6
1.05M
| token_count
int64 3
727k
|
|---|---|---|
1,588 | package xyz.erupt.monitor.vo;
import lombok.Getter;
import lombok.Setter;
import oshi.software.os.OSFileStore;
import xyz.erupt.monitor.util.SystemUtil;
import java.text.DecimalFormat;
/**
* @author YuePeng
* date 2021/1/23 23:07
*/
@Getter
@Setter
public class SysFile {
/**
* 盘符路径
*/
private String dirName;
/**
* 盘符类型
*/
private String sysTypeName;
/**
* 文件类型
*/
private String typeName;
/**
* 总大小
*/
private String total;
/**
* 剩余大小
*/
private String free;
/**
* 已经使用量
*/
private String used;
/**
* 资源的使用率
*/
private String usage;
SysFile(OSFileStore fs) {
long free = fs.getUsableSpace();
long total = fs.getTotalSpace();
long used = total - free;
this.setDirName(fs.getMount());
this.setSysTypeName(fs.getType());
this.setTypeName(fs.getName());
this.setTotal(SystemUtil.formatByte(total));
this.setFree(SystemUtil.formatByte((free)));
this.setUsed(SystemUtil.formatByte((used)));
this.setUsage(new DecimalFormat("#.##%").format((total - free) * 1.0 / total));
}
}
| 594 |
13,162 | #include <eosio/chain/authority.hpp>
namespace fc {
void to_variant(const eosio::chain::shared_public_key& var, fc::variant& vo) {
vo = var.to_string();
}
} // namespace fc
| 80 |
708 | import torch
import torch.nn.functional as F
def clip_bce(output_dict, target_dict):
"""Binary crossentropy loss.
"""
return F.binary_cross_entropy(
output_dict['clipwise_output'], target_dict['target'])
def get_loss_func(loss_type):
if loss_type == 'clip_bce':
return clip_bce | 124 |
1,840 | <reponame>Gigahawk/cli-visualizer
#include <Utils/NcursesUtils.h>
#include <Utils/Utils.h>
#include <gtest/gtest.h>
#include <iostream>
#include <ncurses.h>
TEST(UtilsTest, LowercaseAllLowerCase)
{
std::string s{"hello world"};
auto actual = vis::Utils::lowercase(s);
std::string expected{"hello world"};
EXPECT_EQ(expected, actual)
<< "lowercase must not change an all lowercased string";
}
TEST(UtilsTest, LowercaseAllUpperCase)
{
std::string s{"HELLO WORLD"};
auto actual = vis::Utils::lowercase(s);
std::string expected{"hello world"};
EXPECT_EQ(expected, actual)
<< "lowercase must lowercase an all uppercase string";
}
TEST(UtilsTest, LowercaseAllMixedCase)
{
std::string s{"HeLlo wORLD"};
auto actual = vis::Utils::lowercase(s);
std::string expected{"hello world"};
EXPECT_EQ(expected, actual)
<< "lowercase must lowercase a mixed case string";
}
TEST(UtilsTest, LowercaseEmptyString)
{
std::string s{""};
auto actual = vis::Utils::lowercase(s);
std::string expected{""};
EXPECT_EQ(expected, actual) << "lowercase must work with an empty string";
}
TEST(UtilsTest, ToBoolEmptyString)
{
auto actual = vis::Utils::to_bool("");
EXPECT_FALSE(actual) << "to_bool should return false for empty string";
}
TEST(UtilsTest, ToBoolOneString)
{
auto actual = vis::Utils::to_bool("1");
EXPECT_TRUE(actual) << "to_bool should return false for \"1\"";
}
TEST(UtilsTest, ToBoolZeroString)
{
auto actual = vis::Utils::to_bool("0");
EXPECT_FALSE(actual) << "to_bool should return false for \"0\"";
}
TEST(UtilsTest, ToBoolTrueString)
{
auto actual = vis::Utils::to_bool("true");
EXPECT_TRUE(actual) << "to_bool should return true for \"true\"";
}
TEST(UtilsTest, ToBoolTrUeString)
{
auto actual = vis::Utils::to_bool("trUe");
EXPECT_TRUE(actual) << "to_bool should return true for \"trUe\"";
}
TEST(UtilsTest, ToBoolFalseString)
{
auto actual = vis::Utils::to_bool("false");
EXPECT_FALSE(actual) << "to_bool should return true for \"false\"";
}
TEST(UtilsTest, ToBoolFaLseString)
{
auto actual = vis::Utils::to_bool("faLse");
EXPECT_FALSE(actual) << "to_bool should return true for \"faLse\"";
}
TEST(UtilsTest, GetStrFromStrStrUnorderedMap)
{
std::unordered_map<std::string, std::wstring> m{
{"a", L"a"}, {"b", L"b"}, {"c", L"c"}};
EXPECT_EQ(std::wstring{L"a"},
vis::Utils::get(m, std::string{"a"}, std::wstring{L""}));
EXPECT_EQ(std::wstring{L"b"},
vis::Utils::get(m, std::string{"b"}, std::wstring{L""}));
EXPECT_EQ(std::wstring{L""},
vis::Utils::get(m, std::string{"z"}, std::wstring{L""}));
EXPECT_EQ(std::wstring{L"d"},
vis::Utils::get(m, std::string{"z"}, std::wstring{L"d"}));
}
TEST(UtilsTest, GetBoolFromStrStrUnorderedMap)
{
std::unordered_map<std::string, std::wstring> m{
{"a", L"true"}, {"b", L"false"}, {"c", L"c"}};
EXPECT_EQ(true, vis::Utils::get(m, std::string{"a"}, true));
EXPECT_EQ(false, vis::Utils::get(m, std::string{"b"}, true));
EXPECT_EQ(true, vis::Utils::get(m, std::string{"z"}, true));
EXPECT_EQ(false, vis::Utils::get(m, std::string{"z"}, false));
}
TEST(UtilsTest, GetUintFromStrStrUnorderedMap)
{
std::unordered_map<std::string, std::wstring> m{
{"a", L"1337"}, {"b", L"42"}, {"c", L"c"}};
EXPECT_EQ(1337,
vis::Utils::get(m, std::string{"a"}, static_cast<uint32_t>(1)));
EXPECT_EQ(42,
vis::Utils::get(m, std::string{"b"}, static_cast<uint32_t>(1)));
EXPECT_EQ(314,
vis::Utils::get(m, std::string{"z"}, static_cast<uint32_t>(314)));
EXPECT_EQ(0,
vis::Utils::get(m, std::string{"z"}, static_cast<uint32_t>(0)));
}
TEST(UtilsTest, SplitFirstEmptyString)
{
std::pair<std::string, std::string> p{"hello", "world"};
std::string s{""};
vis::Utils::split_first(s, '=', &p);
EXPECT_EQ("", p.first);
EXPECT_EQ("", p.second);
}
TEST(UtilsTest, SplitFirstSingleDelimString)
{
std::pair<std::string, std::string> p{"hello", "world"};
std::string s{"this=isatest"};
vis::Utils::split_first(s, '=', &p);
EXPECT_EQ("this", p.first);
EXPECT_EQ("isatest", p.second);
}
TEST(UtilsTest, SplitFirstMultiDelimString)
{
std::pair<std::string, std::string> p{"hello", "world"};
std::string s{"this=isatest=with=more=than=one=delimiter"};
vis::Utils::split_first(s, '=', &p);
EXPECT_EQ("this", p.first);
EXPECT_EQ("isatest=with=more=than=one=delimiter", p.second);
}
TEST(UtilsTest, SplitEmptyString)
{
std::vector<std::string> v{"hello", "world"};
std::string s{""};
vis::Utils::split(s, '=', &v);
EXPECT_TRUE(v.empty());
}
TEST(UtilsTest, SplitSingleDelimString)
{
std::vector<std::string> v{"hello", "world"};
std::string s{"this=isatest"};
vis::Utils::split(s, '=', &v);
EXPECT_EQ(2, v.size());
EXPECT_EQ("this", v[0]);
EXPECT_EQ("isatest", v[1]);
}
TEST(UtilsTest, SplitMultiDelimString)
{
std::vector<std::string> v{"hello", "world"};
std::string s{"this=isatest=with=more=than=one=delimiter"};
vis::Utils::split(s, '=', &v);
EXPECT_EQ(7, v.size());
EXPECT_EQ("this", v[0]);
EXPECT_EQ("isatest", v[1]);
EXPECT_EQ("with", v[2]);
EXPECT_EQ("more", v[3]);
EXPECT_EQ("than", v[4]);
EXPECT_EQ("one", v[5]);
EXPECT_EQ("delimiter", v[6]);
}
TEST(UtilsTest, ToIntEmptyString)
{
EXPECT_EQ(0, vis::Utils::to_int(""));
}
TEST(UtilsTest, ToIntMinInt)
{
EXPECT_EQ(-2147483648, vis::Utils::to_int("-2147483648"));
}
TEST(UtilsTest, ToIntMaxInt)
{
EXPECT_EQ(2147483647, vis::Utils::to_int("2147483647"));
}
TEST(UtilsTest, ToIntZero)
{
EXPECT_EQ(0, vis::Utils::to_int("0"));
}
TEST(UtilsTest, IsNumericZero)
{
EXPECT_TRUE(vis::Utils::is_numeric("0"));
}
TEST(UtilsTest, IsNumericOne)
{
EXPECT_TRUE(vis::Utils::is_numeric("1"));
}
TEST(UtilsTest, IsNumericNegative)
{
EXPECT_TRUE(vis::Utils::is_numeric("-1"));
}
TEST(UtilsTest, IsNumericMaxInt)
{
EXPECT_TRUE(vis::Utils::is_numeric("2147483647"));
}
TEST(UtilsTest, IsNumericLetter)
{
EXPECT_FALSE(vis::Utils::is_numeric("A"));
}
TEST(UtilsTest, IsNumericWords)
{
EXPECT_FALSE(vis::Utils::is_numeric("hello world"));
}
| 2,900 |
1,444 | <reponame>amc8391/mage
package org.mage.test.cards.single.cmr;
import mage.constants.PhaseStep;
import mage.constants.Zone;
import org.junit.Test;
import org.mage.test.serverside.base.CardTestPlayerBase;
/**
* @author JayDi85
*/
public class EligethCrossroadsAugurTest extends CardTestPlayerBase {
@Test
public void test_Playable() {
removeAllCardsFromLibrary(playerA);
addCard(Zone.LIBRARY, playerA, "Balduvian Bears", 2);
// If you would scry a number of cards, draw that many cards instead.
addCard(Zone.BATTLEFIELD, playerA, "Eligeth, Crossroads Augur", 1);
//
// When Faerie Seer enters the battlefield, scry 2.
addCard(Zone.HAND, playerA, "Faerie Seer", 1); // {U}
addCard(Zone.BATTLEFIELD, playerA, "Island", 1);
// scry multiple cards and draws instead
castSpell(1, PhaseStep.PRECOMBAT_MAIN, playerA, "Faerie Seer");
setStrictChooseMode(true);
setStopAt(1, PhaseStep.END_TURN);
execute();
assertAllCommandsUsed();
assertPermanentCount(playerA, "Faerie Seer", 1);
assertHandCount(playerA, "Balduvian Bears", 2);
}
}
| 480 |
677 | <reponame>brianpos/fhir-server<filename>docs/rest/C4BB/SearchParameters/EOBType.json
{
"resourceType": "SearchParameter",
"id": "explanationofbenefit-type",
"meta": {
"versionId": "1",
"lastUpdated": "2020-03-31T06:41:13.000+00:00"
},
"text": {
"status": "extensions",
"div": "<div xmlns=\"http://www.w3.org/1999/xhtml\"><p><b>Generated Narrative</b></p><p><b>Standards Status</b>: trial-use</p><p><b>url</b>: <code>http://hl7.org/fhir/us/carin-bb/SearchParameter/explanationofbenefit-type</code></p><p><b>version</b>: 1.0.0</p><p><b>name</b>: ExplanationOfBenefit_Type</p><p><b>status</b>: active</p><p><b>experimental</b>: false</p><p><b>date</b>: Mar 31, 2020, 9:48:45 AM</p><p><b>publisher</b>: HL7 Financial Management Working Group</p><p><b>contact</b>: HL7 Financial Management Working Group: <a href=\"http://www.hl7.org/Special/committees/fm/index.cfm\">http://www.hl7.org/Special/committees/fm/index.cfm</a>,<a href=\"mailto:<EMAIL>\"><EMAIL></a></p><p><b>description</b>: The type of the ExplanationOfBenefit</p><p><b>jurisdiction</b>: <span title=\"Codes: {urn:iso:std:iso:3166 US}\">United States of America</span></p><p><b>code</b>: type</p><p><b>base</b>: ExplanationOfBenefit</p><p><b>type</b>: token</p><p><b>expression</b>: ExplanationOfBenefit.type</p><p><b>xpath</b>: f:ExplanationOfBenefit/f:type</p><p><b>xpathUsage</b>: normal</p></div>"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status",
"valueCode": "trial-use"
}
],
"url": "http://hl7.org/fhir/us/carin-bb/SearchParameter/explanationofbenefit-type",
"version": "1.0.0",
"name": "type",
"status": "active",
"experimental": false,
"date": "2020-03-31T19:48:45+10:00",
"publisher": "HL7 Financial Management Working Group",
"contact": [
{
"name": "<NAME>",
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/fm/index.cfm"
},
{
"system": "email",
"value": "<EMAIL>"
}
]
}
],
"description": "The type of the ExplanationOfBenefit",
"jurisdiction": [
{
"coding": [
{
"system": "urn:iso:std:iso:3166",
"code": "US"
}
]
}
],
"code": "type",
"base": [
"ExplanationOfBenefit"
],
"type": "token",
"expression": "ExplanationOfBenefit.type",
"xpath": "f:ExplanationOfBenefit/f:type",
"xpathUsage": "normal"
} | 1,113 |
373 | package com.dianrong.common.uniauth.server.service.common.notify;
/**
* Notify的类型.
*/
public enum NotifyType {
/**
* 添加用户通知.
*/
ADD_USER,
/**
* 系统管理员更新密码通知.
*/
UPDATE_PSWD_ADMIN,
/**
* 自己修改密码通知.
*/
UPDATE_PSWD_SELF;
}
| 182 |
1,056 | /*
* 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.subversion.ui.history;
import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import org.tigris.subversion.svnclientadapter.ISVNLogMessage;
import org.tigris.subversion.svnclientadapter.ISVNLogMessageChangePath;
import org.tigris.subversion.svnclientadapter.SVNClientException;
import org.tigris.subversion.svnclientadapter.SVNRevision.Number;
import org.tigris.subversion.svnclientadapter.SVNUrl;
import java.io.File;
import java.util.*;
import java.util.ArrayList;
import java.util.logging.Level;
import javax.swing.AbstractAction;
import javax.swing.Action;
import org.netbeans.api.progress.ProgressHandle;
import org.netbeans.modules.subversion.Subversion;
import org.netbeans.modules.subversion.client.SvnClient;
import org.netbeans.modules.subversion.client.SvnClientExceptionHandler;
import org.netbeans.modules.subversion.client.SvnProgressSupport;
import org.netbeans.modules.subversion.ui.update.RevertModifications;
import org.netbeans.modules.subversion.ui.update.RevertModificationsAction;
import org.netbeans.modules.subversion.util.Context;
import org.netbeans.modules.subversion.util.SvnUtils;
import org.netbeans.modules.versioning.spi.VersioningSupport;
import org.netbeans.modules.versioning.util.Utils;
import org.openide.filesystems.FileUtil;
import org.openide.util.NbBundle;
import org.tigris.subversion.svnclientadapter.SVNRevision;
/**
* Describes log information for a file. This is the result of doing a
* cvs log command. The fields in instances of this object are populated
* by response handlers.
*
* @author <NAME>
*/
final class RepositoryRevision {
private ISVNLogMessage message;
private SVNUrl repositoryRootUrl;
/**
* List of events associated with the revision.
*/
private final List<Event> events = new ArrayList<Event>(5);
private List<Event> fakeRootEvents;
private boolean eventsInitialized;
private Search currentSearch;
private final PropertyChangeSupport support;
public static final String PROP_EVENTS_CHANGED = "eventsChanged"; //NOI18N
private final File[] selectionRoots;
private final Map<String,File> pathToRoot;
private final Map<String, SVNRevision> pegRevisions;
public RepositoryRevision(ISVNLogMessage message, SVNUrl rootUrl, File[] selectionRoots,
Map<String,File> pathToRoot, Map<String, SVNRevision> pegRevisions) {
this.message = message;
this.repositoryRootUrl = rootUrl;
this.selectionRoots = selectionRoots;
support = new PropertyChangeSupport(this);
this.pathToRoot = pathToRoot;
this.pegRevisions = pegRevisions;
initFakeRootEvent();
}
public SVNUrl getRepositoryRootUrl() {
return repositoryRootUrl;
}
List<Event> getDummyEvents () {
return fakeRootEvents;
}
List<Event> getEvents() {
return events;
}
public ISVNLogMessage getLog() {
return message;
}
@Override
public String toString() {
StringBuilder text = new StringBuilder();
text.append(getLog().getRevision().getNumber());
text.append("\t"); //NOI18N
text.append(getLog().getDate());
text.append("\t"); //NOI18N
text.append(getLog().getAuthor()); // NOI18N
text.append("\n"); // NOI18N
text.append(getLog().getMessage());
return text.toString();
}
public void sort (Comparator<RepositoryRevision.Event> comparator) {
if (events == null) {
return;
}
Collections.sort(events, comparator);
}
boolean expandEvents () {
Search s = currentSearch;
if (s == null && !eventsInitialized) {
currentSearch = new Search();
currentSearch.start(Subversion.getInstance().getRequestProcessor(repositoryRootUrl), repositoryRootUrl, null);
return true;
}
return !eventsInitialized;
}
void cancelExpand () {
Search s = currentSearch;
if (s != null) {
s.cancel();
currentSearch = null;
}
}
boolean isEventsInitialized () {
return eventsInitialized;
}
public void addPropertyChangeListener (String propertyName, PropertyChangeListener listener) {
support.addPropertyChangeListener(propertyName, listener);
}
public void removePropertyChangeListener (String propertyName, PropertyChangeListener listener) {
support.removePropertyChangeListener(propertyName, listener);
}
Action[] getActions () {
List<Action> actions = new ArrayList<Action>();
actions.add(new AbstractAction(NbBundle.getMessage(RepositoryRevision.class, "CTL_SummaryView_RollbackChange")) { //NOI18N
@Override
public void actionPerformed(ActionEvent e) {
SvnProgressSupport support = new SvnProgressSupport() {
@Override
public void perform() {
RevertModifications.RevisionInterval revisionInterval = new RevertModifications.RevisionInterval(getLog().getRevision());
final Context ctx = new Context(selectionRoots);
RevertModificationsAction.performRevert(revisionInterval, false, false, ctx, this);
}
};
support.start(Subversion.getInstance().getRequestProcessor(repositoryRootUrl),
repositoryRootUrl, NbBundle.getMessage(SummaryView.class, "MSG_Revert_Progress")); //NOI18N
}
});
return actions.toArray(new Action[actions.size()]);
}
public class Event {
/**
* The file or folder that this event is about. It may be null if the File cannot be computed.
*/
private File file;
private ISVNLogMessageChangePath changedPath;
private String name;
private String path;
private boolean underRoots;
private File originalFile;
private final String originalPath;
private final String action;
private final String originalName;
private ArrayList<Action> actions;
public Event (ISVNLogMessageChangePath changedPath, boolean underRoots, String displayAction) {
this.changedPath = changedPath;
name = changedPath.getPath().substring(changedPath.getPath().lastIndexOf('/') + 1);
path = changedPath.getPath().substring(0, changedPath.getPath().lastIndexOf('/'));
originalPath = changedPath.getCopySrcPath();
originalName = originalPath == null ? null : originalPath.substring(originalPath.lastIndexOf('/') + 1);
this.underRoots = underRoots;
this.action = displayAction == null ? Character.toString(changedPath.getAction()) : displayAction;
}
public RepositoryRevision getLogInfoHeader() {
return RepositoryRevision.this;
}
public ISVNLogMessageChangePath getChangedPath() {
return changedPath;
}
/** Getter for property file.
* @return Value of property file.
*/
public File getFile() {
return file;
}
/** Setter for property file.
* @param file New value of property file.
*/
public void setFile(File file) {
this.file = file;
}
public File getOriginalFile () {
return originalFile;
}
public void setOriginalFile (File originalFile) {
this.originalFile = originalFile;
}
public String getName() {
return name;
}
public String getPath() {
return path;
}
@Override
public String toString() {
return changedPath.getPath();
}
boolean isUnderRoots () {
return underRoots;
}
String getOriginalPath () {
return originalPath;
}
String getOriginalName () {
return originalName;
}
String getAction() {
return action;
}
@NbBundle.Messages({
"CTL_Action.ViewCurrent.name=View Current"
})
Action[] getActions () {
if (actions == null) {
actions = new ArrayList<Action>();
boolean rollbackToEnabled = getFile() != null && getChangedPath().getAction() != 'D';
boolean rollbackChangeEnabled = getFile() != null && (getChangedPath().getAction() != 'D' || !getFile().exists());
boolean viewEnabled = rollbackToEnabled && !getFile().isDirectory();
if (rollbackChangeEnabled) {
actions.add(new AbstractAction(NbBundle.getMessage(RepositoryRevision.class, "CTL_SummaryView_RollbackChange")) { //NOI18N
@Override
public void actionPerformed(ActionEvent e) {
revert();
}
});
}
if (rollbackToEnabled) {
actions.add(new AbstractAction(NbBundle.getMessage(RepositoryRevision.class, "CTL_SummaryView_RollbackToShort")) { //NOI18N
@Override
public void actionPerformed(ActionEvent e) {
Subversion.getInstance().getParallelRequestProcessor().post(new Runnable() {
@Override
public void run() {
rollback();
}
});
}
});
}
if (viewEnabled) {
actions.add(new AbstractAction(NbBundle.getMessage(RepositoryRevision.class, "CTL_SummaryView_View")) { //NOI18N
@Override
public void actionPerformed(ActionEvent e) {
Subversion.getInstance().getParallelRequestProcessor().post(new Runnable() {
@Override
public void run() {
viewFile(false);
}
});
}
});
actions.add(new AbstractAction(NbBundle.getMessage(RepositoryRevision.class, "CTL_SummaryView_ShowAnnotations")) { //NOI18N
@Override
public void actionPerformed(ActionEvent e) {
Subversion.getInstance().getParallelRequestProcessor().post(new Runnable() {
@Override
public void run() {
viewFile(true);
}
});
}
});
actions.add(new AbstractAction(Bundle.CTL_Action_ViewCurrent_name()) {
@Override
public void actionPerformed(ActionEvent e) {
Subversion.getInstance().getParallelRequestProcessor().post(new Runnable() {
@Override
public void run() {
Utils.openFile(FileUtil.normalizeFile(getFile()));
}
});
}
});
}
}
return actions.toArray(new Action[actions.size()]);
}
void viewFile (boolean showAnnotations) {
File originFile = getFile();
SVNRevision rev = getLogInfoHeader().getLog().getRevision();
SVNUrl repoUrl = getLogInfoHeader().getRepositoryRootUrl();
SVNUrl fileUrl = repoUrl.appendPath(getChangedPath().getPath());
SvnUtils.openInRevision(originFile, repoUrl, fileUrl, rev, rev, showAnnotations);
}
void rollback () {
SvnProgressSupport support = new SvnProgressSupport() {
@Override
public void perform() {
File file = getFile();
boolean wasDeleted = getChangedPath().getAction() == 'D';
SVNUrl repoUrl = getLogInfoHeader().getRepositoryRootUrl();
SVNUrl fileUrl = repoUrl.appendPath(getChangedPath().getPath());
SVNRevision.Number revision = getLogInfoHeader().getLog().getRevision();
SvnUtils.rollback(file, repoUrl, fileUrl, revision, wasDeleted, getLogger());
}
};
support.start(Subversion.getInstance().getRequestProcessor(repositoryRootUrl),
repositoryRootUrl, NbBundle.getMessage(RepositoryRevision.class, "MSG_Rollback_Progress")); //NOI18N
}
void revert () {
SvnProgressSupport support = new SvnProgressSupport() {
@Override
public void perform() {
RevertModifications.RevisionInterval revisionInterval = new RevertModifications.RevisionInterval(getLogInfoHeader().getLog().getRevision());
final Context ctx = new Context(getFile());
RevertModificationsAction.performRevert(revisionInterval, false, false, ctx, this);
}
};
support.start(Subversion.getInstance().getRequestProcessor(repositoryRootUrl),
repositoryRootUrl, NbBundle.getMessage(SummaryView.class, "MSG_Revert_Progress")); //NOI18N
}
}
public static class EventFullNameComparator implements Comparator<Event> {
@Override
public int compare(Event e1, Event e2) {
if (e1 == null || e2 == null || e1.getChangedPath() == null || e2.getChangedPath() == null) {
return 0;
}
return e1.getChangedPath().getPath().compareTo(e2.getChangedPath().getPath());
}
}
public static class EventBaseNameComparator implements Comparator<Event> {
@Override
public int compare(Event e1, Event e2) {
if (e1 == null || e2 == null || e1.getName() == null || e2.getName() == null) {
return 0;
}
return e1.getName().compareTo(e2.getName());
}
}
public void initFakeRootEvent() {
fakeRootEvents = new LinkedList<Event>();
for (final File selectionRoot : selectionRoots) {
Event e = new Event(new ISVNLogMessageChangePath() {
private String path;
@Override
public String getPath() {
if(path == null) {
try {
path = SvnUtils.getRelativePath(selectionRoot);
if (!path.startsWith("/")) { //NOI18B
path = "/" + path; //NOI18B
}
} catch (SVNClientException ex) {
Subversion.LOG.log(Level.INFO, selectionRoot.getAbsolutePath(), ex);
path = "/"; //NOI18B
}
}
return path;
}
@Override
public Number getCopySrcRevision() {
return null;
}
@Override
public String getCopySrcPath() {
return null;
}
@Override
public char getAction() {
return '?';
}
}, true, null);
e.setFile(selectionRoot);
fakeRootEvents.add(e);
}
}
private class Search extends SvnProgressSupport {
@Override
protected void perform () {
try {
SvnClient client = Subversion.getInstance().getClient(repositoryRootUrl, this);
ISVNLogMessage [] messages = new ISVNLogMessage[0];
if (pegRevisions == null) {
// searching URL
messages = client.getLogMessages(repositoryRootUrl, message.getRevision(), message.getRevision());
} else {
// do not call search history for with repo root url, some repositories
// may limit access to the root folder
for (File f : selectionRoots) {
String p = SvnUtils.getRelativePath(f);
if (p != null && p.startsWith("/")) { //NOI18N
p = p.substring(1, p.length());
}
messages = client.getLogMessages(repositoryRootUrl.appendPath(p), pegRevisions.get(p),
message.getRevision(), message.getRevision(), false, true, 0);
if (messages.length > 0) {
break;
}
}
}
if (messages.length > 0) {
final ISVNLogMessage msg = messages[0];
final List<Event> logEvents = prepareEvents(msg);
if (!isCanceled()) {
EventQueue.invokeLater(new Runnable() {
@Override
public void run () {
if (!isCanceled()) {
message = msg;
events.clear();
fakeRootEvents.clear();
events.addAll(logEvents);
eventsInitialized = true;
currentSearch = null;
support.firePropertyChange(RepositoryRevision.PROP_EVENTS_CHANGED, null, new ArrayList<Event>(events));
}
}
});
}
}
} catch (SVNClientException e) {
if (!SvnClientExceptionHandler.handleLogException(repositoryRootUrl, message.getRevision(), e)) {
annotate(e);
}
}
}
@Override
protected void finnishProgress () {
}
@Override
protected void startProgress () {
}
@Override
protected ProgressHandle getProgressHandle () {
return null;
}
private List<Event> prepareEvents (ISVNLogMessage message) {
ISVNLogMessageChangePath [] paths = message.getChangedPaths();
if (paths == null) {
return Collections.<Event>emptyList();
} else {
List<Event> events = new ArrayList<Event>(paths.length);
Set<String> removedPaths = new HashSet<String>(paths.length);
for (ISVNLogMessageChangePath path : paths) {
if (path.getAction() == 'D') {
removedPaths.add(path.getPath());
}
}
for (ISVNLogMessageChangePath path : paths) {
boolean underRoots = false;
File f = computeFile(path.getPath());
if (f != null) {
for (File selectionRoot : selectionRoots) {
if (VersioningSupport.isFlat(selectionRoot)) {
underRoots = selectionRoot.equals(f) || selectionRoot.equals(f.getParentFile());
} else {
underRoots = Utils.isAncestorOrEqual(selectionRoot, f);
}
if (underRoots) {
break;
}
}
}
String action = Character.toString(path.getAction());
if (path.getAction() == 'A' && path.getCopySrcPath() != null) {
if (removedPaths.contains(path.getCopySrcPath())) {
action = "R"; // rename
} else {
action = "C"; // copied
}
}
Event event = new Event(path, underRoots, action);
event.setFile(f);
if (path.getCopySrcPath() != null) {
event.setOriginalFile(computeFile(path.getCopySrcPath()));
}
events.add(event);
}
Collections.sort(events, new EventFullNameComparator());
return events;
}
}
}
private File computeFile(String path) {
for (String s : pathToRoot.keySet()) {
if (path.startsWith(s)) {
return new File(pathToRoot.get(s), path.substring(s.length()));
}
}
return null;
}
}
| 10,989 |
335 | <filename>B/Brittle_noun.json
{
"word": "Brittle",
"definitions": [
"A brittle sweet made from nuts and set melted sugar."
],
"parts-of-speech": "Noun"
} | 76 |
634 | /*
* Copyright 2000-2013 JetBrains s.r.o.
*
* 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.intellij.openapi.actionSystem;
import com.intellij.ide.*;
import com.intellij.openapi.application.ModalityState;
import com.intellij.openapi.fileEditor.FileEditor;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.openapi.wm.StatusBar;
import com.intellij.openapi.wm.ToolWindow;
import com.intellij.ui.content.ContentManager;
import consulo.annotation.DeprecationInfo;
import consulo.disposer.Disposable;
import consulo.util.dataholder.Key;
import java.awt.*;
import java.util.Comparator;
/**
* @author yole
*/
public interface PlatformDataKeys extends CommonDataKeys {
Key<FileEditor> FILE_EDITOR = Key.create("fileEditor");
/**
* Returns the text of currently selected file/file revision
*/
Key<String> FILE_TEXT = Key.create("fileText");
/**
* Returns Boolean.TRUE if action is executed in modal context and
* Boolean.FALSE if action is executed not in modal context. If context
* is unknown then the value of this data constant is <code>null</code>.
*/
Key<Boolean> IS_MODAL_CONTEXT = Key.create("isModalContext");
/**
* Returns help id (String)
*/
Key<String> HELP_ID = Key.create("helpId");
/**
* Returns project if project node is selected (in project view)
*/
Key<Project> PROJECT_CONTEXT = Key.create("context.Project");
/**
* Returns java.awt.Component currently in focus, DataContext should be retrieved for
*/
@Deprecated
@DeprecationInfo("Desktop only")
Key<Component> CONTEXT_COMPONENT = Key.create("contextComponent");
/**
* Returns java.awt.Component currently in focus, DataContext should be retrieved for
*/
Key<consulo.ui.Component> CONTEXT_UI_COMPONENT = Key.create("contextUIComponent");
Key<CopyProvider> COPY_PROVIDER = Key.create("copyProvider");
Key<CutProvider> CUT_PROVIDER = Key.create("cutProvider");
Key<PasteProvider> PASTE_PROVIDER = Key.create("pasteProvider");
Key<DeleteProvider> DELETE_ELEMENT_PROVIDER = Key.create("deleteElementProvider");
Key<Object> SELECTED_ITEM = Key.create("selectedItem");
Key<Object[]> SELECTED_ITEMS = Key.create("selectedItems");
Key<Rectangle> DOMINANT_HINT_AREA_RECTANGLE = Key.create("dominant.hint.rectangle");
Key<ContentManager> CONTENT_MANAGER = Key.create("contentManager");
Key<ToolWindow> TOOL_WINDOW = Key.create("TOOL_WINDOW");
Key<StatusBar> STATUS_BAR = Key.create("STATUS_BAR");
Key<TreeExpander> TREE_EXPANDER = Key.create("treeExpander");
Key<ExporterToTextFile> EXPORTER_TO_TEXT_FILE = Key.create("exporterToTextFile");
Key<VirtualFile> PROJECT_FILE_DIRECTORY = Key.create("context.ProjectFileDirectory");
Key<Disposable> UI_DISPOSABLE = Key.create("ui.disposable");
Key<ContentManager> NONEMPTY_CONTENT_MANAGER = Key.create("nonemptyContentManager");
Key<ModalityState> MODALITY_STATE = Key.create("ModalityState");
Key<Boolean> SOURCE_NAVIGATION_LOCKED = Key.create("sourceNavigationLocked");
Key<String> PREDEFINED_TEXT = Key.create("predefined.text.value");
Key<Object> SPEED_SEARCH_COMPONENT = Key.create("speed.search.component.value");
Key<String> SEARCH_INPUT_TEXT = Key.create("search.input.text.value");
/**
* Returns java.awt.Point to guess where to show context menu invoked by key.
* This point should be relative to the currently focused component
*/
Key<Point> CONTEXT_MENU_POINT = Key.create("contextMenuPoint");
/**
* It's allowed to assign multiple actions to the same keyboard shortcut. Actions system filters them on the current
* context basis during processing (e.g. we can have two actions assigned to the same shortcut but one of them is
* configured to be inapplicable in modal dialog context).
* <p/>
* However, there is a possible case that there is still more than one action applicable for particular keyboard shortcut
* after filtering. The first one is executed then. Hence, actions processing order becomes very important.
* <p/>
* Current key allows to specify custom actions sorter to use if any. I.e. every component can define it's custom
* sorting rule in order to define priorities for target actions (classes of actions).
*
* @deprecated use com.intellij.openapi.actionSystem.ActionPromoter
*/
@Deprecated
Key<Comparator<? super AnAction>> ACTIONS_SORTER = Key.create("actionsSorter");
}
| 1,521 |
2,027 | from peewee import OperationalError
from data.database import validate_database_precondition
from util.config.validators import BaseValidator, ConfigValidationException
class DatabaseValidator(BaseValidator):
name = "database"
@classmethod
def validate(cls, validator_context):
"""
Validates connecting to the database.
"""
config = validator_context.config
try:
validate_database_precondition(config["DB_URI"], config.get("DB_CONNECTION_ARGS", {}))
except OperationalError as ex:
if ex.args and len(ex.args) > 1:
raise ConfigValidationException(ex.args[1])
else:
raise ex
| 281 |
376 | // Copyright (C) 2017 <NAME>
// This file is part of the "Nazara Development Kit"
// For conditions of distribution and use, see copyright notice in Prerequisites.hpp
#include <Nazara/Widgets/LabelWidget.hpp>
namespace Nz
{
inline void LabelWidget::UpdateText(const Nz::AbstractTextDrawer& drawer, float scale)
{
m_textSprite->Update(drawer, scale);
Nz::Vector2f size = Nz::Vector2f(m_textSprite->GetAABB().GetLengths());
SetMinimumSize(size);
SetPreferredSize(size);
}
}
| 167 |
3,387 | <reponame>ogaoga/fb-mac-messenger
#import <WebKit/WebKit.h>
@interface WebView (MacMessengerPrivate)
- (IBAction)zoomPageIn:(id)sender;
- (BOOL)canZoomPageIn;
- (IBAction)zoomPageOut:(id)sender;
- (BOOL)canZoomPageOut;
- (IBAction)resetPageZoom:(id)sender;
- (BOOL)canResetPageZoom;
@end
| 132 |
335 | {
"word": "Thrift",
"definitions": [
"The quality of using money and other resources carefully and not wastefully.",
"A European plant which forms low-growing tufts of slender leaves with rounded pink flower heads, growing chiefly on sea cliffs and mountains."
],
"parts-of-speech": "Noun"
} | 102 |
3,066 | /*
* Licensed to Crate.io GmbH ("Crate") under one or more contributor
* license agreements. See the NOTICE file distributed with this work for
* additional information regarding copyright ownership. Crate 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.
*
* However, if you have executed another commercial license agreement
* with Crate these terms will supersede the license and you may use the
* software solely pursuant to the terms of the relevant commercial agreement.
*/
package io.crate.integrationtests;
import org.junit.Test;
import static io.crate.testing.TestingHelpers.printedTable;
import static org.hamcrest.Matchers.is;
public class ArraySubQueryIntegrationTest extends SQLIntegrationTestCase {
private Setup setup = new Setup(sqlExecutor);
@Test
public void testSubQueryInSelectList() throws Exception {
execute("select mountain, height , " +
"array(select height from sys.summits where country = 'AT' order by height desc limit 5) as array_top5_at_mountains " +
"from sys.summits " +
"where country = 'AT' " +
"order by height desc " +
"limit 5");
assertThat(printedTable(response.rows()),
is("Großglockner| 3798| [3798, 3770, 3666, 3564, 3550]\n" +
"Wildspitze| 3770| [3798, 3770, 3666, 3564, 3550]\n" +
"Großvenediger| 3666| [3798, 3770, 3666, 3564, 3550]\n" +
"Großes Wiesbachhorn| 3564| [3798, 3770, 3666, 3564, 3550]\n" +
"Großer Ramolkogel| 3550| [3798, 3770, 3666, 3564, 3550]\n"));
}
@Test
public void testSubQueryInWhereClause() throws Exception {
execute("select mountain, height " +
"from sys.summits " +
"where country = 'AT' " +
"and [3798, 3770] = array(select height from sys.summits where country = 'AT' order by height desc limit 2) " +
"order by height desc " +
"limit 5");
assertThat(printedTable(response.rows()),
is("Großglockner| 3798\n" +
"Wildspitze| 3770\n" +
"Großvenediger| 3666\n" +
"Großes Wiesbachhorn| 3564\n" +
"Großer Ramolkogel| 3550\n"));
}
}
| 1,087 |
491 | <reponame>jinyouzhi/Forward
# -*- coding: utf-8 -*-
# Copyright (C) 2021 THL A29 Limited, a Tencent company. 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.
#
# ╔════════════════════════════════════════════════════════════════════════════════════════╗
# ║──█████████╗───███████╗───████████╗───██╗──────██╗───███████╗───████████╗───████████╗───║
# ║──██╔══════╝──██╔════██╗──██╔════██╗──██║──────██║──██╔════██╗──██╔════██╗──██╔════██╗──║
# ║──████████╗───██║────██║──████████╔╝──██║──█╗──██║──█████████║──████████╔╝──██║────██║──║
# ║──██╔═════╝───██║────██║──██╔════██╗──██║█████╗██║──██╔════██║──██╔════██╗──██║────██║──║
# ║──██║─────────╚███████╔╝──██║────██║──╚████╔████╔╝──██║────██║──██║────██║──████████╔╝──║
# ║──╚═╝──────────╚══════╝───╚═╝────╚═╝───╚═══╝╚═══╝───╚═╝────╚═╝──╚═╝────╚═╝──╚═══════╝───║
# ╚════════════════════════════════════════════════════════════════════════════════════════╝
#
# Authors: <NAME> (<EMAIL>)
# Yzx (<EMAIL>)
# <NAME> (<EMAIL>)
# <NAME> (<EMAIL>)
import os
import tensorflow as tf
import tensorflow.keras as keras
from tensorflow.python.framework.graph_util import convert_variables_to_constants
from tensorflow.keras import backend as K
import modeling
K.set_learning_phase(0)
def freeze_session(session,
keep_var_names=None,
output_names=None,
clear_devices=True):
"""
Freezes the state of a session into a pruned computation graph.
Creates a new computation graph where variable nodes are replaced by
constants taking their current value in the session. The new graph will be
pruned so subgraphs that are not necessary to compute the requested
outputs are removed.
@param session The TensorFlow session to be frozen.
@param keep_var_names A list of variable names that should not be frozen,
or None to freeze all the variables in the graph.
@param output_names Names of the relevant graph outputs.
@param clear_devices Remove the device directives from the graph for better portability.
@return The frozen graph definition.
"""
print(output_names)
graph = session.graph
with graph.as_default():
freeze_var_names = list(
set(v.op.name
for v in tf.global_variables()).difference(keep_var_names
or []))
output_names = output_names or []
# output_names += [v.op.name for v in tf.global_variables()]
# Graph -> GraphDef ProtoBuf
input_graph_def = graph.as_graph_def()
if clear_devices:
for node in input_graph_def.node:
node.device = ""
frozen_graph = convert_variables_to_constants(session, input_graph_def,
output_names,
freeze_var_names)
return frozen_graph
# export bert model
def main():
bert_dir = "tiny_bert"
pathname = os.path.join(bert_dir, "bert_model.ckpt") # 模型地址
bert_config = modeling.BertConfig.from_json_file(
os.path.join(bert_dir, "bert_config.json")) # 配置文件地址
configsession = tf.ConfigProto()
configsession.gpu_options.allow_growth = True
sess = tf.Session(config=configsession)
input_ids = tf.placeholder(shape=[None, 64],
dtype=tf.int32,
name="input_ids")
input_mask = tf.placeholder(shape=[None, 64],
dtype=tf.int32,
name="input_mask")
segment_ids = tf.placeholder(shape=[None, 64],
dtype=tf.int32,
name="segment_ids")
with sess.as_default():
model = modeling.BertModel(config=bert_config,
is_training=False,
input_ids=input_ids,
input_mask=input_mask,
token_type_ids=segment_ids,
use_one_hot_embeddings=True)
saver = tf.train.Saver()
# 这里尤其注意，先初始化，在加载参数，否者会把bert的参数重新初始化。这里和demo1是有区别的
sess.run(tf.global_variables_initializer())
saver.restore(sess, pathname)
# frozen_graph = freeze_session(sess, output_names=['bert/encoder/Reshape_3'])
frozen_graph = freeze_session(sess,
output_names=['bert/pooler/dense/Tanh'])
# Save
tf.train.write_graph(frozen_graph, ".", "tiny_bert.pb", as_text=False)
if __name__ == "__main__":
main()
| 2,646 |
507 | <gh_stars>100-1000
# terrascript/data/sdm.py
# Automatically generated by tools/makecode.py (24-Sep-2021 15:26:26 UTC)
#
# For imports without namespace, e.g.
#
# >>> import terrascript.data.sdm
#
# instead of
#
# >>> import terrascript.data.strongdm.sdm
#
# This is only available for 'official' and 'partner' providers.
from terrascript.data.strongdm.sdm import *
| 132 |
2,229 | <gh_stars>1000+
{
"name": "gitlet",
"description": "Git implemented in JavaScript.",
"author": "<NAME> <<EMAIL>> (http://maryrosecook.com/)",
"version": "0.1.20",
"repository": {
"type": "git",
"url": "https://github.com/maryrosecook/gitlet.git"
},
"main": "./gitlet.js",
"bin": {
"gitlet": "./gitlet.js"
},
"scripts": {
"test": "jasmine-node spec"
},
"devDependencies": {
"jasmine-node": "1.14.5"
}
}
| 201 |
4,054 | <filename>searchlib/src/vespa/searchlib/expression/floatresultnode.h<gh_stars>1000+
// Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
#pragma once
#include "numericresultnode.h"
#include <vespa/vespalib/util/sort.h>
namespace search {
namespace expression {
class FloatResultNode final : public NumericResultNode
{
public:
DECLARE_EXPRESSIONNODE(FloatResultNode);
DECLARE_NBO_SERIALIZE;
void visitMembers(vespalib::ObjectVisitor &visitor) const override;
FloatResultNode(double v=0) : _value(v) { }
size_t hash() const override { size_t tmpHash(0); memcpy(&tmpHash, &_value, sizeof(tmpHash)); return tmpHash; }
int onCmp(const Identifiable & b) const override;
void add(const ResultNode & b) override;
void negate() override;
void multiply(const ResultNode & b) override;
void divide(const ResultNode & b) override;
void modulo(const ResultNode & b) override;
void min(const ResultNode & b) override;
void max(const ResultNode & b) override;
void set(const ResultNode & rhs) override;
double get() const { return _value; }
void set(double value) { _value = value; }
const BucketResultNode& getNullBucket() const override;
private:
int cmpMem(const void * a, const void *b) const override {
const double & ai(*static_cast<const double *>(a));
const double & bi(*static_cast<const double *>(b));
return ai < bi ? -1 : ai == bi ? 0 : 1;
}
void create(void * buf) const override { (void) buf; }
void destroy(void * buf) const override { (void) buf; }
void decode(const void * buf) override { _value = *static_cast<const double *>(buf); }
void encode(void * buf) const override { *static_cast<double *>(buf) = _value; }
void swap(void * buf) override { std::swap(*static_cast<double *>(buf), _value); }
size_t hash(const void * buf) const override { size_t tmpHash(0); memcpy(&tmpHash, buf, sizeof(tmpHash)); return tmpHash; }
uint64_t radixAsc(const void * buf) const override { return vespalib::convertForSort<double, true>::convert(*static_cast<const double *>(buf)); }
uint64_t radixDesc(const void * buf) const override { return vespalib::convertForSort<double, false>::convert(*static_cast<const double *>(buf)); }
size_t onGetRawByteSize() const override { return sizeof(_value); }
bool isNan() const;
void setMin() override;
void setMax() override;
int64_t onGetInteger(size_t index) const override;
double onGetFloat(size_t index) const override;
ConstBufferRef onGetString(size_t index, BufferRef buf) const override;
double _value;
};
}
}
| 930 |
432 | /* $NetBSD: import_vsn1.c,v 1.1.1.2 2009/12/02 00:26:30 haad Exp $ */
/*
* Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
* Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved.
*
* This file is part of LVM2.
*
* This copyrighted material is made available to anyone wishing to use,
* modify, copy, or redistribute it subject to the terms and conditions
* of the GNU Lesser General Public License v.2.1.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "lib.h"
#include "metadata.h"
#include "import-export.h"
#include "display.h"
#include "toolcontext.h"
#include "lvmcache.h"
#include "lv_alloc.h"
#include "pv_alloc.h"
#include "segtype.h"
#include "text_import.h"
typedef int (*section_fn) (struct format_instance * fid, struct dm_pool * mem,
struct volume_group * vg, struct config_node * pvn,
struct config_node * vgn,
struct dm_hash_table * pv_hash);
#define _read_int32(root, path, result) \
get_config_uint32(root, path, (uint32_t *) result)
#define _read_uint32(root, path, result) \
get_config_uint32(root, path, result)
#define _read_int64(root, path, result) \
get_config_uint64(root, path, result)
/*
* Logs an attempt to read an invalid format file.
*/
static void _invalid_format(const char *str)
{
log_error("Can't process text format file - %s.", str);
}
/*
* Checks that the config file contains vg metadata, and that it
* we recognise the version number,
*/
static int _check_version(struct config_tree *cft)
{
struct config_node *cn;
struct config_value *cv;
/*
* Check the contents field.
*/
if (!(cn = find_config_node(cft->root, CONTENTS_FIELD))) {
_invalid_format("missing contents field");
return 0;
}
cv = cn->v;
if (!cv || cv->type != CFG_STRING || strcmp(cv->v.str, CONTENTS_VALUE)) {
_invalid_format("unrecognised contents field");
return 0;
}
/*
* Check the version number.
*/
if (!(cn = find_config_node(cft->root, FORMAT_VERSION_FIELD))) {
_invalid_format("missing version number");
return 0;
}
cv = cn->v;
if (!cv || cv->type != CFG_INT || cv->v.i != FORMAT_VERSION_VALUE) {
_invalid_format("unrecognised version number");
return 0;
}
return 1;
}
static int _is_converting(struct logical_volume *lv)
{
struct lv_segment *seg;
if (lv->status & MIRRORED) {
seg = first_seg(lv);
/* Can't use is_temporary_mirror() because the metadata for
* seg_lv may not be read in and flags may not be set yet. */
if (seg_type(seg, 0) == AREA_LV &&
strstr(seg_lv(seg, 0)->name, MIRROR_SYNC_LAYER))
return 1;
}
return 0;
}
static int _read_id(struct id *id, struct config_node *cn, const char *path)
{
struct config_value *cv;
if (!(cn = find_config_node(cn, path))) {
log_error("Couldn't find uuid.");
return 0;
}
cv = cn->v;
if (!cv || !cv->v.str) {
log_error("uuid must be a string.");
return 0;
}
if (!id_read_format(id, cv->v.str)) {
log_error("Invalid uuid.");
return 0;
}
return 1;
}
static int _read_flag_config(struct config_node *n, uint32_t *status, int type)
{
struct config_node *cn;
*status = 0;
if (!(cn = find_config_node(n, "status"))) {
log_error("Could not find status flags.");
return 0;
}
if (!(read_flags(status, type | STATUS_FLAG, cn->v))) {
log_error("Could not read status flags.");
return 0;
}
if ((cn = find_config_node(n, "flags"))) {
if (!(read_flags(status, type, cn->v))) {
log_error("Could not read flags.");
return 0;
}
}
return 1;
}
static int _read_pv(struct format_instance *fid, struct dm_pool *mem,
struct volume_group *vg, struct config_node *pvn,
struct config_node *vgn __attribute((unused)),
struct dm_hash_table *pv_hash)
{
struct physical_volume *pv;
struct pv_list *pvl;
struct config_node *cn;
uint64_t size;
if (!(pvl = dm_pool_zalloc(mem, sizeof(*pvl))) ||
!(pvl->pv = dm_pool_zalloc(mem, sizeof(*pvl->pv))))
return_0;
pv = pvl->pv;
/*
* Add the pv to the pv hash for quick lookup when we read
* the lv segments.
*/
if (!dm_hash_insert(pv_hash, pvn->key, pv))
return_0;
if (!(pvn = pvn->child)) {
log_error("Empty pv section.");
return 0;
}
if (!_read_id(&pv->id, pvn, "id")) {
log_error("Couldn't read uuid for physical volume.");
return 0;
}
/*
* Convert the uuid into a device.
*/
if (!(pv->dev = device_from_pvid(fid->fmt->cmd, &pv->id))) {
char buffer[64] __attribute((aligned(8)));
if (!id_write_format(&pv->id, buffer, sizeof(buffer)))
log_error("Couldn't find device.");
else
log_error("Couldn't find device with uuid '%s'.",
buffer);
}
if (!(pv->vg_name = dm_pool_strdup(mem, vg->name)))
return_0;
memcpy(&pv->vgid, &vg->id, sizeof(vg->id));
if (!_read_flag_config(pvn, &pv->status, PV_FLAGS)) {
log_error("Couldn't read status flags for physical volume.");
return 0;
}
if (!pv->dev)
pv->status |= MISSING_PV;
/* Late addition */
_read_int64(pvn, "dev_size", &pv->size);
if (!_read_int64(pvn, "pe_start", &pv->pe_start)) {
log_error("Couldn't read extent size for physical volume.");
return 0;
}
if (!_read_int32(pvn, "pe_count", &pv->pe_count)) {
log_error("Couldn't find extent count (pe_count) for "
"physical volume.");
return 0;
}
dm_list_init(&pv->tags);
dm_list_init(&pv->segments);
/* Optional tags */
if ((cn = find_config_node(pvn, "tags")) &&
!(read_tags(mem, &pv->tags, cn->v))) {
log_error("Couldn't read tags for physical volume %s in %s.",
pv_dev_name(pv), vg->name);
return 0;
}
/* adjust the volume group. */
vg->extent_count += pv->pe_count;
vg->free_count += pv->pe_count;
pv->pe_size = vg->extent_size;
pv->pe_alloc_count = 0;
pv->pe_align = 0;
pv->fmt = fid->fmt;
/* Fix up pv size if missing or impossibly large */
if ((!pv->size || pv->size > (1ULL << 62)) && pv->dev) {
if (!dev_get_size(pv->dev, &pv->size)) {
log_error("%s: Couldn't get size.", pv_dev_name(pv));
return 0;
}
log_verbose("Fixing up missing size (%s) "
"for PV %s", display_size(fid->fmt->cmd, pv->size),
pv_dev_name(pv));
if (vg) {
size = pv->pe_count * (uint64_t) vg->extent_size +
pv->pe_start;
if (size > pv->size)
log_error("WARNING: Physical Volume %s is too "
"large for underlying device",
pv_dev_name(pv));
}
}
if (!alloc_pv_segment_whole_pv(mem, pv))
return_0;
vg->pv_count++;
dm_list_add(&vg->pvs, &pvl->list);
return 1;
}
static void _insert_segment(struct logical_volume *lv, struct lv_segment *seg)
{
struct lv_segment *comp;
dm_list_iterate_items(comp, &lv->segments) {
if (comp->le > seg->le) {
dm_list_add(&comp->list, &seg->list);
return;
}
}
lv->le_count += seg->len;
dm_list_add(&lv->segments, &seg->list);
}
static int _read_segment(struct dm_pool *mem, struct volume_group *vg,
struct logical_volume *lv, struct config_node *sn,
struct dm_hash_table *pv_hash)
{
uint32_t area_count = 0u;
struct lv_segment *seg;
struct config_node *cn, *sn_child = sn->child;
struct config_value *cv;
uint32_t start_extent, extent_count;
struct segment_type *segtype;
const char *segtype_str;
if (!sn_child) {
log_error("Empty segment section.");
return 0;
}
if (!_read_int32(sn_child, "start_extent", &start_extent)) {
log_error("Couldn't read 'start_extent' for segment '%s' "
"of logical volume %s.", sn->key, lv->name);
return 0;
}
if (!_read_int32(sn_child, "extent_count", &extent_count)) {
log_error("Couldn't read 'extent_count' for segment '%s' "
"of logical volume %s.", sn->key, lv->name);
return 0;
}
segtype_str = "striped";
if ((cn = find_config_node(sn_child, "type"))) {
cv = cn->v;
if (!cv || !cv->v.str) {
log_error("Segment type must be a string.");
return 0;
}
segtype_str = cv->v.str;
}
if (!(segtype = get_segtype_from_string(vg->cmd, segtype_str)))
return_0;
if (segtype->ops->text_import_area_count &&
!segtype->ops->text_import_area_count(sn_child, &area_count))
return_0;
if (!(seg = alloc_lv_segment(mem, segtype, lv, start_extent,
extent_count, 0, 0, NULL, area_count,
extent_count, 0, 0, 0))) {
log_error("Segment allocation failed");
return 0;
}
if (seg->segtype->ops->text_import &&
!seg->segtype->ops->text_import(seg, sn_child, pv_hash))
return_0;
/* Optional tags */
if ((cn = find_config_node(sn_child, "tags")) &&
!(read_tags(mem, &seg->tags, cn->v))) {
log_error("Couldn't read tags for a segment of %s/%s.",
vg->name, lv->name);
return 0;
}
/*
* Insert into correct part of segment list.
*/
_insert_segment(lv, seg);
if (seg_is_mirrored(seg))
lv->status |= MIRRORED;
if (seg_is_virtual(seg))
lv->status |= VIRTUAL;
if (_is_converting(lv))
lv->status |= CONVERTING;
return 1;
}
int text_import_areas(struct lv_segment *seg, const struct config_node *sn,
const struct config_node *cn, struct dm_hash_table *pv_hash,
uint32_t flags)
{
unsigned int s;
struct config_value *cv;
struct logical_volume *lv1;
struct physical_volume *pv;
const char *seg_name = config_parent_name(sn);
if (!seg->area_count) {
log_error("Zero areas not allowed for segment %s", seg_name);
return 0;
}
for (cv = cn->v, s = 0; cv && s < seg->area_count; s++, cv = cv->next) {
/* first we read the pv */
if (cv->type != CFG_STRING) {
log_error("Bad volume name in areas array for segment %s.", seg_name);
return 0;
}
if (!cv->next) {
log_error("Missing offset in areas array for segment %s.", seg_name);
return 0;
}
if (cv->next->type != CFG_INT) {
log_error("Bad offset in areas array for segment %s.", seg_name);
return 0;
}
/* FIXME Cope if LV not yet read in */
if ((pv = dm_hash_lookup(pv_hash, cv->v.str))) {
if (!set_lv_segment_area_pv(seg, s, pv, (uint32_t) cv->next->v.i))
return_0;
} else if ((lv1 = find_lv(seg->lv->vg, cv->v.str))) {
if (!set_lv_segment_area_lv(seg, s, lv1,
(uint32_t) cv->next->v.i,
flags))
return_0;
} else {
log_error("Couldn't find volume '%s' "
"for segment '%s'.",
cv->v.str ? : "NULL", seg_name);
return 0;
}
cv = cv->next;
}
/*
* Check we read the correct number of stripes.
*/
if (cv || (s < seg->area_count)) {
log_error("Incorrect number of areas in area array "
"for segment '%s'.", seg_name);
return 0;
}
return 1;
}
static int _read_segments(struct dm_pool *mem, struct volume_group *vg,
struct logical_volume *lv, struct config_node *lvn,
struct dm_hash_table *pv_hash)
{
struct config_node *sn;
int count = 0, seg_count;
for (sn = lvn; sn; sn = sn->sib) {
/*
* All sub-sections are assumed to be segments.
*/
if (!sn->v) {
if (!_read_segment(mem, vg, lv, sn, pv_hash))
return_0;
count++;
}
/* FIXME Remove this restriction */
if ((lv->status & SNAPSHOT) && count > 1) {
log_error("Only one segment permitted for snapshot");
return 0;
}
}
if (!_read_int32(lvn, "segment_count", &seg_count)) {
log_error("Couldn't read segment count for logical volume %s.",
lv->name);
return 0;
}
if (seg_count != count) {
log_error("segment_count and actual number of segments "
"disagree for logical volume %s.", lv->name);
return 0;
}
/*
* Check there are no gaps or overlaps in the lv.
*/
if (!check_lv_segments(lv, 0))
return_0;
/*
* Merge segments in case someones been editing things by hand.
*/
if (!lv_merge_segments(lv))
return_0;
return 1;
}
static int _read_lvnames(struct format_instance *fid __attribute((unused)),
struct dm_pool *mem,
struct volume_group *vg, struct config_node *lvn,
struct config_node *vgn __attribute((unused)),
struct dm_hash_table *pv_hash __attribute((unused)))
{
struct logical_volume *lv;
struct config_node *cn;
if (!(lv = alloc_lv(mem)))
return_0;
if (!(lv->name = dm_pool_strdup(mem, lvn->key)))
return_0;
if (!(lvn = lvn->child)) {
log_error("Empty logical volume section.");
return 0;
}
if (!_read_flag_config(lvn, &lv->status, LV_FLAGS)) {
log_error("Couldn't read status flags for logical volume %s.",
lv->name);
return 0;
}
lv->alloc = ALLOC_INHERIT;
if ((cn = find_config_node(lvn, "allocation_policy"))) {
struct config_value *cv = cn->v;
if (!cv || !cv->v.str) {
log_error("allocation_policy must be a string.");
return 0;
}
lv->alloc = get_alloc_from_string(cv->v.str);
if (lv->alloc == ALLOC_INVALID)
return_0;
}
if (!_read_int32(lvn, "read_ahead", &lv->read_ahead))
/* If not present, choice of auto or none is configurable */
lv->read_ahead = vg->cmd->default_settings.read_ahead;
else {
switch (lv->read_ahead) {
case 0:
lv->read_ahead = DM_READ_AHEAD_AUTO;
break;
case (uint32_t) -1:
lv->read_ahead = DM_READ_AHEAD_NONE;
break;
default:
;
}
}
/* Optional tags */
if ((cn = find_config_node(lvn, "tags")) &&
!(read_tags(mem, &lv->tags, cn->v))) {
log_error("Couldn't read tags for logical volume %s/%s.",
vg->name, lv->name);
return 0;
}
return link_lv_to_vg(vg, lv);
}
static int _read_lvsegs(struct format_instance *fid __attribute((unused)),
struct dm_pool *mem,
struct volume_group *vg, struct config_node *lvn,
struct config_node *vgn __attribute((unused)),
struct dm_hash_table *pv_hash)
{
struct logical_volume *lv;
struct lv_list *lvl;
if (!(lvl = find_lv_in_vg(vg, lvn->key))) {
log_error("Lost logical volume reference %s", lvn->key);
return 0;
}
lv = lvl->lv;
if (!(lvn = lvn->child)) {
log_error("Empty logical volume section.");
return 0;
}
/* FIXME: read full lvid */
if (!_read_id(&lv->lvid.id[1], lvn, "id")) {
log_error("Couldn't read uuid for logical volume %s.",
lv->name);
return 0;
}
memcpy(&lv->lvid.id[0], &lv->vg->id, sizeof(lv->lvid.id[0]));
if (!_read_segments(mem, vg, lv, lvn, pv_hash))
return_0;
lv->size = (uint64_t) lv->le_count * (uint64_t) vg->extent_size;
lv->minor = -1;
if ((lv->status & FIXED_MINOR) &&
!_read_int32(lvn, "minor", &lv->minor)) {
log_error("Couldn't read minor number for logical "
"volume %s.", lv->name);
return 0;
}
lv->major = -1;
if ((lv->status & FIXED_MINOR) &&
!_read_int32(lvn, "major", &lv->major)) {
log_error("Couldn't read major number for logical "
"volume %s.", lv->name);
}
return 1;
}
static int _read_sections(struct format_instance *fid,
const char *section, section_fn fn,
struct dm_pool *mem,
struct volume_group *vg, struct config_node *vgn,
struct dm_hash_table *pv_hash, int optional)
{
struct config_node *n;
if (!(n = find_config_node(vgn, section))) {
if (!optional) {
log_error("Couldn't find section '%s'.", section);
return 0;
}
return 1;
}
for (n = n->child; n; n = n->sib) {
if (!fn(fid, mem, vg, n, vgn, pv_hash))
return_0;
}
return 1;
}
static struct volume_group *_read_vg(struct format_instance *fid,
struct config_tree *cft)
{
struct config_node *vgn, *cn;
struct volume_group *vg;
struct dm_hash_table *pv_hash = NULL;
struct dm_pool *mem = dm_pool_create("lvm2 vg_read", VG_MEMPOOL_CHUNK);
if (!mem)
return_NULL;
/* skip any top-level values */
for (vgn = cft->root; (vgn && vgn->v); vgn = vgn->sib) ;
if (!vgn) {
log_error("Couldn't find volume group in file.");
goto bad;
}
if (!(vg = dm_pool_zalloc(mem, sizeof(*vg))))
goto_bad;
vg->vgmem = mem;
vg->cmd = fid->fmt->cmd;
/* FIXME Determine format type from file contents */
/* eg Set to instance of fmt1 here if reading a format1 backup? */
vg->fid = fid;
if (!(vg->name = dm_pool_strdup(mem, vgn->key)))
goto_bad;
if (!(vg->system_id = dm_pool_zalloc(mem, NAME_LEN)))
goto_bad;
vgn = vgn->child;
if ((cn = find_config_node(vgn, "system_id")) && cn->v) {
if (!cn->v->v.str) {
log_error("system_id must be a string");
goto bad;
}
strncpy(vg->system_id, cn->v->v.str, NAME_LEN);
}
if (!_read_id(&vg->id, vgn, "id")) {
log_error("Couldn't read uuid for volume group %s.", vg->name);
goto bad;
}
if (!_read_int32(vgn, "seqno", &vg->seqno)) {
log_error("Couldn't read 'seqno' for volume group %s.",
vg->name);
goto bad;
}
if (!_read_flag_config(vgn, &vg->status, VG_FLAGS)) {
log_error("Error reading flags of volume group %s.",
vg->name);
goto bad;
}
if (!_read_int32(vgn, "extent_size", &vg->extent_size)) {
log_error("Couldn't read extent size for volume group %s.",
vg->name);
goto bad;
}
/*
* 'extent_count' and 'free_count' get filled in
* implicitly when reading in the pv's and lv's.
*/
if (!_read_int32(vgn, "max_lv", &vg->max_lv)) {
log_error("Couldn't read 'max_lv' for volume group %s.",
vg->name);
goto bad;
}
if (!_read_int32(vgn, "max_pv", &vg->max_pv)) {
log_error("Couldn't read 'max_pv' for volume group %s.",
vg->name);
goto bad;
}
vg->alloc = ALLOC_NORMAL;
if ((cn = find_config_node(vgn, "allocation_policy"))) {
struct config_value *cv = cn->v;
if (!cv || !cv->v.str) {
log_error("allocation_policy must be a string.");
return 0;
}
vg->alloc = get_alloc_from_string(cv->v.str);
if (vg->alloc == ALLOC_INVALID)
return_0;
}
/*
* The pv hash memoises the pv section names -> pv
* structures.
*/
if (!(pv_hash = dm_hash_create(32))) {
log_error("Couldn't create hash table.");
goto bad;
}
dm_list_init(&vg->pvs);
if (!_read_sections(fid, "physical_volumes", _read_pv, mem, vg,
vgn, pv_hash, 0)) {
log_error("Couldn't find all physical volumes for volume "
"group %s.", vg->name);
goto bad;
}
dm_list_init(&vg->lvs);
dm_list_init(&vg->tags);
dm_list_init(&vg->removed_pvs);
/* Optional tags */
if ((cn = find_config_node(vgn, "tags")) &&
!(read_tags(mem, &vg->tags, cn->v))) {
log_error("Couldn't read tags for volume group %s.", vg->name);
goto bad;
}
if (!_read_sections(fid, "logical_volumes", _read_lvnames, mem, vg,
vgn, pv_hash, 1)) {
log_error("Couldn't read all logical volume names for volume "
"group %s.", vg->name);
goto bad;
}
if (!_read_sections(fid, "logical_volumes", _read_lvsegs, mem, vg,
vgn, pv_hash, 1)) {
log_error("Couldn't read all logical volumes for "
"volume group %s.", vg->name);
goto bad;
}
if (!fixup_imported_mirrors(vg)) {
log_error("Failed to fixup mirror pointers after import for "
"volume group %s.", vg->name);
goto bad;
}
dm_hash_destroy(pv_hash);
/*
* Finished.
*/
return vg;
bad:
if (pv_hash)
dm_hash_destroy(pv_hash);
dm_pool_destroy(mem);
return NULL;
}
static void _read_desc(struct dm_pool *mem,
struct config_tree *cft, time_t *when, char **desc)
{
const char *d;
unsigned int u = 0u;
int old_suppress;
old_suppress = log_suppress(1);
d = find_config_str(cft->root, "description", "");
log_suppress(old_suppress);
*desc = dm_pool_strdup(mem, d);
get_config_uint32(cft->root, "creation_time", &u);
*when = u;
}
static const char *_read_vgname(const struct format_type *fmt,
struct config_tree *cft, struct id *vgid,
uint32_t *vgstatus, char **creation_host)
{
struct config_node *vgn;
struct dm_pool *mem = fmt->cmd->mem;
char *vgname;
int old_suppress;
old_suppress = log_suppress(2);
*creation_host = dm_pool_strdup(mem,
find_config_str(cft->root,
"creation_host", ""));
log_suppress(old_suppress);
/* skip any top-level values */
for (vgn = cft->root; (vgn && vgn->v); vgn = vgn->sib) ;
if (!vgn) {
log_error("Couldn't find volume group in file.");
return 0;
}
if (!(vgname = dm_pool_strdup(mem, vgn->key)))
return_0;
vgn = vgn->child;
if (!_read_id(vgid, vgn, "id")) {
log_error("Couldn't read uuid for volume group %s.", vgname);
return 0;
}
if (!_read_flag_config(vgn, vgstatus, VG_FLAGS)) {
log_error("Couldn't find status flags for volume group %s.",
vgname);
return 0;
}
return vgname;
}
static struct text_vg_version_ops _vsn1_ops = {
.check_version = _check_version,
.read_vg = _read_vg,
.read_desc = _read_desc,
.read_vgname = _read_vgname,
};
struct text_vg_version_ops *text_vg_vsn1_init(void)
{
return &_vsn1_ops;
}
| 8,810 |
380 | /*
* oxAuth is available under the MIT License (2008). See http://opensource.org/licenses/MIT for full text.
*
* Copyright (c) 2014, Gluu
*/
package org.gluu.oxauth.model.common;
import java.util.HashMap;
import java.util.Map;
import org.gluu.persist.annotation.AttributeEnum;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonValue;
/**
* @author <NAME>
* @version January 16, 2019
*/
public enum TokenTypeHint implements HasParamName, AttributeEnum {
/**
* An access token as defined in RFC6749, Section 1.4
*/
ACCESS_TOKEN("access_token"),
/**
* A refresh token as defined in RFC6749, Section 1.5
*/
REFRESH_TOKEN("refresh_token");
private final String value;
private static Map<String, TokenTypeHint> mapByValues = new HashMap<String, TokenTypeHint>();
static {
for (TokenTypeHint enumType : values()) {
mapByValues.put(enumType.getValue(), enumType);
}
}
TokenTypeHint(String value) {
this.value = value;
}
/**
* Gets param name.
*
* @return param name
*/
@Override
public String getParamName() {
return value;
}
@Override
public String getValue() {
return value;
}
@JsonCreator
public static TokenTypeHint fromString(String param) {
if (param != null) {
for (TokenTypeHint tth : TokenTypeHint.values()) {
if (param.equals(tth.value)) {
return tth;
}
}
}
return null;
}
public static TokenTypeHint getByValue(String value) {
return mapByValues.get(value);
}
@Override
public Enum<? extends AttributeEnum> resolveByValue(String s) {
return getByValue(value);
}
/**
* Returns a string representation of the object. In this case the parameter
* name for the grant_type parameter.
*
* @return The string representation of the object.
*/
@Override
@JsonValue
public String toString() {
return value;
}
}
| 880 |
387 | /*
* Copyright (C) 2014, United States Government, as represented by the
* Administrator of the National Aeronautics and Space Administration.
* All rights reserved.
*
* The Java Pathfinder core (jpf-core) platform is 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 gov.nasa.jpf.vm;
import gov.nasa.jpf.ListenerAdapter;
import gov.nasa.jpf.annotation.MJI;
import gov.nasa.jpf.jvm.bytecode.JVMReturnInstruction;
import gov.nasa.jpf.vm.ElementInfo;
import gov.nasa.jpf.vm.Instruction;
import gov.nasa.jpf.vm.VM;
import gov.nasa.jpf.vm.MJIEnv;
import gov.nasa.jpf.vm.MethodInfo;
import gov.nasa.jpf.vm.NativePeer;
/**
* native peer for MemoryGoal tests
*/
public class JPF_gov_nasa_jpf_test_MemoryGoal extends NativePeer {
Listener listener;
// <2do> that's too simple, because we should only measure what is
// allocated from the invoked method, not the MethodTester. Needs a listener
static class Listener extends ListenerAdapter {
MethodInfo mi;
boolean active;
long nAllocBytes;
long nFreeBytes;
long nAlloc;
long nFree;
Listener (MethodInfo mi){
this.mi = mi;
}
@Override
public void objectCreated (VM vm, ThreadInfo ti, ElementInfo ei){
if (active){
nAlloc++;
nAllocBytes += ei.getHeapSize(); // just an approximation
}
}
@Override
public void objectReleased (VM vm, ThreadInfo ti, ElementInfo ei){
if (active){
nFree++;
nFreeBytes += ei.getHeapSize(); // just an approximation
}
}
@Override
public void instructionExecuted (VM vm, ThreadInfo ti, Instruction nextInsn, Instruction executedInsn){
if (!active) {
if (executedInsn.getMethodInfo() == mi){
active = true;
}
} else {
if ((executedInsn instanceof JVMReturnInstruction) && (executedInsn.getMethodInfo() == mi)){
active = false;
}
}
}
long totalAllocBytes() {
return nAllocBytes - nFreeBytes;
}
}
@MJI
public boolean preCheck__Lgov_nasa_jpf_test_TestContext_2Ljava_lang_reflect_Method_2__Z
(MJIEnv env, int objRef, int testContextRef, int methodRef){
MethodInfo mi = JPF_java_lang_reflect_Method.getMethodInfo(env, methodRef);
listener = new Listener(mi);
env.addListener(listener);
return true;
}
// what a terrible name!
@MJI
public boolean postCheck__Lgov_nasa_jpf_test_TestContext_2Ljava_lang_reflect_Method_2Ljava_lang_Object_2Ljava_lang_Throwable_2__Z
(MJIEnv env, int objRef, int testContextRef, int methdRef, int resultRef, int exRef){
long nMax = env.getLongField(objRef, "maxGrowth");
Listener l = listener;
env.removeListener(l);
listener = null;
return (l.totalAllocBytes() <= nMax);
}
}
| 1,299 |
459 | <gh_stars>100-1000
// File implement/oglplus/enums/blit_filter_class.ipp
//
// Automatically generated file, DO NOT modify manually.
// Edit the source 'source/enums/oglplus/blit_filter.txt'
// or the 'source/enums/make_enum.py' script instead.
//
// Copyright 2010-2015 <NAME>.
// Distributed under 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
//
namespace enums {
template <typename Base, template<BlitFilter> class Transform>
class EnumToClass<Base, BlitFilter, Transform>
: public Base
{
private:
Base& _base(void) { return *this; }
public:
#if defined GL_NEAREST
# if defined Nearest
# pragma push_macro("Nearest")
# undef Nearest
Transform<BlitFilter::Nearest> Nearest;
# pragma pop_macro("Nearest")
# else
Transform<BlitFilter::Nearest> Nearest;
# endif
#endif
#if defined GL_LINEAR
# if defined Linear
# pragma push_macro("Linear")
# undef Linear
Transform<BlitFilter::Linear> Linear;
# pragma pop_macro("Linear")
# else
Transform<BlitFilter::Linear> Linear;
# endif
#endif
EnumToClass(void) { }
EnumToClass(Base&& base)
: Base(std::move(base))
#if defined GL_NEAREST
# if defined Nearest
# pragma push_macro("Nearest")
# undef Nearest
, Nearest(_base())
# pragma pop_macro("Nearest")
# else
, Nearest(_base())
# endif
#endif
#if defined GL_LINEAR
# if defined Linear
# pragma push_macro("Linear")
# undef Linear
, Linear(_base())
# pragma pop_macro("Linear")
# else
, Linear(_base())
# endif
#endif
{ }
};
} // namespace enums
| 571 |
515 | /*=============================================================================
Library: CTK
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics
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.
=============================================================================*/
#include "ctkManagedServiceFactoryTracker_p.h"
#include <service/cm/ctkConfigurationException.h>
#include <service/log/ctkLogService.h>
#include "ctkConfigurationAdminActivator_p.h"
#include "ctkConfigurationAdminFactory_p.h"
#include "ctkConfigurationStore_p.h"
#include "ctkConfigurationImpl_p.h"
#include <QRunnable>
ctkManagedServiceFactoryTracker::ctkManagedServiceFactoryTracker(
ctkConfigurationAdminFactory* configurationAdminFactory,
ctkConfigurationStore* configurationStore,
ctkPluginContext* context)
: ctkServiceTracker<ctkManagedServiceFactory*>(context),
context(context),
configurationAdminFactory(configurationAdminFactory),
configurationStoreMutex(QMutex::Recursive),
configurationStore(configurationStore),
queue("ctkManagedServiceFactory Update Queue")
{
}
ctkManagedServiceFactory* ctkManagedServiceFactoryTracker::addingService(const ctkServiceReference& reference)
{
QString factoryPid = reference.getProperty(ctkPluginConstants::SERVICE_PID).toString();
if (factoryPid.isEmpty())
return 0;
ctkManagedServiceFactory* service = context->getService<ctkManagedServiceFactory>(reference);
if (service == 0)
return 0;
{
QMutexLocker lock(&configurationStoreMutex);
addManagedServiceFactory(reference, factoryPid, service);
}
return service;
}
void ctkManagedServiceFactoryTracker::modifiedService(const ctkServiceReference& reference,
ctkManagedServiceFactory* service)
{
QString factoryPid = reference.getProperty(ctkPluginConstants::SERVICE_PID).toString();
{
QMutexLocker lock(&configurationStoreMutex);
if (getManagedServiceFactory(factoryPid) == service)
return;
QString previousPid = getPidForManagedServiceFactory(service);
removeManagedServiceFactory(reference, previousPid);
addingService(reference);
}
}
void ctkManagedServiceFactoryTracker::removedService(const ctkServiceReference& reference,
ctkManagedServiceFactory* service)
{
Q_UNUSED(service)
QString factoryPid = reference.getProperty(ctkPluginConstants::SERVICE_PID).toString();
{
QMutexLocker lock(&configurationStoreMutex);
removeManagedServiceFactory(reference, factoryPid);
}
context->ungetService(reference);
}
void ctkManagedServiceFactoryTracker::notifyDeleted(ctkConfigurationImpl* config)
{
config->checkLocked();
QString factoryPid = config->getFactoryPid(false);
ctkServiceReference reference = getManagedServiceFactoryReference(factoryPid);
if (reference && config->bind(reference.getPlugin()))
{
asynchDeleted(getManagedServiceFactory(factoryPid), config->getPid(false));
}
}
void ctkManagedServiceFactoryTracker::notifyUpdated(ctkConfigurationImpl* config)
{
config->checkLocked();
QString factoryPid = config->getFactoryPid();
ctkServiceReference reference = getManagedServiceFactoryReference(factoryPid);
if (reference && config->bind(reference.getPlugin()))
{
ctkDictionary properties = config->getProperties();
configurationAdminFactory->modifyConfiguration(reference, properties);
asynchUpdated(getManagedServiceFactory(factoryPid), config->getPid(), properties);
}
}
void ctkManagedServiceFactoryTracker::addManagedServiceFactory(
const ctkServiceReference& reference, const QString& factoryPid,
ctkManagedServiceFactory* service)
{
QList<ctkConfigurationImplPtr> configs = configurationStore->getFactoryConfigurations(factoryPid);
ctkConfigurationImplLocker lock(configs);
if (trackManagedServiceFactory(factoryPid, reference, service))
{
foreach (ctkConfigurationImplPtr config, configs)
{
if (config->isDeleted())
{
// ignore this config
}
else if (config->bind(reference.getPlugin()))
{
ctkDictionary properties = config->getProperties();
configurationAdminFactory->modifyConfiguration(reference, properties);
asynchUpdated(service, config->getPid(), properties);
}
else
{
CTK_WARN(configurationAdminFactory->getLogService())
<< "Configuration for " << ctkPluginConstants::SERVICE_PID << "="
<< config->getPid() << " could not be bound to "
<< reference.getPlugin()->getLocation();
}
}
}
}
void ctkManagedServiceFactoryTracker::removeManagedServiceFactory(
const ctkServiceReference& reference, const QString& factoryPid)
{
QList<ctkConfigurationImplPtr> configs = configurationStore->getFactoryConfigurations(factoryPid);
ctkConfigurationImplLocker lock(configs);
untrackManagedServiceFactory(factoryPid, reference);
}
bool ctkManagedServiceFactoryTracker::trackManagedServiceFactory(const QString& factoryPid,
const ctkServiceReference& reference,
ctkManagedServiceFactory* service)
{
QMutexLocker lock(&managedServiceFactoryMutex);
if (managedServiceFactoryReferences.contains(factoryPid))
{
CTK_WARN(configurationAdminFactory->getLogService())
<< "ctkManagedServiceFactory already registered for "
<< ctkPluginConstants::SERVICE_PID << "=" << factoryPid;
return false;
}
managedServiceFactoryReferences.insert(factoryPid, reference);
managedServiceFactories.insert(factoryPid, service);
return true;
}
void ctkManagedServiceFactoryTracker::untrackManagedServiceFactory(const QString& factoryPid,
const ctkServiceReference& reference)
{
Q_UNUSED(reference)
QMutexLocker lock(&managedServiceFactoryMutex);
managedServiceFactoryReferences.remove(factoryPid);
managedServiceFactories.remove(factoryPid);
}
ctkManagedServiceFactory* ctkManagedServiceFactoryTracker::getManagedServiceFactory(const QString& factoryPid) const
{
QMutexLocker lock(&managedServiceFactoryMutex);
return managedServiceFactories.value(factoryPid);
}
ctkServiceReference ctkManagedServiceFactoryTracker::getManagedServiceFactoryReference(const QString& factoryPid) const
{
QMutexLocker lock(&managedServiceFactoryMutex);
return managedServiceFactoryReferences.value(factoryPid);
}
QString ctkManagedServiceFactoryTracker::getPidForManagedServiceFactory(ctkManagedServiceFactory* service) const
{
QMutexLocker lock(&managedServiceFactoryMutex);
QHash<QString, ctkManagedServiceFactory*>::ConstIterator end = managedServiceFactories.end();
QHash<QString, ctkManagedServiceFactory*>::ConstIterator it;
for (it = managedServiceFactories.begin(); it != end; ++it)
{
if (it.value() == service)
return it.key();
}
return QString();
}
class _AsynchDeleteRunnable : public QRunnable
{
public:
_AsynchDeleteRunnable(ctkManagedServiceFactory* service, const QString& pid,
ctkLogService* log)
: service(service), pid(pid), log(log)
{
}
void run()
{
try
{
service->deleted(pid);
}
catch (const std::exception* e)
{
CTK_ERROR_EXC(log, e);
}
}
private:
ctkManagedServiceFactory* const service;
const QString pid;
ctkLogService* const log;
};
void ctkManagedServiceFactoryTracker::asynchDeleted(ctkManagedServiceFactory* service, const QString& pid)
{
queue.put(new _AsynchDeleteRunnable(service, pid, configurationAdminFactory->getLogService()));
}
class _AsynchFactoryUpdateRunnable : public QRunnable
{
public:
_AsynchFactoryUpdateRunnable(ctkManagedServiceFactory* service, const QString& pid,
const ctkDictionary& properties, ctkLogService* log)
: service(service), pid(pid), properties(properties), log(log)
{
}
void run()
{
try
{
service->updated(pid, properties);
}
catch (const ctkConfigurationException* e)
{
// we might consider doing more for ConfigurationExceptions
CTK_ERROR_EXC(log, e);
}
catch (const std::exception* e)
{
CTK_ERROR_EXC(log, e);
}
}
private:
ctkManagedServiceFactory* const service;
const QString pid;
const ctkDictionary properties;
ctkLogService* const log;
};
void ctkManagedServiceFactoryTracker::asynchUpdated(ctkManagedServiceFactory* service, const QString& pid,
const ctkDictionary& properties)
{
queue.put(new _AsynchFactoryUpdateRunnable(service, pid, properties, configurationAdminFactory->getLogService()));
}
| 3,234 |
2,003 | // Copyright (c) 2015-2018, Baidu.com, Inc. All Rights Reserved
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <gtest/gtest.h>
#include <gflags/gflags.h>
#include <memory>
#include <string>
#include "access/helpers/permission_builder.h"
DECLARE_string(tera_auth_name);
DECLARE_string(tera_auth_token);
namespace tera {
namespace auth {
namespace test {
static const std::string namespace_name{"sandbox"};
static const std::string table_name{"test"};
static const std::string family{"cf"};
static const std::string qualifier{"qu"};
class PermissionTest : public ::testing::Test {
public:
PermissionTest() {}
virtual ~PermissionTest() {}
};
TEST_F(PermissionTest, GlobalPermissionBuilderTest) {
std::unique_ptr<Permission> global_permission(
PermissionBuilder::NewPermission(Permission::kRead));
EXPECT_TRUE(global_permission->type() == Permission::kGlobal);
std::unique_ptr<Permission> nullptr_permission(
PermissionBuilder::NewPermission(static_cast<Permission::Action>(5)));
EXPECT_TRUE(!nullptr_permission);
}
TEST_F(PermissionTest, NamespacePermissionBuilderTest) {
std::unique_ptr<Permission> namespace_permission(
PermissionBuilder::NewPermission(Permission::kRead, namespace_name));
EXPECT_TRUE(namespace_permission->type() == Permission::kNamespace);
EXPECT_TRUE(namespace_permission->namespace_permission().namespace_name() == namespace_name);
std::unique_ptr<Permission> nullptr_permission(
PermissionBuilder::NewPermission(static_cast<Permission::Action>(5), namespace_name));
EXPECT_TRUE(!nullptr_permission);
}
TEST_F(PermissionTest, TablePermissionBuilderTest) {
std::unique_ptr<Permission> table_permission(
PermissionBuilder::NewPermission(Permission::kRead, namespace_name, table_name));
EXPECT_TRUE(table_permission->type() == Permission::kTable);
EXPECT_TRUE(table_permission->table_permission().namespace_name() == namespace_name);
EXPECT_TRUE(table_permission->table_permission().table_name() == table_name);
std::unique_ptr<Permission> nullptr_permission(PermissionBuilder::NewPermission(
static_cast<Permission::Action>(5), namespace_name, table_name));
EXPECT_TRUE(!nullptr_permission);
}
TEST_F(PermissionTest, TableCfQuPermissionBuilderTest) {
std::unique_ptr<Permission> table_cf_qu_permission(PermissionBuilder::NewPermission(
Permission::kRead, namespace_name, table_name, family, qualifier));
EXPECT_TRUE(table_cf_qu_permission->type() == Permission::kTable);
EXPECT_TRUE(table_cf_qu_permission->table_permission().namespace_name() == namespace_name);
EXPECT_TRUE(table_cf_qu_permission->table_permission().table_name() == table_name);
EXPECT_TRUE(table_cf_qu_permission->table_permission().family() == family);
EXPECT_TRUE(table_cf_qu_permission->table_permission().qualifier() == qualifier);
std::unique_ptr<Permission> nullptr_permission(PermissionBuilder::NewPermission(
static_cast<Permission::Action>(5), namespace_name, table_name, family, qualifier));
EXPECT_TRUE(!nullptr_permission);
}
}
}
} | 1,041 |
488 | <filename>projects/simulator/syscall_tests/syscall_tst.117.c
/******************************************************************************
* Copyright (C) International Business Machines Corp., 2004, 2006
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
* the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*
*
* FILE: testfileperms.c
*
* PURPOSE: The purpose of this test is to verify the file permissions
* of all files under a given directory. The test makes 2 passes
* through all the files.
* Pass 1:
* Using the existing file attributes, verify file access as the
* file owner, group owner and other.
* The results of "open" are used to determine access.
* If the file owner is root, it is expected that access
* will be granted even if permissions are explicitly
* denied.
* Pass 2:
* An attempt is made to chown the file to the provided
* testuser and testgroup.
* If the chown fails, a message is logged and the file
* is skipped.
* If the chown succeeds, a stat is performed to verify
* the chown was effective. If the file owner and group
* has not been modified, a message is logged and the file
* is skipped.
* Once the file is chowned, file permissions are verified
* as the testuser/testgroup.
*
* In all cases, links are skipped.
*
* SPECIAL CASES:
* If the given directory is "ipc_obj", all IPC Objects are tested
* (Shared Memory, Semaphores and Message Queue).
*
* If the given directory is "dev/mqueue", all files in that directory
* are tested with specifics functions of POSIX Message Queue.
*
* When testing functions those will change the original value of
* IPC object, a pre-preparing of object is done to make sure that the test
* will fail or accept by permission access only. After the execution of
* test, the original values are returned to the object in test.
*
************************** HISTORY ****************************************
* DATE NAME DESCRIPTION
* 01/29/2007 <EMAIL> Added shmdt to dettach shmemory when
* operation succeeds.
* Fixed file_select scandir param function
* 01/10/2007 <EMAIL> Minor fix - added a special
* case when file gid == gid_other
* 01/10/2007 <EMAIL> Fixed. Added setgroups() to
* drop supplementary groups
* 01/04/2007 <EMAIL> Updated nobody's uid/gid to
* match RHEL5 ones (99/99)
* 08/18/2006 <EMAIL> Added IPC Message Queue tests
* 08/16/2006 <EMAIL> Added IPC Semaphores Set tests
* 08/14/2006 <EMAIL> Added IPC Shared Memory tests
* 08/11/2006 <EMAIL> Added POSIX Message Queue tests
* 11/18/2004 <EMAIL> If access is expected but denied,
* this is not a security problem,
* it is a problem if denial is
* expected but access allowed.
* So if pass is expected but fail
* received, this has been deemed
* OK for certification purposes
* (A1).
* 10/10/2004 <EMAIL> originated by <NAME>.
******************************************************************************/
#include <sys/types.h>
#include <sys/dir.h>
#include <sys/param.h>
#include <sys/stat.h>
#include <sys/shm.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/msg.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <pwd.h>
#include <grp.h>
#include <fcntl.h>
#include <errno.h>
#include <mqueue.h>
#define tmpfile "/tmp/tmpfile"
extern int alphasort ();
static int file_select (const struct dirent *entry);
static int perms[] = {S_IRUSR, S_IWUSR, S_IXUSR,
S_IRGRP, S_IWGRP, S_IXGRP,
S_IROTH, S_IWOTH, S_IXOTH};
static char *ptext[] = {"r", "w", "x", "r", "w", "x", "r", "w", "x"};
int totalpass = 0;
int totalfail = 0;
uid_t uid_nobody = 99;
gid_t gid_nobody = 99;
int test = 0;
static char *test_description[] = {"Check default permissions",
"chown files to testuser/testgroup"};
/*
* Do not include . or .. in directory list.
*/
static int file_select (const struct dirent *entry)
{
if ((strcmp (entry->d_name, ".") == 0) ||
(strcmp (entry->d_name, "..") == 0))
return (0);
else
return (1);
}
/*
* Set euid, egid
*/
void setids(uid_t uid, gid_t gid)
{
int rc = 0;
if ((rc = setegid(gid)) == -1) {
printf("ERROR: unable to set gid %d, errno %d", gid, errno);
exit(1);
}
if ((rc = seteuid(uid)) == -1) {
printf("ERROR: unable to set uid %d, errno %d", uid, errno);
exit(1);
}
printf("euid/egid now %d/%d\n", geteuid(), getegid());
return;
}
/*
* Check actual vs. expected access using open system call
*/
void testaccess(char *pathname, int mode, int expected, char *outbuf)
{
int testrc = 0;
int myerr = 0;
char dir[15]; /* used for posix message queue */
char * qname;
if (expected == -1) {
strcat(outbuf, "expected: fail ");
} else {
strcat(outbuf, "expected: pass ");
}
memset(dir, '\0', sizeof(dir));
strncpy(dir, pathname, 12);
/* Test if pathname is from POSIX Message Queue */
if (strcmp(dir, "/dev/mqueue/") == 0) {
qname = &pathname[11];
if ((testrc = mq_open(qname, mode)) == -1) {
myerr = errno;
strcat(outbuf, "actual: fail");
} else {
strcat(outbuf, "actual: pass");
mq_close(testrc);
}
} else {
if ((testrc = open(pathname, mode)) == -1) {
myerr = errno;
strcat(outbuf, "actual: fail");
} else {
strcat(outbuf, "actual: pass");
close(testrc);
}
}
if (myerr == ENODEV) {
sprintf(&(outbuf[strlen(outbuf)]),
"\tresult: SKIP : no device : %s\n", pathname);
} else if (myerr == EBUSY) {
sprintf(&(outbuf[strlen(outbuf)]),
"\tresult: SKIP : device busy : %s\n", pathname);
} else if ((testrc == expected) || ((expected == 0) && (testrc != -1))) {
strcat(outbuf, "\tresult: PASS\n");
totalpass++;
} else {
/*
* A1 OK if expected pass but got fail, but need to log
* so can manually check errno.
*/
if ((expected == 0) && (testrc == -1)) {
sprintf(&(outbuf[strlen(outbuf)]),
"\tresult: FAIL/PASS : errno = %d : %s\n",
myerr, pathname);
totalpass++;
} else {
sprintf(&(outbuf[strlen(outbuf)]),
"\tresult: FAIL : myerr = %d, expected = %d, testrc = %d, euid = %u, egid = %u : %s\n",
myerr, expected, testrc, geteuid(), getegid(), pathname);
totalfail++;
}
}
printf("%s", outbuf);
return;
}
/*
* Check actual vs. expected access using ipc system call
*/
void testaccess_ipc(int ipc_id,
char opt,
int mode,
int expected,
char *outbuf)
{
int actual, semval, rc;
int myerror = 0;
char * chPtr;
struct sembuf sop;
uid_t tmpuid;
gid_t tmpgid;
struct msqbuf {
long mtype;
char mtext[80];
} s_message, r_message;
/* If we are root, we expect to succeed event
* without explicit permission.
*/
strcat(outbuf,(expected == -1)?"expected: fail ":"expected: pass ");
switch (opt) {
/* Shared Memory */
case 'm':
/* Try to get (mode) access
* There is no notion of a write-only shared memory
* segment. We are testing READ ONLY and READWRITE access.
*/
chPtr = shmat (ipc_id, NULL, (mode==O_RDONLY)?SHM_RDONLY:0);
if (chPtr != (void *)-1) {
strcat(outbuf, "actual: pass ");
actual = 0;
if (shmdt(chPtr) == -1) {
perror("Warning: Could not dettach memory segment");
}
} else {
myerror = errno;
strcat(outbuf, "actual: fail ");
actual = -1;
}
break;
/* Semaphores */
case 's':
tmpuid = geteuid();
tmpgid = getegid();
semval = semctl(ipc_id, 0, GETVAL);
/* Need semaphore value == 0 to execute read permission test */
if ((mode == O_RDONLY) && (semval > 0)) {
setids(0,0);
if ((semctl(ipc_id, 0, SETVAL, 0)) == -1) {
printf("Unable to set semaphore value: %d\n",
errno);
}
setids(tmpuid, tmpgid);
}
/* Try to get mode access */
sop.sem_num = 0;
sop.sem_op = mode;
sop.sem_flg = SEM_UNDO;
actual = semop(ipc_id, &sop, 1);
myerror = errno;
if (actual != -1) {
strcat(outbuf, "actual: pass ");
/* back to semaphore original value */
if (mode != O_RDONLY) {
sop.sem_op = -1; /* decrement semaphore */
rc = semop(ipc_id, &sop, 1);
}
} else {
/* Back to semaphore original value */
if ((mode == O_RDONLY) && (semval > 0)) {
setids(0,0);
if ((semctl(ipc_id, 0, SETVAL, semval)) == -1) {
printf("Unable to set semaphore "
"value: %d\n", errno);
}
setids(tmpuid, tmpgid);
}
strcat(outbuf, "actual: fail ");
}
break;
/* Message Queues */
case 'q':
tmpuid = geteuid();
tmpgid = getegid();
if (mode == O_RDONLY) {
setids(0,0);
/* Send a message to test msgrcv function */
s_message.mtype = 1;
memset(s_message.mtext, '\0', sizeof(s_message.mtext));
strcpy(s_message.mtext, "First Message\0");
if ((rc = msgsnd(ipc_id, &s_message,
strlen(s_message.mtext), 0)) == -1) {
printf("Error sending first message: %d\n",
errno);
}
setids(tmpuid, tmpgid);
}
s_message.mtype = 1;
memset(s_message.mtext, '\0', sizeof(s_message.mtext));
strcpy(s_message.mtext, "Write Test\0");
/* Try to get WRITE access */
if (mode == O_WRONLY) {
actual = msgsnd(ipc_id, &s_message,
strlen(s_message.mtext), 0);
} else {
/* Try to get READ access */
actual = msgrcv(ipc_id, &r_message,
sizeof(r_message.mtext), 0, IPC_NOWAIT);
}
myerror = errno;
if (actual != -1) {
strcat(outbuf, "actual: pass ");
} else {
strcat(outbuf, "actual: fail ");
}
if (((mode == O_RDONLY) && (actual == -1)) ||
((mode == O_WRONLY) && (actual != -1))) {
setids(0,0);
/* discard the message send */
rc = msgrcv(ipc_id, &r_message,
sizeof(r_message.mtext), 0, IPC_NOWAIT);
setids(tmpuid, tmpgid);
}
break;
}
if ((actual == expected) || ((expected == 0) && (actual != -1))) {
strcat(outbuf, "\tresult: PASS\n");
totalpass++;
} else {
errno = myerror; // restore errno from correct error code
sprintf(&(outbuf[strlen(outbuf)]), "\tresult: FAIL : "
"errno = %d\n", errno);
totalfail++;
}
printf("%s", outbuf);
return;
}
/*
* Test access for owner, group, other
*/
void testall(struct stat *ostatbufp, char *pathname, uid_t uid, gid_t gid)
{
int i;
int rc = 0;
char outbuf[512];
struct passwd passwd;
struct passwd *passwdp;
struct group group;
struct group *groupp;
struct stat statbuf;
struct stat *statbufp = &statbuf;
char *pbuf;
char *gbuf;
passwdp = (struct passwd *)malloc(sizeof(passwd));
groupp = (struct group *)malloc(sizeof(group));
pbuf = (char *)malloc(4096);
gbuf = (char *)malloc(4096);
memset(pbuf, '\0', 4096);
memset(gbuf, '\0', 4096);
setids(0,0);
printf("\n%s\n", pathname);
/* For test 1 we chown the file owner/group */
if (test == 1) {
if ((rc = chown(pathname, uid, gid)) == -1) {
printf("ERROR: unable to chown %s to %d:%d\n",
pathname, uid, gid);
goto EXIT;
}
}
/* Start with clean buffers */
memset(&statbuf, '\0', sizeof(statbuf));
/* Get file stat info to determine actual owner and group */
stat(pathname, &statbuf);
/*
* If we successfully chown'd the file, but the owner hasn't changed
* log it and skip.
*/
if ((test == 1) && ((statbufp->st_uid != uid) ||
(statbufp->st_gid != gid))) {
printf("INFO: chown success, but file owner "
"did not change: %s\n", pathname);
goto EXIT;
}
memset(outbuf, '\0', sizeof(outbuf));
strcat(outbuf, "MODE: ");
for (i = 0; i < sizeof(perms)/sizeof(int); i++) {
if (statbufp->st_mode & perms[i]) {
strcat(outbuf, ptext[i]);
} else {
strcat(outbuf, "-");
}
}
getpwuid_r(statbufp->st_uid, &passwd, pbuf, 4096, &passwdp);
getgrgid_r(statbufp->st_gid, &group, gbuf, 4096, &groupp);
sprintf(&(outbuf[strlen(outbuf)]), " %s:%s\n",
passwd.pw_name, group.gr_name);
printf("%s", outbuf);
/* Check owner access for read/write */
setids(statbufp->st_uid, gid_nobody);
memset(outbuf, '\0', sizeof(outbuf));
strcat(outbuf, "Owner read\t");
/*
* If we are root, we expect to succeed event
* without explicit permission.
*/
if ((statbufp->st_mode & S_IRUSR) || (statbufp->st_uid == 0)) {
testaccess(pathname, O_RDONLY, 0, outbuf);
} else {
testaccess(pathname, O_RDONLY, -1, outbuf);
}
memset(outbuf, '\0', sizeof(outbuf));
strcat(outbuf, "Owner write\t");
/*
* If we are root, we expect to succeed event
* without explicit permission.
*/
if ((statbufp->st_mode & S_IWUSR) || (statbufp->st_uid == 0)) {
testaccess(pathname, O_WRONLY, 0, outbuf);
} else {
testaccess(pathname, O_WRONLY, -1, outbuf);
}
/* Check group access for read/write */
setids(0, 0);
setids(uid_nobody, statbufp->st_gid);
memset(outbuf, '\0', sizeof(outbuf));
strcat(outbuf, "Group read\t");
if (statbufp->st_mode & S_IRGRP) {
testaccess(pathname, O_RDONLY, 0, outbuf);
} else {
testaccess(pathname, O_RDONLY, -1, outbuf);
}
memset(outbuf, '\0', sizeof(outbuf));
strcat(outbuf, "Group write\t");
if (statbufp->st_mode & S_IWGRP) {
testaccess(pathname, O_WRONLY, 0, outbuf);
} else {
testaccess(pathname, O_WRONLY, -1, outbuf);
}
/* Check other access for read/write */
setids(0, 0);
setids(uid_nobody, gid_nobody);
memset(outbuf, '\0', sizeof(outbuf));
strcat(outbuf, "Other read\t");
if (statbufp->st_gid == gid_nobody) {
/* special case! file's gid == our 'other' gid */
if (statbufp->st_mode & S_IRGRP) {
testaccess(pathname, O_RDONLY, 0, outbuf);
} else {
testaccess(pathname, O_RDONLY, -1, outbuf);
}
}
else {
if (statbufp->st_mode & S_IROTH) {
testaccess(pathname, O_RDONLY, 0, outbuf);
} else {
testaccess(pathname, O_RDONLY, -1, outbuf);
}
}
memset(outbuf, '\0', sizeof(outbuf));
strcat(outbuf, "Other write\t");
if (statbufp->st_gid == gid_nobody) {
/* special case! ile's gid == our 'other' gid */
if (statbufp->st_mode & S_IWGRP) {
testaccess(pathname, O_WRONLY, 0, outbuf);
} else {
testaccess(pathname, O_WRONLY, -1, outbuf);
}
}
else {
if (statbufp->st_mode & S_IWOTH) {
testaccess(pathname, O_WRONLY, 0, outbuf);
} else {
testaccess(pathname, O_WRONLY, -1, outbuf);
}
}
setids(0, 0);
if (test == 1) {
chown(pathname, ostatbufp->st_uid, ostatbufp->st_gid);
}
EXIT:
return;
}
/*
* Test an IPC object.
*/
int testall_ipc(int ipc_id, char opt, uid_t uid, gid_t gid)
{
int rc = 0;
char outbuf[256];
struct passwd passwd;
struct passwd *passwdp;
struct group group;
struct group *groupp;
struct shmid_ds shbuf;
struct semid_ds sembuf;
struct msqid_ds msqbuf;
struct ipc_perm * ipcperm;
char *pbuf;
char *gbuf;
uid_t tmpuid;
gid_t tmpgid;
pbuf = (char *)malloc(4096);
gbuf = (char *)malloc(4096);
memset(pbuf, '\0', 4096);
memset(gbuf, '\0', 4096);
setids(0,0);
printf("\nIPC ID: %d - %s\n", ipc_id,
((opt=='s')?"Semaphore Sets":(opt=='m')?"Shared Memory Segment":
"Message Queues"));
switch (opt) {
/* Shared Memory */
case 'm':
/* Get stat information of shared memory.*/
if ((rc = shmctl (ipc_id, IPC_STAT, &shbuf)) == -1) {
printf("Error getting stat of Shared Memory: %d\n",
errno);
return (rc);
} else {
/* ipcperm get the shm_perm memory address to manipulate
* permissions with the same struct (ipc_perm).
*/
ipcperm = &(shbuf.shm_perm);
}
break;
/* Semaphores */
case 's':
/* Set permission mode for semaphore. */
if ((rc = semctl(ipc_id, 0, IPC_STAT, &sembuf)) == -1) {
printf("Error getting stat of Semaphores: %d\n",errno);
return (rc);
} else {
/* ipcperm get the sem_perm memory address to manipulate
* permissions with the same struct (ipc_perm).
*/
ipcperm = &(sembuf.sem_perm);
}
break;
/* Message Queues */
case 'q':
if ((rc = msgctl (ipc_id, IPC_STAT, &msqbuf)) == -1) {
printf("Error getting stat of Message Queue: %d\n",
errno);
return (rc);
} else {
/* ipcperm get the msg_perm memory address to manipulate
* permissions with the same struct (ipc_perm).
*/
ipcperm = &(msqbuf.msg_perm);
}
break;
}
/* For test 1, change owner and group */
if (test == 1) {
tmpuid = ipcperm->uid;
tmpgid = ipcperm->gid;
ipcperm->uid = uid;
ipcperm->gid = gid;
switch (opt) {
/* Shared Memory */
case 'm':
if ((rc = shmctl (ipc_id, IPC_SET, &shbuf)) == -1) {
printf("Error setting stat of Shared Memory: "
"%d\n", errno);
return(rc);
}
break;
/* Semaphores */
case 's':
if ((rc = semctl (ipc_id, 0, IPC_SET, &sembuf)) == -1) {
printf("Error setting stat of Semaphores: "
"%d\n", errno);
return(rc);
}
break;
/* Message Queues */
case 'q':
if ((rc = msgctl (ipc_id, IPC_SET, &msqbuf)) == -1) {
printf("Error setting stat of Message Queue: "
"%d\n", errno);
return(rc);
}
break;
}
}
memset(outbuf, '\0', sizeof(outbuf));
strcat(outbuf, "MODE: ");
strcat(outbuf, (((ipcperm->mode & S_IRUSR) != 0)? "r":"-"));
strcat(outbuf, (((ipcperm->mode & S_IWUSR) != 0)? "w":"-"));
strcat(outbuf, "-");
strcat(outbuf, (((ipcperm->mode & S_IRGRP) != 0)? "r":"-"));
strcat(outbuf, (((ipcperm->mode & S_IWGRP) != 0)? "w":"-"));
strcat(outbuf, "-");
strcat(outbuf, (((ipcperm->mode & S_IROTH) != 0)? "r":"-"));
strcat(outbuf, (((ipcperm->mode & S_IWOTH) != 0)? "w":"-"));
strcat(outbuf, "-");
getpwuid_r(ipcperm->uid, &passwd, pbuf, 4096, &passwdp);
getgrgid_r(ipcperm->gid, &group, gbuf, 4096, &groupp);
/* Print owner:group */
sprintf(&(outbuf[strlen(outbuf)]), " %s:%s\n",
passwd.pw_name, group.gr_name);
/* Change current owner of process to access IPC function */
setids(ipcperm->uid, gid_nobody);
strcat(outbuf, "Owner read\t");
/*
* If we are root, we expect to succeed event
* without explicit permission.
*/
if ((ipcperm->mode & S_IRUSR) || (ipcperm->uid == 0)) {
testaccess_ipc(ipc_id, opt, O_RDONLY, 0, outbuf);
} else {
testaccess_ipc(ipc_id, opt, O_RDONLY, -1, outbuf);
}
memset(outbuf, '\0', sizeof(outbuf));
strcat(outbuf, "Owner write\t");
/*
* If we are root, we expect to succeed event
* without explicit permission.
*/
if ((ipcperm->mode & S_IWUSR) || (ipcperm->uid == 0)) {
testaccess_ipc(ipc_id, opt, O_WRONLY, 0, outbuf);
} else {
testaccess_ipc(ipc_id, opt, O_WRONLY, -1, outbuf);
}
/* Check group access for read/write */
setids(0, 0);
setids(uid_nobody, ipcperm->gid);
memset(outbuf, '\0', sizeof(outbuf));
strcat(outbuf, "Group read\t");
if (ipcperm->mode & S_IRGRP) {
testaccess_ipc(ipc_id, opt, O_RDONLY, 0, outbuf);
} else {
testaccess_ipc(ipc_id, opt, O_RDONLY, -1, outbuf);
}
memset(outbuf, '\0', sizeof(outbuf));
strcat(outbuf, "Group write\t");
if (ipcperm->mode & S_IWGRP) {
testaccess_ipc(ipc_id, opt, O_WRONLY, 0, outbuf);
} else {
testaccess_ipc(ipc_id, opt, O_WRONLY, -1, outbuf);
}
/* Check other access for read/write */
setids(0, 0);
setids(uid_nobody, gid_nobody);
memset(outbuf, '\0', sizeof(outbuf));
strcat(outbuf, "Other read\t");
if (ipcperm->mode & S_IROTH) {
testaccess_ipc(ipc_id, opt, O_RDONLY, 0, outbuf);
} else {
testaccess_ipc(ipc_id, opt, O_RDONLY, -1, outbuf);
}
memset(outbuf, '\0', sizeof(outbuf));
strcat(outbuf, "Other write\t");
if (ipcperm->mode & S_IWOTH) {
testaccess_ipc(ipc_id, opt, O_WRONLY, 0, outbuf);
} else {
testaccess_ipc(ipc_id, opt, O_WRONLY, -1, outbuf);
}
setids(0, 0);
/* Back to the original owner */
if (test == 1) {
ipcperm->uid = tmpuid;
ipcperm->gid = tmpgid;
switch (opt) {
/* Shared Memory */
case 'm':
if ((rc = shmctl (ipc_id, IPC_SET, &shbuf)) == -1) {
printf("Error setting stat back of Shared "
"Memory: %d\n", errno);
return(rc);
}
break;
/* Semaphores */
case 's':
if ((rc = semctl (ipc_id, 0, IPC_SET, &sembuf)) == -1) {
printf("Error setting stat back of Semaphores: "
"%d\n", errno);
return(rc);
}
break;
/* Message Queues */
case 'q':
if ((rc = msgctl (ipc_id, IPC_SET, &msqbuf)) == -1) {
printf("Error setting stat back of Message "
"Queue: %d\n", errno);
return(rc);
}
break;
}
}
return(0);
}
/*
* Test all IPC Objects
*
* This method check access on actives ipc onjects in kernel
*/
int check_ipc(uid_t uid, gid_t gid)
{
FILE *fd;
char * ret_char;
char readbuf[80];
char ipcscommand[80];
char ipc_buf[10];
int ipc_id;
char ipc_obj[3] = {'m', 's', 'q'}; /* m => SHM, s => SEM, Q => MSQ */
int opt;
setids(0,0);
for (opt = 0; opt < 3; opt++) {
/* Store the resulto of ipcscommand in tmpfile and read each
* line to test IPC objects
*/
memset(ipcscommand, '\0', sizeof(ipcscommand));
sprintf(ipcscommand, "ipcs -%c >%s", ipc_obj[opt], tmpfile);
system(ipcscommand);
fd = fopen(tmpfile, "r");
/* Skip the header */
fgets(readbuf, sizeof(readbuf), fd);
fgets(readbuf, sizeof(readbuf), fd);
fgets(readbuf, sizeof(readbuf), fd);
memset(readbuf, '\0', sizeof(readbuf));
ret_char = fgets(readbuf, sizeof(readbuf), fd);
while ((ret_char != NULL) && (*readbuf != '\n')) {
sscanf(readbuf, "%s %d", ipc_buf, &ipc_id);
/* ipc_id stores the id of ipc object */
testall_ipc(ipc_id, ipc_obj[opt], uid, gid);
memset(readbuf, '\0', sizeof(readbuf));
ret_char = fgets(readbuf, sizeof(readbuf), fd);
}
fclose(fd);
unlink(tmpfile);
}
return (0);
}
/*
* Check access.
*
* This method check a file or recursively scan directories and verify
* the file access modes are enforced.
*/
void check_access (char *pathname, uid_t uid, gid_t gid)
{
int count = 0;
int i = 0;
int rc = 0;
char entry[MAXPATHLEN];
struct dirent **entries;
struct stat statbuf;
/* Start with clean buffers */
memset(&statbuf, '\0', sizeof(statbuf));
/* Test System V Message Queue - IPC */
if ((strcmp(pathname, "ipc_obj")) == 0) {
printf("Testing IPC objects\n");
if (check_ipc(uid, gid) == -1) {
printf("\nERROR: %s. Could not obtain ipc "
"status. errno = %d\n", pathname, errno);
goto EXIT;
}
goto EXIT;
}
/* Get file stat info. */
if ((rc = lstat(pathname, &statbuf)) == -1) {
printf("\nERROR: %s. Could not obtain file status. errno = %d\n",
pathname, errno);
goto EXIT;
}
/* If link, skip it. */
if (S_ISLNK(statbuf.st_mode)) {
printf("Link: skipping %s\n", entry);
goto EXIT;
}
/* If not a directory, check it and leave. */
if (!(S_ISDIR(statbuf.st_mode))) {
testall(&statbuf, pathname, uid, gid);
goto EXIT;
}
/*
*If directory, recurse through all subdirectories,
* checking all files.
*/
if ((count = scandir(pathname, &entries, file_select,
alphasort)) == -1) {
printf("\nERROR: %s. Could not scandir. errno = %d\n",
pathname, errno);
goto EXIT;
}
for (i = 0; i < count; i++) {
sprintf(entry, "%s/%s", pathname, entries[i]->d_name);
/*
* If link, skip it
* Else if directory, call check_access() recursively
*/
if (entries[i]->d_type == DT_LNK) {
printf("Link: skipping %s\n", entry);
continue;
} else if (entries[i]->d_type == DT_DIR) {
check_access(entry, uid, gid);
continue;
}
/* Clean the buffer */
memset(&statbuf, '\0', sizeof(statbuf));
/* Get file stat info. */
if ((rc = lstat(entry, &statbuf)) == -1) {
printf("\nERROR: %s. Could not obtain file status. errno = %d\n",
pathname, errno);
continue;
}
/* The directory entry doesn't always seem to have the
* right info. So we check again after the stat().
*
* If link, skip it
* Else if directory, call check_access() recursively
* Else check access
*/
if (S_ISLNK(statbuf.st_mode)) {
printf("Link: (2) skipping %s\n", entry);
continue;
} else if (S_ISDIR(statbuf.st_mode)) {
check_access(entry, uid, gid);
continue;
} else {
testall(&statbuf, entry, uid, gid);
continue;
}
}
EXIT:
return;
}
char *TCID = "syscall.117";
int TST_TOTAL=1;
int main (int argc, char *argv[]) {
int i = 0;
struct passwd *pw;
struct group *gr;
if (argc != 4) {
printf("usage: %s <directory> <testuser> <testgroup>\n",
argv[0]);
goto EXIT;
}
if ((pw = getpwnam(argv[2])) == NULL) {
printf("ERROR: invalid username %s\n", argv[2]);
goto EXIT;
}
if ((gr = getgrnam(argv[3])) == NULL) {
printf("ERROR: invalid group %s\n", argv[3]);
goto EXIT;
}
/* drop all supplementary groups - we only rely on uid/gid */
if (setgroups(0, NULL) == -1) {
perror("ERROR: can't drop supplementary groups");
goto EXIT;
}
for (i = 0; i < 2; i++) {
totalpass = 0;
totalfail = 0;
test = i;
printf("Test: %s\n\n", test_description[i]);
check_access(argv[1], pw->pw_uid, gr->gr_gid);
printf("\n TESTS PASSED = %d, FAILED = %d\n",
totalpass, totalfail);
}
EXIT:
return (0);
}
| 10,881 |
1,042 | <filename>StereoKitC/lib/include/reactphysics3d/systems/ConstraintSolverSystem.h
/********************************************************************************
* ReactPhysics3D physics library, http://www.reactphysics3d.com *
* Copyright (c) 2010-2020 <NAME> *
*********************************************************************************
* *
* This software is provided 'as-is', without any express or implied warranty. *
* In no event will the authors be held liable for any damages arising from the *
* use of this software. *
* *
* Permission is granted to anyone to use this software for any purpose, *
* including commercial applications, and to alter it and redistribute it *
* freely, subject to the following restrictions: *
* *
* 1. The origin of this software must not be misrepresented; you must not claim *
* that you wrote the original software. If you use this software in a *
* product, an acknowledgment in the product documentation would be *
* appreciated but is not required. *
* *
* 2. Altered source versions must be plainly marked as such, and must not be *
* misrepresented as being the original software. *
* *
* 3. This notice may not be removed or altered from any source distribution. *
* *
********************************************************************************/
#ifndef REACTPHYSICS3D_CONSTRAINT_SOLVER_SYSTEM_H
#define REACTPHYSICS3D_CONSTRAINT_SOLVER_SYSTEM_H
// Libraries
#include <reactphysics3d/configuration.h>
#include <reactphysics3d/mathematics/mathematics.h>
#include <reactphysics3d/systems/SolveBallAndSocketJointSystem.h>
#include <reactphysics3d/systems/SolveFixedJointSystem.h>
#include <reactphysics3d/systems/SolveHingeJointSystem.h>
#include <reactphysics3d/systems/SolveSliderJointSystem.h>
namespace reactphysics3d {
// Declarations
class Joint;
class Island;
struct Islands;
class Profiler;
class RigidBodyComponents;
class JointComponents;
class DynamicsComponents;
// Structure ConstraintSolverData
/**
* This structure contains data from the constraint solver that are used to solve
* each joint constraint.
*/
struct ConstraintSolverData {
public :
/// Current time step of the simulation
decimal timeStep;
/// True if warm starting of the solver is active
bool isWarmStartingActive;
/// Reference to the rigid body components
RigidBodyComponents& rigidBodyComponents;
/// Reference to the joint components
JointComponents& jointComponents;
/// Constructor
ConstraintSolverData(RigidBodyComponents& rigidBodyComponents, JointComponents& jointComponents)
:rigidBodyComponents(rigidBodyComponents), jointComponents(jointComponents) {
}
};
// Class ConstraintSolverSystem
/**
* This class represents the constraint solver that is used to solve constraints between
* the rigid bodies. The constraint solver is based on the "Sequential Impulse" technique
* described by <NAME> in his GDC slides (http://code.google.com/p/box2d/downloads/list).
*
* A constraint between two bodies is represented by a function C(x) which is equal to zero
* when the constraint is satisfied. The condition C(x)=0 describes a valid position and the
* condition dC(x)/dt=0 describes a valid velocity. We have dC(x)/dt = Jv + b = 0 where J is
* the Jacobian matrix of the constraint, v is a vector that contains the velocity of both
* bodies and b is the constraint bias. We are looking for a force F_c that will act on the
* bodies to keep the constraint satisfied. Note that from the virtual work principle, we have
* F_c = J^t * lambda where J^t is the transpose of the Jacobian matrix and lambda is a
* Lagrange multiplier. Therefore, finding the force F_c is equivalent to finding the Lagrange
* multiplier lambda.
* An impulse P = F * dt where F is a force and dt is the timestep. We can apply impulses a
* body to change its velocity. The idea of the Sequential Impulse technique is to apply
* impulses to bodies of each constraints in order to keep the constraint satisfied.
*
* --- Step 1 ---
*
* First, we integrate the applied force F_a acting of each rigid body (like gravity, ...) and
* we obtain some new velocities v2' that tends to violate the constraints.
*
* v2' = v1 + dt * M^-1 * F_a
*
* where M is a matrix that contains mass and inertia tensor information.
*
* --- Step 2 ---
*
* During the second step, we iterate over all the constraints for a certain number of
* iterations and for each constraint we compute the impulse to apply to the bodies needed
* so that the new velocity of the bodies satisfy Jv + b = 0. From the Newton law, we know that
* M * deltaV = P_c where M is the mass of the body, deltaV is the difference of velocity and
* P_c is the constraint impulse to apply to the body. Therefore, we have
* v2 = v2' + M^-1 * P_c. For each constraint, we can compute the Lagrange multiplier lambda
* using : lambda = -m_c (Jv2' + b) where m_c = 1 / (J * M^-1 * J^t). Now that we have the
* Lagrange multiplier lambda, we can compute the impulse P_c = J^t * lambda * dt to apply to
* the bodies to satisfy the constraint.
*
* --- Step 3 ---
*
* In the third step, we integrate the new position x2 of the bodies using the new velocities
* v2 computed in the second step with : x2 = x1 + dt * v2.
*
* Note that in the following code (as it is also explained in the slides from Erin Catto),
* the value lambda is not only the lagrange multiplier but is the multiplication of the
* Lagrange multiplier with the timestep dt. Therefore, in the following code, when we use
* lambda, we mean (lambda * dt).
*
* We are using the accumulated impulse technique that is also described in the slides from
* Erin Catto.
*
* We are also using warm starting. The idea is to warm start the solver at the beginning of
* each step by applying the last impulstes for the constraints that we already existing at the
* previous step. This allows the iterative solver to converge faster towards the solution.
*
* For contact constraints, we are also using split impulses so that the position correction
* that uses Baumgarte stabilization does not change the momentum of the bodies.
*
* There are two ways to apply the friction constraints. Either the friction constraints are
* applied at each contact point or they are applied only at the center of the contact manifold
* between two bodies. If we solve the friction constraints at each contact point, we need
* two constraints (two tangential friction directions) and if we solve the friction
* constraints at the center of the contact manifold, we need two constraints for tangential
* friction but also another twist friction constraint to prevent spin of the body around the
* contact manifold center.
*/
class ConstraintSolverSystem {
private :
// -------------------- Attributes -------------------- //
/// Current time step
decimal mTimeStep;
/// True if the warm starting of the solver is active
bool mIsWarmStartingActive;
/// Reference to the islands
Islands& mIslands;
/// Constraint solver data used to initialize and solve the constraints
ConstraintSolverData mConstraintSolverData;
/// Solver for the BallAndSocketJoint constraints
SolveBallAndSocketJointSystem mSolveBallAndSocketJointSystem;
/// Solver for the FixedJoint constraints
SolveFixedJointSystem mSolveFixedJointSystem;
/// Solver for the HingeJoint constraints
SolveHingeJointSystem mSolveHingeJointSystem;
/// Solver for the SliderJoint constraints
SolveSliderJointSystem mSolveSliderJointSystem;
#ifdef IS_RP3D_PROFILING_ENABLED
/// Pointer to the profiler
Profiler* mProfiler;
#endif
public :
// -------------------- Methods -------------------- //
/// Constructor
ConstraintSolverSystem(PhysicsWorld& world, Islands& islands, RigidBodyComponents& rigidBodyComponents,
TransformComponents& transformComponents,
JointComponents& jointComponents,
BallAndSocketJointComponents& ballAndSocketJointComponents,
FixedJointComponents& fixedJointComponents, HingeJointComponents &hingeJointComponents,
SliderJointComponents& sliderJointComponents);
/// Destructor
~ConstraintSolverSystem() = default;
/// Initialize the constraint solver
void initialize(decimal dt);
/// Solve the constraints
void solveVelocityConstraints();
/// Solve the position constraints
void solvePositionConstraints();
/// Return true if the Non-Linear-Gauss-Seidel position correction technique is active
bool getIsNonLinearGaussSeidelPositionCorrectionActive() const;
/// Enable/Disable the Non-Linear-Gauss-Seidel position correction technique.
void setIsNonLinearGaussSeidelPositionCorrectionActive(bool isActive);
#ifdef IS_RP3D_PROFILING_ENABLED
/// Set the profiler
void setProfiler(Profiler* profiler);
#endif
// ---------- Friendship ----------
friend class HingeJoint;
};
#ifdef IS_RP3D_PROFILING_ENABLED
// Set the profiler
inline void ConstraintSolverSystem::setProfiler(Profiler* profiler) {
mProfiler = profiler;
mSolveBallAndSocketJointSystem.setProfiler(profiler);
mSolveFixedJointSystem.setProfiler(profiler);
mSolveHingeJointSystem.setProfiler(profiler);
mSolveSliderJointSystem.setProfiler(profiler);
}
#endif
}
#endif
| 3,686 |
852 | <gh_stars>100-1000
import FWCore.ParameterSet.Config as cms
from DQM.EcalMonitorTasks.TimingTask_cfi import ecalTimingTask
from DQM.EcalMonitorClient.IntegrityClient_cfi import ecalIntegrityClient
minChannelEntries = 1
minTowerEntries = 3
toleranceMean = 2.
toleranceRMS = 6.
minChannelEntriesFwd = 8
minTowerEntriesFwd = 24
toleranceMeanFwd = 6.
toleranceRMSFwd = 12.
tailPopulThreshold = 0.4
timeWindow = 25.
ecalTimingClient = cms.untracked.PSet(
params = cms.untracked.PSet(
minChannelEntries = cms.untracked.int32(minChannelEntries),
minTowerEntries = cms.untracked.int32(minTowerEntries),
toleranceMean = cms.untracked.double(toleranceMean),
toleranceRMS = cms.untracked.double(toleranceRMS),
minChannelEntriesFwd = cms.untracked.int32(minChannelEntriesFwd),
minTowerEntriesFwd = cms.untracked.int32(minTowerEntriesFwd),
toleranceMeanFwd = cms.untracked.double(toleranceMeanFwd),
toleranceRMSFwd = cms.untracked.double(toleranceRMSFwd),
tailPopulThreshold = cms.untracked.double(tailPopulThreshold)
),
sources = cms.untracked.PSet(
TimeAllMap = ecalTimingTask.MEs.TimeAllMap,
TimeMap = ecalTimingTask.MEs.TimeMap,
TimeMapByLS = ecalTimingTask.MEs.TimeMapByLS,
ChStatus = ecalIntegrityClient.MEs.ChStatus
),
MEs = cms.untracked.PSet(
RMSAll = cms.untracked.PSet(
path = cms.untracked.string('%(subdet)s/%(prefix)sSummaryClient/%(prefix)sTMT%(suffix)s timing rms 1D summary'),
kind = cms.untracked.string('TH1F'),
otype = cms.untracked.string('Ecal3P'),
xaxis = cms.untracked.PSet(
high = cms.untracked.double(10.0),
nbins = cms.untracked.int32(100),
low = cms.untracked.double(0.0),
title = cms.untracked.string('time (ns)')
),
btype = cms.untracked.string('User'),
description = cms.untracked.string('Distribution of per-channel timing RMS. Channels with entries less than ' + str(minChannelEntries) + ' are not considered.')
),
ProjEta = cms.untracked.PSet(
path = cms.untracked.string('%(subdet)s/%(prefix)sTimingClient/%(prefix)sTMT timing projection eta%(suffix)s'),
kind = cms.untracked.string('TProfile'),
yaxis = cms.untracked.PSet(
title = cms.untracked.string('time (ns)')
),
otype = cms.untracked.string('Ecal3P'),
btype = cms.untracked.string('ProjEta'),
description = cms.untracked.string('Projection of per-channel mean timing. Channels with entries less than ' + str(minChannelEntries) + ' are not considered.')
),
FwdBkwdDiff = cms.untracked.PSet(
path = cms.untracked.string('%(subdet)s/%(prefix)sTimingTask/%(prefix)sTMT timing %(prefix)s+ - %(prefix)s-'),
kind = cms.untracked.string('TH1F'),
otype = cms.untracked.string('Ecal2P'),
xaxis = cms.untracked.PSet(
high = cms.untracked.double(5.0),
nbins = cms.untracked.int32(100),
low = cms.untracked.double(-5.0),
title = cms.untracked.string('time (ns)')
),
btype = cms.untracked.string('User'),
description = cms.untracked.string('Forward-backward asymmetry of per-channel mean timing. Channels with entries less than ' + str(minChannelEntries) + ' are not considered.')
),
FwdvBkwd = cms.untracked.PSet(
kind = cms.untracked.string('TH2F'),
yaxis = cms.untracked.PSet(
high = cms.untracked.double(timeWindow),
nbins = cms.untracked.int32(50),
low = cms.untracked.double(-timeWindow),
title = cms.untracked.string('time (ns)')
),
otype = cms.untracked.string('Ecal2P'),
xaxis = cms.untracked.PSet(
high = cms.untracked.double(timeWindow),
nbins = cms.untracked.int32(50),
low = cms.untracked.double(-timeWindow)
),
btype = cms.untracked.string('User'),
path = cms.untracked.string('%(subdet)s/%(prefix)sTimingTask/%(prefix)sTMT timing %(prefix)s+ vs %(prefix)s-'),
description = cms.untracked.string('Forward-backward correlation of per-channel mean timing. Channels with entries less than ' + str(minChannelEntries) + ' are not considered.')
),
ProjPhi = cms.untracked.PSet(
path = cms.untracked.string('%(subdet)s/%(prefix)sTimingClient/%(prefix)sTMT timing projection phi%(suffix)s'),
kind = cms.untracked.string('TProfile'),
yaxis = cms.untracked.PSet(
title = cms.untracked.string('time (ns)')
),
otype = cms.untracked.string('Ecal3P'),
btype = cms.untracked.string('ProjPhi'),
description = cms.untracked.string('Projection of per-channel mean timing. Channels with entries less than ' + str(minChannelEntries) + ' are not considered.')
),
MeanSM = cms.untracked.PSet(
kind = cms.untracked.string('TH1F'),
yaxis = cms.untracked.PSet(
title = cms.untracked.string('time (ns)')
),
otype = cms.untracked.string('SM'),
xaxis = cms.untracked.PSet(
high = cms.untracked.double(timeWindow),
nbins = cms.untracked.int32(100),
low = cms.untracked.double(-timeWindow)
),
btype = cms.untracked.string('User'),
path = cms.untracked.string('%(subdet)s/%(prefix)sTimingClient/%(prefix)sTMT timing mean %(sm)s'),
description = cms.untracked.string('Distribution of per-channel timing mean. Channels with entries less than ' + str(minChannelEntries) + ' are not considered.')
),
RMSMap = cms.untracked.PSet(
path = cms.untracked.string('%(subdet)s/%(prefix)sTimingClient/%(prefix)sTMT timing rms %(sm)s'),
kind = cms.untracked.string('TH2F'),
zaxis = cms.untracked.PSet(
title = cms.untracked.string('rms (ns)')
),
otype = cms.untracked.string('SM'),
btype = cms.untracked.string('Crystal'),
description = cms.untracked.string('2D distribution of per-channel timing RMS. Channels with entries less than ' + str(minChannelEntries) + ' are not considered.')
),
QualitySummary = cms.untracked.PSet(
path = cms.untracked.string('%(subdet)s/%(prefix)sSummaryClient/%(prefix)sTMT%(suffix)s timing quality summary'),
kind = cms.untracked.string('TH2F'),
otype = cms.untracked.string('Ecal3P'),
btype = cms.untracked.string('SuperCrystal'),
description = cms.untracked.string('Summary of the timing data quality. A 5x5 tower is red if the mean timing of the tower is off by more than ' + str(toleranceMean) + ' or RMS is greater than ' + str(toleranceRMS) + ' (' + str(toleranceMeanFwd) + ' and ' + str(toleranceRMSFwd) + ' in forward region). Towers with total entries less than ' + str(minTowerEntries) + ' are not subject to this evaluation. Since 5x5 tower timings are calculated with a tighter time-window than per-channel timings, a tower can additionally become red if its the sum of per-channel timing histogram entries is greater than per-tower histogram entries by factor ' + str(1. / (1. - tailPopulThreshold)) + ' (significant fraction of events fall outside the tight time-window).')
),
Quality = cms.untracked.PSet(
path = cms.untracked.string('%(subdet)s/%(prefix)sTimingClient/%(prefix)sTMT timing quality %(sm)s'),
kind = cms.untracked.string('TH2F'),
otype = cms.untracked.string('SM'),
btype = cms.untracked.string('Crystal'),
description = cms.untracked.string('Summary of the timing data quality. A channel is red if its mean timing is off by more than ' + str(toleranceMean) + ' or RMS is greater than ' + str(toleranceRMS) + '. Channels with entries less than ' + str(minChannelEntries) + ' are not considered.')
),
MeanAll = cms.untracked.PSet(
path = cms.untracked.string('%(subdet)s/%(prefix)sSummaryClient/%(prefix)sTMT%(suffix)s timing mean 1D summary'),
kind = cms.untracked.string('TH1F'),
otype = cms.untracked.string('Ecal3P'),
xaxis = cms.untracked.PSet(
high = cms.untracked.double(timeWindow),
nbins = cms.untracked.int32(100),
low = cms.untracked.double(-timeWindow),
title = cms.untracked.string('time (ns)')
),
btype = cms.untracked.string('User'),
description = cms.untracked.string('Distribution of per-channel timing mean. Channels with entries less than ' + str(minChannelEntries) + ' are not considered.')
),
TrendMean = cms.untracked.PSet(
path = cms.untracked.string('Ecal/Trends/TimingClient %(prefix)s timing mean'),
kind = cms.untracked.string('TProfile'),
otype = cms.untracked.string('Ecal2P'),
btype = cms.untracked.string('Trend'),
description = cms.untracked.string('Trend of timing mean. Plots simple average of all channel timing means at each lumisection.')
),
TrendRMS = cms.untracked.PSet(
path = cms.untracked.string('Ecal/Trends/TimingClient %(prefix)s timing rms'),
kind = cms.untracked.string('TProfile'),
otype = cms.untracked.string('Ecal2P'),
btype = cms.untracked.string('Trend'),
description = cms.untracked.string('Trend of timing rms. Plots simple average of all channel timing rms at each lumisection.')
)
)
)
| 4,640 |
7,482 | /*
* Copyright (c) 2015, Freescale Semiconductor, Inc.
* Copyright 2016-2018 NXP
* All rights reserved.
*
* SPDX-License-Identifier: BSD-3-Clause
*/
#include "fsl_sdio.h"
/*******************************************************************************
* Definitions
******************************************************************************/
/*! @brief define the tuple number will be read during init */
#define SDIO_COMMON_CIS_TUPLE_NUM (3U)
/*! @brief SDIO retry times */
#define SDIO_RETRY_TIMES (1000U)
/*******************************************************************************
* Prototypes
******************************************************************************/
/*!
* @brief probe bus voltage.
* @param card Card descriptor.
*/
static status_t SDIO_ProbeBusVoltage(sdio_card_t *card);
/*!
* @brief send card operation condition
* @param card Card descriptor.
* @param command argment
* argument = 0U , means to get the operation condition
* argument !=0 , set the operation condition register
*/
static status_t SDIO_SendOperationCondition(sdio_card_t *card, uint32_t argument);
/*!
* @brief card Send relative address
* @param card Card descriptor.
*/
static status_t SDIO_SendRca(sdio_card_t *card);
/*!
* @brief card select card
* @param card Card descriptor.
* @param select/diselect flag
*/
static status_t inline SDIO_SelectCard(sdio_card_t *card, bool isSelected);
/*!
* @brief card go idle
* @param card Card descriptor.
*/
static status_t inline SDIO_GoIdle(sdio_card_t *card);
/*!
* @brief decode CIS
* @param card Card descriptor.
* @param func number
* @param data buffer pointer
* @param tuple code
* @param tuple link
*/
static status_t SDIO_DecodeCIS(
sdio_card_t *card, sdio_func_num_t func, uint8_t *dataBuffer, uint32_t tplCode, uint32_t tplLink);
/*!
* @brief switch to the maxium support bus width, depend on the host and card's capability.
* @param card Card descriptor.
*/
static status_t SDIO_SetMaxDataBusWidth(sdio_card_t *card);
/*!
* @brief sdio card excute tuning.
* @param card Card descriptor.
*/
static status_t SDIO_ExecuteTuning(sdio_card_t *card);
/*******************************************************************************
* Variables
******************************************************************************/
/* define the tuple list */
static const uint32_t g_tupleList[SDIO_COMMON_CIS_TUPLE_NUM] = {
SDIO_TPL_CODE_MANIFID,
SDIO_TPL_CODE_FUNCID,
SDIO_TPL_CODE_FUNCE,
};
/* g_sdmmc statement */
extern uint32_t g_sdmmc[SDK_SIZEALIGN(SDMMC_GLOBAL_BUFFER_SIZE, SDMMC_DATA_BUFFER_ALIGN_CACHE)];
/*******************************************************************************
* Code
******************************************************************************/
static status_t inline SDIO_SelectCard(sdio_card_t *card, bool isSelected)
{
assert(card);
return SDMMC_SelectCard(card->host.base, card->host.transfer, card->relativeAddress, isSelected);
}
static status_t inline SDIO_GoIdle(sdio_card_t *card)
{
assert(card);
return SDMMC_GoIdle(card->host.base, card->host.transfer);
}
static status_t SDIO_SwitchVoltage(sdio_card_t *card)
{
assert(card);
if ((card->usrParam.cardVoltage != NULL) && (card->usrParam.cardVoltage->cardSignalLine1V8 != NULL))
{
return SDMMC_SwitchToVoltage(card->host.base, card->host.transfer,
card->usrParam.cardVoltage->cardSignalLine1V8);
}
return SDMMC_SwitchToVoltage(card->host.base, card->host.transfer, NULL);
}
static status_t SDIO_ExecuteTuning(sdio_card_t *card)
{
assert(card);
return SDMMC_ExecuteTuning(card->host.base, card->host.transfer, kSD_SendTuningBlock, 64U);
}
static status_t SDIO_SendRca(sdio_card_t *card)
{
assert(card);
uint32_t i = FSL_SDMMC_MAX_CMD_RETRIES;
SDMMCHOST_TRANSFER content = {0};
SDMMCHOST_COMMAND command = {0};
command.index = kSDIO_SendRelativeAddress;
command.argument = 0U;
command.responseType = kCARD_ResponseTypeR6;
command.responseErrorFlags = kSDIO_StatusR6Error | kSDIO_StatusIllegalCmd | kSDIO_StatusCmdCRCError;
content.command = &command;
content.data = NULL;
while (--i)
{
if (kStatus_Success == card->host.transfer(card->host.base, &content))
{
/* check illegal state and cmd CRC error, may be the voltage or clock not stable, retry the cmd*/
if (command.response[0U] & (kSDIO_StatusIllegalCmd | kSDIO_StatusCmdCRCError))
{
continue;
}
card->relativeAddress = (command.response[0U] >> 16U);
return kStatus_Success;
}
}
return kStatus_SDMMC_TransferFailed;
}
status_t SDIO_CardInActive(sdio_card_t *card)
{
assert(card);
return SDMMC_SetCardInactive(card->host.base, card->host.transfer);
}
static status_t SDIO_SendOperationCondition(sdio_card_t *card, uint32_t argument)
{
assert(card);
SDMMCHOST_TRANSFER content = {0U};
SDMMCHOST_COMMAND command = {0U};
uint32_t i = SDIO_RETRY_TIMES;
command.index = kSDIO_SendOperationCondition;
command.argument = argument;
command.responseType = kCARD_ResponseTypeR4;
content.command = &command;
content.data = NULL;
while (--i)
{
if (kStatus_Success != card->host.transfer(card->host.base, &content) || (command.response[0U] == 0U))
{
continue;
}
/* if argument equal 0, then should check and save the info */
if (argument == 0U)
{
/* check if memory present */
if ((command.response[0U] & SDMMC_MASK(kSDIO_OcrMemPresent)) == SDMMC_MASK(kSDIO_OcrMemPresent))
{
card->memPresentFlag = true;
}
/* save the io number */
card->ioTotalNumber = (command.response[0U] & SDIO_OCR_IO_NUM_MASK) >> kSDIO_OcrIONumber;
/* save the operation condition */
card->ocr = command.response[0U] & 0xFFFFFFU;
break;
}
/* wait the card is ready for after initialization */
else if (command.response[0U] & SDMMC_MASK(kSDIO_OcrPowerUpBusyFlag))
{
break;
}
}
return ((i != 0U) ? kStatus_Success : kStatus_Fail);
}
status_t SDIO_IO_Write_Direct(sdio_card_t *card, sdio_func_num_t func, uint32_t regAddr, uint8_t *data, bool raw)
{
assert(card);
assert(func <= kSDIO_FunctionNum7);
SDMMCHOST_TRANSFER content = {0U};
SDMMCHOST_COMMAND command = {0U};
command.index = kSDIO_RWIODirect;
command.argument = (func << SDIO_CMD_ARGUMENT_FUNC_NUM_POS) |
((regAddr & SDIO_CMD_ARGUMENT_REG_ADDR_MASK) << SDIO_CMD_ARGUMENT_REG_ADDR_POS) |
(1U << SDIO_CMD_ARGUMENT_RW_POS) | ((raw ? 1U : 0U) << SDIO_DIRECT_CMD_ARGUMENT_RAW_POS) |
(*data & SDIO_DIRECT_CMD_DATA_MASK);
command.responseType = kCARD_ResponseTypeR5;
command.responseErrorFlags = (kSDIO_StatusCmdCRCError | kSDIO_StatusIllegalCmd | kSDIO_StatusError |
kSDIO_StatusFunctionNumError | kSDIO_StatusOutofRange);
content.command = &command;
content.data = NULL;
if (kStatus_Success != card->host.transfer(card->host.base, &content))
{
return kStatus_SDMMC_TransferFailed;
}
/* read data from response */
*data = command.response[0U] & SDIO_DIRECT_CMD_DATA_MASK;
return kStatus_Success;
}
status_t SDIO_IO_Read_Direct(sdio_card_t *card, sdio_func_num_t func, uint32_t regAddr, uint8_t *data)
{
assert(card);
assert(func <= kSDIO_FunctionNum7);
SDMMCHOST_TRANSFER content = {0U};
SDMMCHOST_COMMAND command = {0U};
command.index = kSDIO_RWIODirect;
command.argument = (func << SDIO_CMD_ARGUMENT_FUNC_NUM_POS) |
((regAddr & SDIO_CMD_ARGUMENT_REG_ADDR_MASK) << SDIO_CMD_ARGUMENT_REG_ADDR_POS);
command.responseType = kCARD_ResponseTypeR5;
command.responseErrorFlags = (kSDIO_StatusCmdCRCError | kSDIO_StatusIllegalCmd | kSDIO_StatusError |
kSDIO_StatusFunctionNumError | kSDIO_StatusOutofRange);
content.command = &command;
content.data = NULL;
if (kStatus_Success != card->host.transfer(card->host.base, &content))
{
return kStatus_SDMMC_TransferFailed;
}
/* read data from response */
*data = command.response[0U] & SDIO_DIRECT_CMD_DATA_MASK;
return kStatus_Success;
}
status_t SDIO_IO_RW_Direct(sdio_card_t *card,
sdio_io_direction_t direction,
sdio_func_num_t func,
uint32_t regAddr,
uint8_t dataIn,
uint8_t *dataOut)
{
assert(card);
assert(func <= kSDIO_FunctionNum7);
SDMMCHOST_TRANSFER content = {0U};
SDMMCHOST_COMMAND command = {0U};
command.index = kSDIO_RWIODirect;
command.argument = (func << SDIO_CMD_ARGUMENT_FUNC_NUM_POS) |
((regAddr & SDIO_CMD_ARGUMENT_REG_ADDR_MASK) << SDIO_CMD_ARGUMENT_REG_ADDR_POS);
if ((dataOut != NULL) && (direction == kSDIO_IOWrite))
{
command.argument |= (1U << SDIO_CMD_ARGUMENT_RW_POS) | (1U << SDIO_DIRECT_CMD_ARGUMENT_RAW_POS);
}
if (direction == kSDIO_IOWrite)
{
command.argument |= dataIn & SDIO_DIRECT_CMD_DATA_MASK;
}
command.responseType = kCARD_ResponseTypeR5;
command.responseErrorFlags = (kSDIO_StatusCmdCRCError | kSDIO_StatusIllegalCmd | kSDIO_StatusError |
kSDIO_StatusFunctionNumError | kSDIO_StatusOutofRange);
command.responseType = kCARD_ResponseTypeR5;
command.responseErrorFlags = (kSDIO_StatusCmdCRCError | kSDIO_StatusIllegalCmd | kSDIO_StatusError |
kSDIO_StatusFunctionNumError | kSDIO_StatusOutofRange);
content.command = &command;
content.data = NULL;
if (kStatus_Success != card->host.transfer(card->host.base, &content))
{
return kStatus_SDMMC_TransferFailed;
}
if (dataOut != NULL)
{
/* read data from response */
*dataOut = command.response[0U] & SDIO_DIRECT_CMD_DATA_MASK;
}
return kStatus_Success;
}
status_t SDIO_IO_Write_Extended(
sdio_card_t *card, sdio_func_num_t func, uint32_t regAddr, uint8_t *buffer, uint32_t count, uint32_t flags)
{
assert(card);
assert(buffer);
assert(func <= kSDIO_FunctionNum7);
SDMMCHOST_TRANSFER content = {0U};
SDMMCHOST_COMMAND command = {0U};
SDMMCHOST_DATA data = {0U};
bool blockMode = false;
bool opCode = false;
/* check if card support block mode */
if ((card->cccrflags & kSDIO_CCCRSupportMultiBlock) && (flags & SDIO_EXTEND_CMD_BLOCK_MODE_MASK))
{
blockMode = true;
}
if (flags & SDIO_EXTEND_CMD_OP_CODE_MASK)
{
opCode = true;
}
/* check the byte size counter in non-block mode
* so you need read CIS for each function first,before you do read/write
*/
if (!blockMode)
{
if ((func == kSDIO_FunctionNum0) && (card->commonCIS.fn0MaxBlkSize != 0U) &&
(count > card->commonCIS.fn0MaxBlkSize))
{
return kStatus_SDMMC_SDIO_InvalidArgument;
}
else if ((func != kSDIO_FunctionNum0) && (card->funcCIS[func - 1U].ioMaxBlockSize != 0U) &&
(count > card->funcCIS[func - 1U].ioMaxBlockSize))
{
return kStatus_SDMMC_SDIO_InvalidArgument;
}
}
command.index = kSDIO_RWIOExtended;
command.argument = (func << SDIO_CMD_ARGUMENT_FUNC_NUM_POS) |
((regAddr & SDIO_CMD_ARGUMENT_REG_ADDR_MASK) << SDIO_CMD_ARGUMENT_REG_ADDR_POS) |
(1U << SDIO_CMD_ARGUMENT_RW_POS) | (count & SDIO_EXTEND_CMD_COUNT_MASK) |
((blockMode ? 1 : 0) << SDIO_EXTEND_CMD_ARGUMENT_BLOCK_MODE_POS |
((opCode ? 1 : 0) << SDIO_EXTEND_CMD_ARGUMENT_OP_CODE_POS));
command.responseType = kCARD_ResponseTypeR5;
command.responseErrorFlags = (kSDIO_StatusCmdCRCError | kSDIO_StatusIllegalCmd | kSDIO_StatusError |
kSDIO_StatusFunctionNumError | kSDIO_StatusOutofRange);
if (blockMode)
{
if (func == kSDIO_FunctionNum0)
{
data.blockSize = card->io0blockSize;
}
else
{
data.blockSize = card->ioFBR[func - 1U].ioBlockSize;
}
data.blockCount = count;
}
else
{
data.blockSize = count;
data.blockCount = 1U;
}
data.txData = (uint32_t *)buffer;
content.command = &command;
content.data = &data;
if (kStatus_Success != card->host.transfer(card->host.base, &content))
{
return kStatus_SDMMC_TransferFailed;
}
return kStatus_Success;
}
status_t SDIO_IO_Read_Extended(
sdio_card_t *card, sdio_func_num_t func, uint32_t regAddr, uint8_t *buffer, uint32_t count, uint32_t flags)
{
assert(card);
assert(buffer);
assert(func <= kSDIO_FunctionNum7);
SDMMCHOST_TRANSFER content = {0U};
SDMMCHOST_COMMAND command = {0U};
SDMMCHOST_DATA data = {0U};
bool blockMode = false;
bool opCode = false;
/* check if card support block mode */
if ((card->cccrflags & kSDIO_CCCRSupportMultiBlock) && (flags & SDIO_EXTEND_CMD_BLOCK_MODE_MASK))
{
blockMode = true;
}
/* op code =0 : read/write to fixed addr
* op code =1 :read/write addr incrementing
*/
if (flags & SDIO_EXTEND_CMD_OP_CODE_MASK)
{
opCode = true;
}
/* check the byte size counter in non-block mode
* so you need read CIS for each function first,before you do read/write
*/
if (!blockMode)
{
if ((func == kSDIO_FunctionNum0) && (card->commonCIS.fn0MaxBlkSize != 0U) &&
(count > card->commonCIS.fn0MaxBlkSize))
{
return kStatus_SDMMC_SDIO_InvalidArgument;
}
else if ((func != kSDIO_FunctionNum0) && (card->funcCIS[func - 1U].ioMaxBlockSize != 0U) &&
(count > card->funcCIS[func - 1U].ioMaxBlockSize))
{
return kStatus_SDMMC_SDIO_InvalidArgument;
}
}
command.index = kSDIO_RWIOExtended;
command.argument = (func << SDIO_CMD_ARGUMENT_FUNC_NUM_POS) |
((regAddr & SDIO_CMD_ARGUMENT_REG_ADDR_MASK) << SDIO_CMD_ARGUMENT_REG_ADDR_POS) |
(count & SDIO_EXTEND_CMD_COUNT_MASK) |
((blockMode ? 1U : 0U) << SDIO_EXTEND_CMD_ARGUMENT_BLOCK_MODE_POS |
((opCode ? 1U : 0U) << SDIO_EXTEND_CMD_ARGUMENT_OP_CODE_POS));
command.responseType = kCARD_ResponseTypeR5;
command.responseErrorFlags = (kSDIO_StatusCmdCRCError | kSDIO_StatusIllegalCmd | kSDIO_StatusError |
kSDIO_StatusFunctionNumError | kSDIO_StatusOutofRange);
if (blockMode)
{
if (func == kSDIO_FunctionNum0)
{
data.blockSize = card->io0blockSize;
}
else
{
data.blockSize = card->ioFBR[func - 1U].ioBlockSize;
}
data.blockCount = count;
}
else
{
data.blockSize = count;
data.blockCount = 1U;
}
data.rxData = (uint32_t *)buffer;
content.command = &command;
content.data = &data;
if (kStatus_Success != card->host.transfer(card->host.base, &content))
{
return kStatus_SDMMC_TransferFailed;
}
return kStatus_Success;
}
status_t SDIO_IO_Transfer(sdio_card_t *card,
sdio_command_t cmd,
uint32_t argument,
uint32_t blockSize,
uint8_t *txData,
uint8_t *rxData,
uint16_t dataSize,
uint32_t *response)
{
assert(card != NULL);
uint32_t actualSize = dataSize;
SDMMCHOST_TRANSFER content = {0U};
SDMMCHOST_COMMAND command = {0U};
SDMMCHOST_DATA data = {0U};
uint32_t i = SDIO_RETRY_TIMES;
uint32_t *dataAddr = (uint32_t *)(txData == NULL ? rxData : txData);
if ((dataSize != 0U) && (txData != NULL) && (rxData != NULL))
{
return kStatus_InvalidArgument;
}
command.index = cmd;
command.argument = argument;
command.responseType = kCARD_ResponseTypeR5;
command.responseErrorFlags = (kSDIO_StatusCmdCRCError | kSDIO_StatusIllegalCmd | kSDIO_StatusError |
kSDIO_StatusFunctionNumError | kSDIO_StatusOutofRange);
content.command = &command;
content.data = NULL;
if (dataSize)
{
/* if block size bigger than 1, then use block mode */
if (argument & SDIO_EXTEND_CMD_BLOCK_MODE_MASK)
{
if (dataSize % blockSize != 0)
{
actualSize = ((dataSize / blockSize) + 1) * blockSize;
}
data.blockCount = actualSize / blockSize;
data.blockSize = blockSize;
}
else
{
data.blockCount = 1;
data.blockSize = dataSize;
}
/* if data buffer address can not meet host controller internal DMA requirement, sdio driver will try to use
* internal align buffer if data size is not bigger than internal buffer size,
* Align address transfer always can get a better performance, so if you want sdio driver make buffer address
* align, you should
* redefine the SDMMC_GLOBAL_BUFFER_SIZE macro to a value which is big enough for your application.
*/
if (((uint32_t)dataAddr & (SDMMCHOST_DMA_BUFFER_ADDR_ALIGN - 1U)) &&
(actualSize <= (SDMMC_GLOBAL_BUFFER_SIZE * sizeof(uint32_t))) && (!card->noInternalAlign))
{
dataAddr = (uint32_t *)g_sdmmc;
memset(g_sdmmc, 0U, actualSize);
if (txData)
{
memcpy(g_sdmmc, txData, dataSize);
}
}
if (rxData)
{
data.rxData = dataAddr;
}
else
{
data.txData = dataAddr;
}
content.data = &data;
}
do
{
if (kStatus_Success == card->host.transfer(card->host.base, &content))
{
if ((rxData != NULL) && ((uint32_t)rxData & (SDMMCHOST_DMA_BUFFER_ADDR_ALIGN - 1U)) &&
(actualSize <= (SDMMC_GLOBAL_BUFFER_SIZE * sizeof(uint32_t))) && (!card->noInternalAlign))
{
memcpy(rxData, g_sdmmc, dataSize);
}
if (response != NULL)
{
*response = command.response[0];
}
return kStatus_Success;
}
} while (i--);
return kStatus_Fail;
}
status_t SDIO_GetCardCapability(sdio_card_t *card, sdio_func_num_t func)
{
assert(card);
assert(func <= kSDIO_FunctionNum7);
uint8_t *tempBuffer = (uint8_t *)g_sdmmc;
uint32_t i = 0U;
memset(g_sdmmc, 0U, sizeof(g_sdmmc));
for (i = 0U; i <= SDIO_CCCR_REG_NUMBER; i++)
{
if (kStatus_Success !=
SDIO_IO_RW_Direct(card, kSDIO_IORead, kSDIO_FunctionNum0, SDIO_FBR_BASE(func) + i, 0U, &tempBuffer[i]))
{
return kStatus_SDMMC_TransferFailed;
}
}
switch (func)
{
case kSDIO_FunctionNum0:
card->sdVersion = tempBuffer[kSDIO_RegSDVersion];
card->sdioVersion = tempBuffer[kSDIO_RegCCCRSdioVer] >> 4U;
card->cccrVersioin = tempBuffer[kSDIO_RegCCCRSdioVer] & 0xFU;
/* continuous SPI interrupt */
if (tempBuffer[kSDIO_RegBusInterface] & 0x40U)
{
card->cccrflags |= kSDIO_CCCRSupportContinuousSPIInt;
}
/* 8bit data bus */
if (tempBuffer[kSDIO_RegBusInterface] & 0x4U)
{
card->cccrflags |= SDIO_CCCR_SUPPORT_8BIT_BUS;
}
/* card capability register */
card->cccrflags |= (tempBuffer[kSDIO_RegCardCapability] & 0xDFU);
/* master power control */
if (tempBuffer[kSDIO_RegPowerControl] & 0x01U)
{
card->cccrflags |= kSDIO_CCCRSupportMasterPowerControl;
}
/* high speed flag */
if (tempBuffer[kSDIO_RegBusSpeed] & 0x01U)
{
card->cccrflags |= SDIO_CCCR_SUPPORT_HIGHSPEED;
}
/* uhs mode flag */
card->cccrflags |= (tempBuffer[kSDIO_RegUHSITimingSupport] & 7U) << 11U;
/* driver type flag */
card->cccrflags |= (tempBuffer[kSDIO_RegDriverStrength] & 7U) << 14U;
/* low speed 4bit */
if (tempBuffer[kSDIO_RegCardCapability] & 0x80U)
{
card->cccrflags |= kSDIO_CCCRSupportLowSpeed4Bit;
}
/* common CIS pointer */
card->commonCISPointer = tempBuffer[kSDIO_RegCommonCISPointer] |
(tempBuffer[kSDIO_RegCommonCISPointer + 1U] << 8U) |
(tempBuffer[kSDIO_RegCommonCISPointer + 2U] << 16U);
/* check card capability of support async interrupt */
if ((tempBuffer[kSDIO_RegInterruptExtension] & SDIO_CCCR_ASYNC_INT_MASK) == SDIO_CCCR_ASYNC_INT_MASK)
{
card->cccrflags |= SDIO_CCCR_SUPPORT_ASYNC_INT;
}
break;
case kSDIO_FunctionNum1:
case kSDIO_FunctionNum2:
case kSDIO_FunctionNum3:
case kSDIO_FunctionNum4:
case kSDIO_FunctionNum5:
case kSDIO_FunctionNum6:
case kSDIO_FunctionNum7:
card->ioFBR[func - 1U].ioStdFunctionCode = tempBuffer[0U] & 0x0FU;
card->ioFBR[func - 1U].ioExtFunctionCode = tempBuffer[1U];
card->ioFBR[func - 1U].ioPointerToCIS = tempBuffer[9U] | (tempBuffer[10U] << 8U) | (tempBuffer[11U] << 16U);
card->ioFBR[func - 1U].ioPointerToCSA =
tempBuffer[12U] | (tempBuffer[13U] << 8U) | (tempBuffer[14U] << 16U);
if (tempBuffer[2U] & 0x01U)
{
card->ioFBR[func - 1U].flags |= kSDIO_FBRSupportPowerSelection;
}
if (tempBuffer[0U] & 0x40U)
{
card->ioFBR[func - 1U].flags |= kSDIO_FBRSupportCSA;
}
break;
default:
break;
}
return kStatus_Success;
}
status_t SDIO_SetBlockSize(sdio_card_t *card, sdio_func_num_t func, uint32_t blockSize)
{
assert(card);
assert(func <= kSDIO_FunctionNum7);
assert(blockSize <= SDIO_MAX_BLOCK_SIZE);
uint8_t temp = 0U;
/* check the block size for block mode
* so you need read CIS for each function first,before you do read/write
*/
if ((func == kSDIO_FunctionNum0) && (card->commonCIS.fn0MaxBlkSize != 0U) &&
(blockSize > card->commonCIS.fn0MaxBlkSize))
{
return kStatus_SDMMC_SDIO_InvalidArgument;
}
else if ((func != kSDIO_FunctionNum0) && (card->funcCIS[func - 1U].ioMaxBlockSize != 0U) &&
(blockSize > card->funcCIS[func - 1U].ioMaxBlockSize))
{
return kStatus_SDMMC_SDIO_InvalidArgument;
}
temp = blockSize & 0xFFU;
if (kStatus_Success != SDIO_IO_RW_Direct(card, kSDIO_IOWrite, kSDIO_FunctionNum0,
SDIO_FBR_BASE(func) + kSDIO_RegFN0BlockSizeLow, temp, &temp))
{
return kStatus_SDMMC_SetCardBlockSizeFailed;
}
temp = (blockSize >> 8U) & 0xFFU;
if (kStatus_Success != SDIO_IO_RW_Direct(card, kSDIO_IOWrite, kSDIO_FunctionNum0,
SDIO_FBR_BASE(func) + kSDIO_RegFN0BlockSizeHigh, temp, &temp))
{
return kStatus_SDMMC_SetCardBlockSizeFailed;
}
/* record the current block size */
if (func == kSDIO_FunctionNum0)
{
card->io0blockSize = blockSize;
}
else
{
card->ioFBR[func - 1U].ioBlockSize = blockSize;
}
return kStatus_Success;
}
status_t SDIO_CardReset(sdio_card_t *card)
{
return SDIO_IO_RW_Direct(card, kSDIO_IOWrite, kSDIO_FunctionNum0, kSDIO_RegIOAbort, 0x08U, NULL);
}
status_t SDIO_SetDataBusWidth(sdio_card_t *card, sdio_bus_width_t busWidth)
{
assert(card);
uint8_t regBusInterface = 0U;
if (((busWidth == kSDIO_DataBus4Bit) && ((card->cccrflags & kSDIO_CCCRSupportHighSpeed) == 0U) &&
((card->cccrflags & kSDIO_CCCRSupportLowSpeed4Bit) == 0U)) ||
(((SDMMCHOST_NOT_SUPPORT == kSDMMCHOST_Support8BitBusWidth) ||
((card->cccrflags & SDIO_CCCR_SUPPORT_8BIT_BUS) == 0U)) &&
(busWidth == kSDIO_DataBus8Bit)))
{
return kStatus_SDMMC_SDIO_InvalidArgument;
}
/* load bus interface register */
if (kStatus_Success !=
SDIO_IO_RW_Direct(card, kSDIO_IORead, kSDIO_FunctionNum0, kSDIO_RegBusInterface, 0U, ®BusInterface))
{
return kStatus_SDMMC_TransferFailed;
}
/* set bus width */
regBusInterface &= 0xFCU;
regBusInterface |= busWidth;
/* write to register */
if (kStatus_Success != SDIO_IO_RW_Direct(card, kSDIO_IOWrite, kSDIO_FunctionNum0, kSDIO_RegBusInterface,
regBusInterface, ®BusInterface))
{
return kStatus_SDMMC_TransferFailed;
}
if (busWidth == kSDIO_DataBus8Bit)
{
SDMMCHOST_SET_CARD_BUS_WIDTH(card->host.base, kSDMMCHOST_DATABUSWIDTH8BIT);
}
else if (busWidth == kSDIO_DataBus4Bit)
{
SDMMCHOST_SET_CARD_BUS_WIDTH(card->host.base, kSDMMCHOST_DATABUSWIDTH4BIT);
}
else
{
SDMMCHOST_SET_CARD_BUS_WIDTH(card->host.base, kSDMMCHOST_DATABUSWIDTH1BIT);
}
return kStatus_Success;
}
static status_t SDIO_SetMaxDataBusWidth(sdio_card_t *card)
{
sdio_bus_width_t busWidth = kSDIO_DataBus1Bit;
if ((SDMMCHOST_NOT_SUPPORT != kSDMMCHOST_Support8BitBusWidth) &&
((card->cccrflags & SDIO_CCCR_SUPPORT_8BIT_BUS) != 0U))
{
busWidth = kSDIO_DataBus8Bit;
}
/* switch data bus width */
if (((card->cccrflags & kSDIO_CCCRSupportHighSpeed) || ((card->cccrflags & kSDIO_CCCRSupportLowSpeed4Bit) != 0U)) &&
(busWidth == kSDIO_DataBus1Bit))
{
busWidth = kSDIO_DataBus4Bit;
}
return SDIO_SetDataBusWidth(card, busWidth);
}
status_t SDIO_SwitchToHighSpeed(sdio_card_t *card)
{
assert(card);
uint8_t temp = 0U;
uint32_t retryTimes = SDIO_RETRY_TIMES;
status_t status = kStatus_SDMMC_SDIO_SwitchHighSpeedFail;
if (card->cccrflags & SDIO_CCCR_SUPPORT_HIGHSPEED)
{
if (kStatus_Success != SDIO_IO_RW_Direct(card, kSDIO_IORead, kSDIO_FunctionNum0, kSDIO_RegBusSpeed, 0U, &temp))
{
return kStatus_SDMMC_TransferFailed;
}
temp &= ~SDIO_CCCR_BUS_SPEED_MASK;
temp |= SDIO_CCCR_ENABLE_HIGHSPEED_MODE;
do
{
retryTimes--;
/* enable high speed mode */
if (kStatus_Success !=
SDIO_IO_RW_Direct(card, kSDIO_IOWrite, kSDIO_FunctionNum0, kSDIO_RegBusSpeed, temp, &temp))
{
continue;
}
/* either EHS=0 and SHS=0 ,the card is still in default mode */
if ((temp & 0x03U) == 0x03U)
{
/* high speed mode , set freq to 50MHZ */
card->busClock_Hz =
SDMMCHOST_SET_CARD_CLOCK(card->host.base, card->host.sourceClock_Hz, SD_CLOCK_50MHZ);
status = kStatus_Success;
break;
}
else
{
continue;
}
} while (retryTimes);
}
else
{
/* default mode 25MHZ */
card->busClock_Hz = SDMMCHOST_SET_CARD_CLOCK(card->host.base, card->host.sourceClock_Hz, SD_CLOCK_25MHZ);
status = kStatus_Success;
}
return status;
}
static status_t SDIO_SelectBusTiming(sdio_card_t *card)
{
assert(card);
uint32_t targetBusFreq = SD_CLOCK_25MHZ;
uint32_t targetTiming = 0U;
uint8_t temp = 0U;
uint32_t supportModeFlag = 0U;
do
{
switch (card->currentTiming)
{
/* if not select timing mode, sdmmc will handle it automatically*/
case kSD_TimingSDR12DefaultMode:
case kSD_TimingSDR104Mode:
if ((kSDMMCHOST_SupportSDR104 != SDMMCHOST_NOT_SUPPORT) &&
((card->cccrflags & SDIO_CCCR_SUPPORT_SDR104) == SDIO_CCCR_SUPPORT_SDR104))
{
card->currentTiming = kSD_TimingSDR104Mode;
targetTiming = SDIO_CCCR_ENABLE_SDR104_MODE;
targetBusFreq = SDMMCHOST_SUPPORT_SDR104_FREQ;
supportModeFlag = SDIO_CCCR_SUPPORT_SDR104;
break;
}
case kSD_TimingDDR50Mode:
if ((kSDMMCHOST_SupportDDR50 != SDMMCHOST_NOT_SUPPORT) &&
((card->cccrflags & SDIO_CCCR_SUPPORT_DDR50) == SDIO_CCCR_SUPPORT_DDR50))
{
card->currentTiming = kSD_TimingDDR50Mode;
targetTiming = SDIO_CCCR_ENABLE_DDR50_MODE;
targetBusFreq = SD_CLOCK_50MHZ;
supportModeFlag = SDIO_CCCR_SUPPORT_DDR50;
break;
}
case kSD_TimingSDR50Mode:
if ((kSDMMCHOST_SupportSDR50 != SDMMCHOST_NOT_SUPPORT) &&
((card->cccrflags & SDIO_CCCR_SUPPORT_SDR50) == SDIO_CCCR_SUPPORT_SDR50))
{
card->currentTiming = kSD_TimingSDR50Mode;
targetTiming = SDIO_CCCR_ENABLE_SDR50_MODE;
targetBusFreq = SD_CLOCK_100MHZ;
supportModeFlag = SDIO_CCCR_SUPPORT_SDR50;
break;
}
case kSD_TimingSDR25HighSpeedMode:
if ((card->host.capability.flags & kSDMMCHOST_SupportHighSpeed) &&
(card->cccrflags & SDIO_CCCR_SUPPORT_HIGHSPEED) == SDIO_CCCR_SUPPORT_HIGHSPEED)
{
card->currentTiming = kSD_TimingSDR25HighSpeedMode;
targetTiming = SDIO_CCCR_ENABLE_HIGHSPEED_MODE;
targetBusFreq = SD_CLOCK_50MHZ;
supportModeFlag = SDIO_CCCR_SUPPORT_HIGHSPEED;
break;
}
default:
/* default timing mode */
card->currentTiming = kSD_TimingSDR12DefaultMode;
return kStatus_Success;
}
if (kStatus_Success != SDIO_IO_RW_Direct(card, kSDIO_IORead, kSDIO_FunctionNum0, kSDIO_RegBusSpeed, 0U, &temp))
{
return kStatus_SDMMC_TransferFailed;
}
temp &= ~SDIO_CCCR_BUS_SPEED_MASK;
temp |= targetTiming;
if (kStatus_Success !=
SDIO_IO_RW_Direct(card, kSDIO_IOWrite, kSDIO_FunctionNum0, kSDIO_RegBusSpeed, temp, &temp))
{
return kStatus_SDMMC_TransferFailed;
}
/* if cannot switch target timing, it will switch continuously until find a valid timing. */
if ((temp & targetTiming) != targetTiming)
{
/* need add error log here */
card->cccrflags &= ~supportModeFlag;
continue;
}
break;
} while (1);
card->busClock_Hz = SDMMCHOST_SET_CARD_CLOCK(card->host.base, card->host.sourceClock_Hz, targetBusFreq);
/* enable DDR mode if it is the target mode */
if (card->currentTiming == kSD_TimingDDR50Mode)
{
SDMMCHOST_ENABLE_DDR_MODE(card->host.base, true, 0U);
}
/* SDR50 and SDR104 mode need tuning */
if ((card->currentTiming == kSD_TimingSDR50Mode) || (card->currentTiming == kSD_TimingSDR104Mode))
{
/* config IO strength in IOMUX*/
if (card->currentTiming == kSD_TimingSDR50Mode)
{
SDMMCHOST_CONFIG_SD_IO(CARD_BUS_FREQ_100MHZ1, CARD_BUS_STRENGTH_7);
}
else
{
SDMMCHOST_CONFIG_SD_IO(CARD_BUS_FREQ_200MHZ, CARD_BUS_STRENGTH_7);
}
/* execute tuning */
if (SDIO_ExecuteTuning(card) != kStatus_Success)
{
return kStatus_SDMMC_TuningFail;
}
}
else
{
/* set default IO strength to 4 to cover card adapter driver strength difference */
SDMMCHOST_CONFIG_SD_IO(CARD_BUS_FREQ_100MHZ1, CARD_BUS_STRENGTH_4);
}
return kStatus_Success;
}
status_t SDIO_SetDriverStrength(sdio_card_t *card, sd_driver_strength_t driverStrength)
{
uint8_t strength = 0U, temp = 0U;
switch (driverStrength)
{
case kSD_DriverStrengthTypeA:
strength = SDIO_CCCR_ENABLE_DRIVER_TYPE_A;
break;
case kSD_DriverStrengthTypeC:
strength = SDIO_CCCR_ENABLE_DRIVER_TYPE_C;
break;
case kSD_DriverStrengthTypeD:
strength = SDIO_CCCR_ENABLE_DRIVER_TYPE_D;
break;
default:
strength = SDIO_CCCR_ENABLE_DRIVER_TYPE_B;
break;
}
if (kStatus_Success !=
SDIO_IO_RW_Direct(card, kSDIO_IORead, kSDIO_FunctionNum0, kSDIO_RegDriverStrength, 0U, &temp))
{
return kStatus_SDMMC_TransferFailed;
}
temp &= ~SDIO_CCCR_DRIVER_TYPE_MASK;
temp |= strength;
return SDIO_IO_RW_Direct(card, kSDIO_IOWrite, kSDIO_FunctionNum0, kSDIO_RegDriverStrength, temp, &temp);
}
status_t SDIO_EnableAsyncInterrupt(sdio_card_t *card, bool enable)
{
assert(card);
uint8_t eai = 0U;
if ((card->cccrflags & SDIO_CCCR_SUPPORT_ASYNC_INT) == 0U)
{
return kStatus_SDMMC_NotSupportYet;
}
/* load interrupt enable register */
if (kStatus_Success !=
SDIO_IO_RW_Direct(card, kSDIO_IORead, kSDIO_FunctionNum0, kSDIO_RegInterruptExtension, 0U, &eai))
{
return kStatus_SDMMC_TransferFailed;
}
/* if already enable/disable , do not need enable/disable again */
if (((eai)&SDIO_CCCR_ENABLE_AYNC_INT) == (enable ? SDIO_CCCR_ENABLE_AYNC_INT : 0U))
{
return kStatus_Success;
}
/* enable the eai */
if (enable)
{
eai |= SDIO_CCCR_ENABLE_AYNC_INT;
}
else
{
eai &= ~(SDIO_CCCR_ENABLE_AYNC_INT);
}
/* write to register */
if (kStatus_Success !=
SDIO_IO_RW_Direct(card, kSDIO_IOWrite, kSDIO_FunctionNum0, kSDIO_RegInterruptExtension, eai, &eai))
{
return kStatus_SDMMC_TransferFailed;
}
return kStatus_Success;
}
static status_t SDIO_DecodeCIS(
sdio_card_t *card, sdio_func_num_t func, uint8_t *dataBuffer, uint32_t tplCode, uint32_t tplLink)
{
assert(card);
assert(func <= kSDIO_FunctionNum7);
if (func == kSDIO_FunctionNum0)
{
/* only decode MANIFID,FUNCID,FUNCE here */
if (tplCode == SDIO_TPL_CODE_MANIFID)
{
card->commonCIS.mID = dataBuffer[0U] | (dataBuffer[1U] << 8U);
card->commonCIS.mInfo = dataBuffer[2U] | (dataBuffer[3U] << 8U);
}
else if (tplCode == SDIO_TPL_CODE_FUNCID)
{
card->commonCIS.funcID = dataBuffer[0U];
}
else if (tplCode == SDIO_TPL_CODE_FUNCE)
{
/* max transfer block size and data size */
card->commonCIS.fn0MaxBlkSize = dataBuffer[1U] | (dataBuffer[2U] << 8U);
/* max transfer speed */
card->commonCIS.maxTransSpeed = dataBuffer[3U];
}
else
{
/* reserved here */
return kStatus_Fail;
}
}
else
{
/* only decode FUNCID,FUNCE here */
if (tplCode == SDIO_TPL_CODE_FUNCID)
{
card->funcCIS[func].funcID = dataBuffer[0U];
}
else if (tplCode == SDIO_TPL_CODE_FUNCE)
{
if (tplLink == 0x2A)
{
card->funcCIS[func - 1U].funcInfo = dataBuffer[1U];
card->funcCIS[func - 1U].ioVersion = dataBuffer[2U];
card->funcCIS[func - 1U].cardPSN =
dataBuffer[3U] | (dataBuffer[4U] << 8U) | (dataBuffer[5U] << 16U) | (dataBuffer[6U] << 24U);
card->funcCIS[func - 1U].ioCSASize =
dataBuffer[7U] | (dataBuffer[8U] << 8U) | (dataBuffer[9U] << 16U) | (dataBuffer[10U] << 24U);
card->funcCIS[func - 1U].ioCSAProperty = dataBuffer[11U];
card->funcCIS[func - 1U].ioMaxBlockSize = dataBuffer[12U] | (dataBuffer[13U] << 8U);
card->funcCIS[func - 1U].ioOCR =
dataBuffer[14U] | (dataBuffer[15U] << 8U) | (dataBuffer[16U] << 16U) | (dataBuffer[17U] << 24U);
card->funcCIS[func - 1U].ioOPMinPwr = dataBuffer[18U];
card->funcCIS[func - 1U].ioOPAvgPwr = dataBuffer[19U];
card->funcCIS[func - 1U].ioOPMaxPwr = dataBuffer[20U];
card->funcCIS[func - 1U].ioSBMinPwr = dataBuffer[21U];
card->funcCIS[func - 1U].ioSBAvgPwr = dataBuffer[22U];
card->funcCIS[func - 1U].ioSBMaxPwr = dataBuffer[23U];
card->funcCIS[func - 1U].ioMinBandWidth = dataBuffer[24U] | (dataBuffer[25U] << 8U);
card->funcCIS[func - 1U].ioOptimumBandWidth = dataBuffer[26U] | (dataBuffer[27U] << 8U);
card->funcCIS[func - 1U].ioReadyTimeout = dataBuffer[28U] | (dataBuffer[29U] << 8U);
card->funcCIS[func - 1U].ioHighCurrentAvgCurrent = dataBuffer[34U] | (dataBuffer[35U] << 8U);
card->funcCIS[func - 1U].ioHighCurrentMaxCurrent = dataBuffer[36U] | (dataBuffer[37U] << 8U);
card->funcCIS[func - 1U].ioLowCurrentAvgCurrent = dataBuffer[38U] | (dataBuffer[39U] << 8U);
card->funcCIS[func - 1U].ioLowCurrentMaxCurrent = dataBuffer[40U] | (dataBuffer[41U] << 8U);
}
else
{
return kStatus_Fail;
}
}
else
{
return kStatus_Fail;
}
}
return kStatus_Success;
}
status_t SDIO_ReadCIS(sdio_card_t *card, sdio_func_num_t func, const uint32_t *tupleList, uint32_t tupleNum)
{
assert(card);
assert(func <= kSDIO_FunctionNum7);
assert(tupleList);
uint8_t tplCode = 0U;
uint8_t tplLink = 0U;
uint32_t cisPtr = 0U;
uint32_t i = 0U, num = 0U;
bool tupleMatch = false;
uint8_t dataBuffer[255U] = {0U};
/* get the CIS pointer for each function */
if (func == kSDIO_FunctionNum0)
{
cisPtr = card->commonCISPointer;
}
else
{
cisPtr = card->ioFBR[func - 1U].ioPointerToCIS;
}
if (0U == cisPtr)
{
return kStatus_SDMMC_SDIO_ReadCISFail;
}
do
{
if (kStatus_Success != SDIO_IO_RW_Direct(card, kSDIO_IORead, kSDIO_FunctionNum0, cisPtr++, 0U, &tplCode))
{
return kStatus_SDMMC_TransferFailed;
}
/* end of chain tuple */
if (tplCode == 0xFFU)
{
break;
}
if (tplCode == 0U)
{
continue;
}
for (i = 0; i < tupleNum; i++)
{
if (tplCode == tupleList[i])
{
tupleMatch = true;
break;
}
}
if (kStatus_Success != SDIO_IO_RW_Direct(card, kSDIO_IORead, kSDIO_FunctionNum0, cisPtr++, 0U, &tplLink))
{
return kStatus_SDMMC_TransferFailed;
}
/* end of chain tuple */
if (tplLink == 0xFFU)
{
break;
}
if (tupleMatch)
{
memset(dataBuffer, 0U, 255U);
for (i = 0; i < tplLink; i++)
{
if (kStatus_Success !=
SDIO_IO_RW_Direct(card, kSDIO_IORead, kSDIO_FunctionNum0, cisPtr++, 0U, &dataBuffer[i]))
{
return kStatus_SDMMC_TransferFailed;
}
}
tupleMatch = false;
/* pharse the data */
SDIO_DecodeCIS(card, func, dataBuffer, tplCode, tplLink);
/* read finish then return */
if (++num == tupleNum)
{
break;
}
}
else
{
/* move pointer */
cisPtr += tplLink;
/* tuple code not match,continue read tuple code */
continue;
}
} while (1);
return kStatus_Success;
}
static status_t SDIO_ProbeBusVoltage(sdio_card_t *card)
{
assert(card);
uint32_t ocr = 0U;
status_t error = kStatus_Success;
/* application able to set the supported voltage window */
if ((card->ocr & SDIO_OCR_VOLTAGE_WINDOW_MASK) != 0U)
{
ocr = card->ocr & SDIO_OCR_VOLTAGE_WINDOW_MASK;
}
else
{
/* 3.3V voltage should be supported as default */
ocr |= SDMMC_MASK(kSD_OcrVdd29_30Flag) | SDMMC_MASK(kSD_OcrVdd32_33Flag) | SDMMC_MASK(kSD_OcrVdd33_34Flag);
}
/* allow user select the work voltage, if not select, sdmmc will handle it automatically */
if (kSDMMCHOST_SupportV180 != SDMMCHOST_NOT_SUPPORT)
{
ocr |= SDMMC_MASK(kSD_OcrSwitch18RequestFlag);
}
do
{
/* card go idle */
if (kStatus_Success != SDIO_GoIdle(card))
{
return kStatus_SDMMC_GoIdleFailed;
}
/* Get IO OCR-CMD5 with arg0 ,set new voltage if needed*/
if (kStatus_Success != SDIO_SendOperationCondition(card, 0U))
{
return kStatus_SDMMC_HandShakeOperationConditionFailed;
}
if (kStatus_Success != SDIO_SendOperationCondition(card, ocr))
{
return kStatus_SDMMC_InvalidVoltage;
}
/* check if card support 1.8V */
if ((card->ocr & SDMMC_MASK(kSD_OcrSwitch18AcceptFlag)) != 0U)
{
error = SDIO_SwitchVoltage(card);
if (kStatus_SDMMC_SwitchVoltageFail == error)
{
break;
}
if (error == kStatus_SDMMC_SwitchVoltage18VFail33VSuccess)
{
ocr &= ~SDMMC_MASK(kSD_OcrSwitch18RequestFlag);
error = kStatus_Success;
continue;
}
else
{
card->operationVoltage = kCARD_OperationVoltage180V;
break;
}
}
break;
} while (1U);
return error;
}
status_t SDIO_CardInit(sdio_card_t *card)
{
assert(card);
if (!card->isHostReady)
{
return kStatus_SDMMC_HostNotReady;
}
/* Identify mode ,set clock to 400KHZ. */
card->busClock_Hz = SDMMCHOST_SET_CARD_CLOCK(card->host.base, card->host.sourceClock_Hz, SDMMC_CLOCK_400KHZ);
SDMMCHOST_SET_CARD_BUS_WIDTH(card->host.base, kSDMMCHOST_DATABUSWIDTH1BIT);
SDMMCHOST_SEND_CARD_ACTIVE(card->host.base, 100U);
/* get host capability */
GET_SDMMCHOST_CAPABILITY(card->host.base, &(card->host.capability));
if (SDIO_ProbeBusVoltage(card) != kStatus_Success)
{
return kStatus_SDMMC_SwitchVoltageFail;
}
/* there is a memonly card */
if ((card->ioTotalNumber == 0U) && (card->memPresentFlag))
{
return kStatus_SDMMC_SDIO_InvalidCard;
}
/* send relative address ,cmd3*/
if (kStatus_Success != SDIO_SendRca(card))
{
return kStatus_SDMMC_SendRelativeAddressFailed;
}
/* select card cmd7 */
if (kStatus_Success != SDIO_SelectCard(card, true))
{
return kStatus_SDMMC_SelectCardFailed;
}
/* get card capability */
if (kStatus_Success != SDIO_GetCardCapability(card, kSDIO_FunctionNum0))
{
return kStatus_SDMMC_TransferFailed;
}
/* read common CIS here */
if (SDIO_ReadCIS(card, kSDIO_FunctionNum0, g_tupleList, SDIO_COMMON_CIS_TUPLE_NUM))
{
return kStatus_SDMMC_SDIO_ReadCISFail;
}
/* switch data bus width */
if (kStatus_Success != SDIO_SetMaxDataBusWidth(card))
{
return kStatus_SDMMC_SetDataBusWidthFailed;
}
/* trying switch to card support timing mode. */
if (kStatus_Success != SDIO_SelectBusTiming(card))
{
return kStatus_SDMMC_SDIO_SwitchHighSpeedFail;
}
return kStatus_Success;
}
void SDIO_CardDeinit(sdio_card_t *card)
{
assert(card);
SDIO_CardReset(card);
SDIO_SelectCard(card, false);
}
status_t SDIO_HostInit(sdio_card_t *card)
{
assert(card);
if ((!card->isHostReady) && SDMMCHOST_Init(&(card->host), (void *)(&(card->usrParam))) != kStatus_Success)
{
return kStatus_Fail;
}
/* set the host status flag, after the card re-plug in, don't need init host again */
card->isHostReady = true;
SDMMCHOST_ENABLE_SDIO_INT(card->host.base);
return kStatus_Success;
}
void SDIO_HostDeinit(sdio_card_t *card)
{
assert(card);
SDMMCHOST_Deinit(&(card->host));
/* should re-init host */
card->isHostReady = false;
}
void SDIO_HostReset(SDMMCHOST_CONFIG *host)
{
SDMMCHOST_Reset(host->base);
}
status_t SDIO_WaitCardDetectStatus(SDMMCHOST_TYPE *hostBase, const sdmmchost_detect_card_t *cd, bool waitCardStatus)
{
return SDMMCHOST_WaitCardDetectStatus(hostBase, cd, waitCardStatus);
}
bool SDIO_IsCardPresent(sdio_card_t *card)
{
return SDMMCHOST_IsCardPresent();
}
void SDIO_PowerOnCard(SDMMCHOST_TYPE *base, const sdmmchost_pwr_card_t *pwr)
{
SDMMCHOST_PowerOnCard(base, pwr);
}
void SDIO_PowerOffCard(SDMMCHOST_TYPE *base, const sdmmchost_pwr_card_t *pwr)
{
SDMMCHOST_PowerOffCard(base, pwr);
}
status_t SDIO_Init(sdio_card_t *card)
{
assert(card);
assert(card->host.base);
if (!card->isHostReady)
{
if (SDIO_HostInit(card) != kStatus_Success)
{
return kStatus_SDMMC_HostNotReady;
}
}
else
{
/* reset the host */
SDIO_HostReset(&(card->host));
}
/* power off card */
SDIO_PowerOffCard(card->host.base, card->usrParam.pwr);
/* card detect */
if (SDIO_WaitCardDetectStatus(card->host.base, card->usrParam.cd, true) != kStatus_Success)
{
return kStatus_SDMMC_CardDetectFailed;
}
/* power on card */
SDIO_PowerOnCard(card->host.base, card->usrParam.pwr);
return SDIO_CardInit(card);
}
void SDIO_Deinit(sdio_card_t *card)
{
assert(card);
SDIO_CardDeinit(card);
SDIO_HostDeinit(card);
}
status_t SDIO_EnableIOInterrupt(sdio_card_t *card, sdio_func_num_t func, bool enable)
{
assert(card);
assert(func <= kSDIO_FunctionNum7);
uint8_t intEn = 0U;
/* load io interrupt enable register */
if (kStatus_Success != SDIO_IO_RW_Direct(card, kSDIO_IORead, kSDIO_FunctionNum0, kSDIO_RegIOIntEnable, 0U, &intEn))
{
return kStatus_SDMMC_TransferFailed;
}
if (enable)
{
/* if already enable , do not need enable again */
if ((((intEn >> func) & 0x01U) == 0x01U) && (intEn & 0x01U))
{
return kStatus_Success;
}
/* enable the interrupt and interrupt master */
intEn |= (1U << func) | 0x01U;
card->ioIntNums++;
}
else
{
/* if already disable , do not need enable again */
if (((intEn >> func) & 0x01U) == 0x00U)
{
return kStatus_Success;
}
/* disable the interrupt, don't disable the interrupt master here */
intEn &= ~(1U << func);
if (card->ioIntNums)
{
card->ioIntNums--;
}
}
/* write to register */
if (kStatus_Success !=
SDIO_IO_RW_Direct(card, kSDIO_IOWrite, kSDIO_FunctionNum0, kSDIO_RegIOIntEnable, intEn, &intEn))
{
return kStatus_SDMMC_TransferFailed;
}
return kStatus_Success;
}
status_t SDIO_GetPendingInterrupt(sdio_card_t *card, uint8_t *pendingInt)
{
assert(card);
/* load io interrupt enable register */
if (kStatus_Success !=
SDIO_IO_RW_Direct(card, kSDIO_IORead, kSDIO_FunctionNum0, kSDIO_RegIOIntPending, 0U, pendingInt))
{
return kStatus_SDMMC_TransferFailed;
}
return kStatus_Success;
}
status_t SDIO_EnableIO(sdio_card_t *card, sdio_func_num_t func, bool enable)
{
assert(card);
assert(func <= kSDIO_FunctionNum7);
assert(func != kSDIO_FunctionNum0);
uint8_t ioEn = 0U, ioReady = 0U;
volatile uint32_t i = SDIO_RETRY_TIMES;
uint32_t ioReadyTimeoutMS = card->funcCIS[func - 1U].ioReadyTimeout * SDIO_IO_READY_TIMEOUT_UNIT;
if (ioReadyTimeoutMS != 0U)
{
/* do not poll the IO ready status, but use IO ready timeout */
i = 1U;
}
/* load io enable register */
if (kStatus_Success != SDIO_IO_RW_Direct(card, kSDIO_IORead, kSDIO_FunctionNum0, kSDIO_RegIOEnable, 0U, &ioEn))
{
return kStatus_SDMMC_TransferFailed;
}
/* if already enable/disable , do not need enable/disable again */
if (((ioEn >> func) & 0x01U) == (enable ? 1U : 0U))
{
return kStatus_Success;
}
/* enable the io */
if (enable)
{
ioEn |= (1U << func);
}
else
{
ioEn &= ~(1U << func);
}
/* write to register */
if (kStatus_Success != SDIO_IO_RW_Direct(card, kSDIO_IOWrite, kSDIO_FunctionNum0, kSDIO_RegIOEnable, ioEn, &ioEn))
{
return kStatus_SDMMC_TransferFailed;
}
/* if enable io, need check the IO ready status */
if (enable)
{
do
{
SDMMCHOST_Delay(ioReadyTimeoutMS);
/* wait IO ready */
if (kStatus_Success !=
SDIO_IO_RW_Direct(card, kSDIO_IORead, kSDIO_FunctionNum0, kSDIO_RegIOReady, 0U, &ioReady))
{
return kStatus_SDMMC_TransferFailed;
}
/* check if IO ready */
if ((ioReady & (1 << func)) != 0U)
{
return kStatus_Success;
}
i--;
} while (i);
return kStatus_Fail;
}
return kStatus_Success;
}
status_t SDIO_SelectIO(sdio_card_t *card, sdio_func_num_t func)
{
assert(card);
assert(func <= kSDIO_FunctionMemory);
uint8_t ioSel = func;
/* write to register */
if (kStatus_Success !=
SDIO_IO_RW_Direct(card, kSDIO_IOWrite, kSDIO_FunctionNum0, kSDIO_RegFunctionSelect, ioSel, &ioSel))
{
return kStatus_SDMMC_TransferFailed;
}
return kStatus_Success;
}
status_t SDIO_AbortIO(sdio_card_t *card, sdio_func_num_t func)
{
assert(card);
assert(func <= kSDIO_FunctionNum7);
uint8_t ioAbort = func;
/* write to register */
if (kStatus_Success !=
SDIO_IO_RW_Direct(card, kSDIO_IOWrite, kSDIO_FunctionNum0, kSDIO_RegIOAbort, ioAbort, &ioAbort))
{
return kStatus_SDMMC_TransferFailed;
}
return kStatus_Success;
}
void SDIO_SetIOIRQHandler(sdio_card_t *card, sdio_func_num_t func, sdio_io_irq_handler_t handler)
{
assert(card);
assert((func <= kSDIO_FunctionNum7) && (func != kSDIO_FunctionNum0));
card->ioIRQHandler[func - 1] = handler;
card->ioIntIndex = func;
}
status_t SDIO_HandlePendingIOInterrupt(sdio_card_t *card)
{
assert(card);
uint8_t i = 0, pendingInt = 0;
/* call IRQ handler directly if one IRQ handler only */
if (card->ioIntNums == 1U)
{
if (card->ioIRQHandler[card->ioIntIndex - 1])
{
(card->ioIRQHandler[card->ioIntIndex - 1])(card, card->ioIntIndex);
}
}
else
{
/* get pending int firstly */
if (SDIO_GetPendingInterrupt(card, &pendingInt) != kStatus_Success)
{
return kStatus_SDMMC_TransferFailed;
}
for (i = 1; i <= FSL_SDIO_MAX_IO_NUMS; i++)
{
if (pendingInt & (1 << i))
{
if (card->ioIRQHandler[i - 1])
{
(card->ioIRQHandler[i - 1])(card, i);
}
}
}
}
return kStatus_Success;
}
| 26,118 |
892 | {
"schema_version": "1.2.0",
"id": "GHSA-xc8p-9vx8-gcj4",
"modified": "2022-05-13T01:53:06Z",
"published": "2022-05-13T01:53:06Z",
"aliases": [
"CVE-2018-6400"
],
"details": "Kingsoft WPS Office Free 10.2.0.5978 allows local users to gain privileges or cause a denial of service by impersonating all the pipes through a use of \\\\.\\pipe\\WPSCloudSvr\\WpsCloudSvr -- an \"insecurely created named pipe.\" Ensures full access to Everyone users group.",
"severity": [
{
"type": "CVSS_V3",
"score": "CVSS:3.0/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H"
}
],
"affected": [
],
"references": [
{
"type": "ADVISORY",
"url": "https://nvd.nist.gov/vuln/detail/CVE-2018-6400"
},
{
"type": "WEB",
"url": "http://seclists.org/fulldisclosure/2018/Mar/27"
}
],
"database_specific": {
"cwe_ids": [
],
"severity": "HIGH",
"github_reviewed": false
}
} | 442 |
421 | /**
* Shared Mutex from:
* http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2406.html#shared_mutex
*/
using namespace std;
class shared_mutex
{
mutex mut_;
condition_variable gate1_;
condition_variable gate2_;
unsigned state_;
static const unsigned write_entered_ = 1U << (sizeof(unsigned)*CHAR_BIT - 1);
static const unsigned n_readers_ = ~write_entered_;
public:
shared_mutex() : state_(0) {}
// Exclusive ownership
void lock();
bool try_lock();
void unlock();
// Shared ownership
void lock_shared();
bool try_lock_shared();
void unlock_shared();
};
// Exclusive ownership
void
shared_mutex::lock()
{
unique_lock<mutex> lk(mut_);
while (state_ & write_entered_)
gate1_.wait(lk);
state_ |= write_entered_;
while (state_ & n_readers_)
gate2_.wait(lk);
}
bool
shared_mutex::try_lock()
{
unique_lock<mutex> lk(mut_, try_to_lock);
if (lk.owns_lock() && state_ == 0)
{
state_ = write_entered_;
return true;
}
return false;
}
void
shared_mutex::unlock()
{
{
lock_guard<mutex> _(mut_);
state_ = 0;
}
gate1_.notify_all();
}
// Shared ownership
void
shared_mutex::lock_shared()
{
unique_lock<mutex> lk(mut_);
while ((state_ & write_entered_) || (state_ & n_readers_) == n_readers_)
gate1_.wait(lk);
unsigned num_readers = (state_ & n_readers_) + 1;
state_ &= ~n_readers_;
state_ |= num_readers;
}
bool
shared_mutex::try_lock_shared()
{
unique_lock<mutex> lk(mut_, try_to_lock);
unsigned num_readers = state_ & n_readers_;
if (lk.owns_lock() && !(state_ & write_entered_) && num_readers != n_readers_)
{
++num_readers;
state_ &= ~n_readers_;
state_ |= num_readers;
return true;
}
return false;
}
void
shared_mutex::unlock_shared()
{
lock_guard<mutex> _(mut_);
unsigned num_readers = (state_ & n_readers_) - 1;
state_ &= ~n_readers_;
state_ |= num_readers;
if (state_ & write_entered_)
{
if (num_readers == 0)
gate2_.notify_one();
}
else
{
if (num_readers == n_readers_ - 1)
gate1_.notify_one();
}
}
| 1,040 |
1,738 | <filename>dev/Gems/PhysX/Code/Tests/PhysXBenchmarks.cpp
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <PhysX_precompiled.h>
#include <vector>
#include <AzTest/AzTest.h>
#include <Physics/PhysicsTests.h>
#include <Tests/PhysXTestCommon.h>
#include <AzCore/Math/Random.h>
#include <AzCore/std/parallel/thread.h>
#include <AzFramework/Physics/RigidBodyBus.h>
#include <AzFramework/Physics/ShapeConfiguration.h>
#include "PhysXGenericTest.h"
#ifdef HAVE_BENCHMARK
#include <benchmark/benchmark.h>
namespace PhysX::Benchmarks
{
namespace Constants
{
const AZ::Vector3 BoxDimensions = AZ::Vector3::CreateOne();
static const float SphereShapeRadius = 2.0f;
static const AZ::u32 MinRadius = 2u;
static const int Seed = 100;
static const std::vector<std::vector<std::pair<int64_t, int64_t>>> BenchmarkConfigs =
{
// {{a, b}, {c, d}} means generate all pairs of parameters {x, y} for the benchmark
// such as x = a * 2 ^ k && x <= b and y = c * 2 ^ l && y <= d
// We have several configurations here because number of box entities might become
// larger than possible number of box locations if the maxRadius is small
{{4, 16}, {8, 512}},
{{32, 256}, {16, 512}},
{{512, 1024}, {32, 512}},
{{2048, 4096}, {64, 512}}
};
}
class PhysXBenchmarkFixture
: public benchmark::Fixture
, public Physics::GenericPhysicsFixture
, public Environment
{
public:
//! Spawns box entities in unique locations in 1/8 of sphere with all non-negative dimensions between radii[2, max radius].
//! Accepts 2 parameters from \state.
//!
//! \state.range(0) - number of box entities to spawn
//! \state.range(1) - max radius
void SetUp(const ::benchmark::State& state) override
{
Environment::SetupInternal();
Physics::GenericPhysicsFixture::SetUpInternal();
m_random = AZ::SimpleLcgRandom(Constants::Seed);
m_numBoxes = aznumeric_cast<AZ::u32>(state.range(0));
const auto minRadius = Constants::MinRadius;
const auto maxRadius = aznumeric_cast<AZ::u32>(state.range(1));
std::vector<AZ::Vector3> possibleBoxes;
AZ::u32 possibleBoxesCount = 0;
// Generate all possible boxes in radii [minRadius, maxRadius] where all the dimensions are positive.
for (auto x = 0u; x <= maxRadius; ++x)
{
for (auto y = 0u; y * y <= maxRadius * maxRadius - x * x; ++y)
{
for (auto z = aznumeric_cast<AZ::u32>(sqrt(std::max(x * x - y * y - minRadius * minRadius, 0u))); z * z <= maxRadius * maxRadius - x * x - y * y; ++z)
{
const auto sqDist = x * x + y * y + z * z;
if (minRadius * minRadius <= sqDist && sqDist <= maxRadius * maxRadius)
{
auto boxPosition = AZ::Vector3(aznumeric_cast<float>(x), aznumeric_cast<float>(y), aznumeric_cast<float>(z));
possibleBoxes.push_back(boxPosition);
possibleBoxesCount++;
}
}
}
}
AZ_Assert(m_numBoxes <= possibleBoxesCount, "Number of supplied boxes should be less than or equal to possible positions for boxes.");
// Shuffle to pick first m_numBoxes
for (AZ::u32 i = 1; i < possibleBoxesCount; ++i)
{
std::swap(possibleBoxes[i], possibleBoxes[m_random.GetRandom() % (i + 1)]);
}
m_boxes = std::vector<AZ::Vector3>(possibleBoxes.begin(), possibleBoxes.begin() + m_numBoxes);
for (auto box : m_boxes)
{
auto newEntity = TestUtils::CreateBoxEntity(box, Constants::BoxDimensions, false);
Physics::RigidBodyRequestBus::Event(newEntity->GetId(), &Physics::RigidBodyRequestBus::Events::SetGravityEnabled, false);
m_entities.push_back(newEntity);
}
}
void TearDown(const ::benchmark::State& state) override
{
m_boxes.clear();
m_entities.clear();
Physics::GenericPhysicsFixture::TearDownInternal();
Environment::TeardownInternal();
}
protected:
std::vector<EntityPtr> m_entities;
std::vector<AZ::Vector3> m_boxes;
AZ::u32 m_numBoxes = 0;
AZ::SimpleLcgRandom m_random;
};
//! Used to measure how much overhead fixture adds to benchmark runs.
class BenchmarkablePhysXBenchmarkFixture
: public Physics::GenericPhysicsFixture
, public Environment
{
public:
void SetUp()
{
Environment::SetupInternal();
Physics::GenericPhysicsFixture::SetUpInternal();
}
void TearDown()
{
Physics::GenericPhysicsFixture::TearDownInternal();
Environment::TeardownInternal();
}
};
BENCHMARK_DEFINE_F(PhysXBenchmarkFixture, BM_RaycastRandomBoxes)(benchmark::State& state)
{
Physics::RayCastRequest request;
request.m_start = AZ::Vector3::CreateZero();
request.m_distance = 2000.0f;
Physics::RayCastHit result;
auto next = 0;
for (auto _ : state)
{
request.m_direction = m_boxes[next].GetNormalizedExact();
Physics::WorldRequestBus::BroadcastResult(result, &Physics::WorldRequests::RayCast, request);
benchmark::DoNotOptimize(result);
next = (next + 1) % m_numBoxes;
}
}
BENCHMARK_DEFINE_F(PhysXBenchmarkFixture, BM_ShapecastRandomBoxes)(benchmark::State& state)
{
Physics::SphereShapeConfiguration shapeConfiguration;
shapeConfiguration.m_radius = Constants::SphereShapeRadius;
Physics::ShapeCastRequest request;
request.m_start = AZ::Transform::CreateIdentity();
request.m_distance = 2000.0f;
request.m_shapeConfiguration = &shapeConfiguration;
Physics::RayCastHit result;
auto next = 0;
for (auto _ : state)
{
request.m_direction = m_boxes[next].GetNormalizedExact();
Physics::WorldRequestBus::BroadcastResult(result, &Physics::WorldRequests::ShapeCast, request);
benchmark::DoNotOptimize(result);
next = (next + 1) % m_numBoxes;
}
}
BENCHMARK_DEFINE_F(PhysXBenchmarkFixture, BM_OverlapRandomBoxes)(benchmark::State& state)
{
Physics::SphereShapeConfiguration shapeConfiguration;
shapeConfiguration.m_radius = Constants::SphereShapeRadius;
Physics::OverlapRequest request;
request.m_shapeConfiguration = &shapeConfiguration;
AZStd::vector<Physics::OverlapHit> result;
auto next = 0;
for (auto _ : state)
{
request.m_pose = AZ::Transform::CreateTranslation(m_boxes[next]);
Physics::WorldRequestBus::BroadcastResult(result, &Physics::WorldRequests::Overlap, request);
benchmark::DoNotOptimize(result);
next = (next + 1) % m_numBoxes;
}
}
BENCHMARK_REGISTER_F(PhysXBenchmarkFixture, BM_RaycastRandomBoxes)
->RangeMultiplier(2)
->Ranges(Constants::BenchmarkConfigs[0])
->Ranges(Constants::BenchmarkConfigs[1])
->Ranges(Constants::BenchmarkConfigs[2])
->Ranges(Constants::BenchmarkConfigs[3])
->ReportAggregatesOnly(true);
BENCHMARK_REGISTER_F(PhysXBenchmarkFixture, BM_ShapecastRandomBoxes)
->RangeMultiplier(2)
->Ranges(Constants::BenchmarkConfigs[0])
->Ranges(Constants::BenchmarkConfigs[1])
->Ranges(Constants::BenchmarkConfigs[2])
->Ranges(Constants::BenchmarkConfigs[3])
->ReportAggregatesOnly(true);
void BM_PhysXBenchmarkFixture(benchmark::State& state)
{
for(auto _ : state)
{
auto fixture = std::make_unique<BenchmarkablePhysXBenchmarkFixture>();
fixture->SetUp();
fixture->TearDown();
benchmark::DoNotOptimize(*fixture);
}
}
BENCHMARK(BM_PhysXBenchmarkFixture)->Unit(benchmark::kMillisecond);
}
#endif
| 3,930 |
348 | <gh_stars>100-1000
{"nom":"Frontignan","circ":"8ème circonscription","dpt":"Hérault","inscrits":18702,"abs":9791,"votants":8911,"blancs":143,"nuls":74,"exp":8694,"res":[{"nuance":"FN","nom":"<NAME>","voix":2723},{"nuance":"REM","nom":"M. <NAME>","voix":2202},{"nuance":"FI","nom":"Mme <NAME>- MONFORT","voix":1164},{"nuance":"SOC","nom":"<NAME>","voix":1087},{"nuance":"LR","nom":"M. <NAME>","voix":684},{"nuance":"COM","nom":"M. <NAME>","voix":286},{"nuance":"DIV","nom":"Mme <NAME>","voix":103},{"nuance":"ECO","nom":"Mme <NAME>","voix":102},{"nuance":"DLF","nom":"M. <NAME>","voix":95},{"nuance":"DVG","nom":"M. <NAME>","voix":84},{"nuance":"EXG","nom":"M. <NAME>","voix":69},{"nuance":"DIV","nom":"M. <NAME>","voix":53},{"nuance":"DVG","nom":"M. <NAME>","voix":27},{"nuance":"DVD","nom":"M. <NAME>","voix":15}]} | 334 |
562 | from conans import ConanFile, AutoToolsBuildEnvironment, CMake, tools
from conans.errors import ConanException
import contextlib
import os
import re
import shlex
required_conan_version = ">=1.33.0"
class MpfrConan(ConanFile):
name = "mpfr"
description = "The MPFR library is a C library for multiple-precision floating-point computations with " \
"correct rounding"
topics = ("mpfr", "multiprecision", "math", "mathematics")
url = "https://github.com/conan-io/conan-center-index"
homepage = "https://www.mpfr.org/"
license = "LGPL-3.0-or-later"
settings = "os", "arch", "compiler", "build_type"
options = {
"shared": [True, False],
"fPIC": [True, False],
"exact_int": ["mpir", "gmp",]
}
default_options = {
"shared": False,
"fPIC": True,
"exact_int": "gmp",
}
exports_sources = "CMakeLists.txt.in", "patches/**"
generators = "cmake"
_autotools = None
_cmake = None
@property
def _source_subfolder(self):
return "source_subfolder"
@property
def _settings_build(self):
return getattr(self, "settings_build", self.settings)
def config_options(self):
if self.settings.os == "Windows":
del self.options.fPIC
def configure(self):
if self.options.shared:
del self.options.fPIC
del self.settings.compiler.libcxx
del self.settings.compiler.cppstd
def requirements(self):
if self.options.exact_int == "gmp":
self.requires("gmp/6.2.1")
elif self.options.exact_int == "mpir":
self.requires("mpir/3.0.0")
def build_requirements(self):
if self._settings_build.os == "Windows" and not tools.get_env("CONAN_BASH_PAH"):
self.build_requires("msys2/cci.latest")
def source(self):
tools.get(**self.conan_data["sources"][self.version],
destination=self._source_subfolder, strip_root=True)
def _configure_autotools(self):
if self._autotools:
return self._autotools
self._autotools = AutoToolsBuildEnvironment(self, win_bash=tools.os_info.is_windows)
yes_no = lambda v: "yes" if v else "no"
args = [
"--enable-thread-safe",
"--with-gmp-include={}".format(tools.unix_path(os.path.join(self.deps_cpp_info[str(self.options.exact_int)].rootpath, "include"))),
"--with-gmp-lib={}".format(tools.unix_path(os.path.join(self.deps_cpp_info[str(self.options.exact_int)].rootpath, "lib"))),
"--enable-shared={}".format(yes_no(self.options.shared)),
"--enable-static={}".format(yes_no(not self.options.shared)),
]
if self.settings.compiler == "clang":
# warning: optimization flag '-ffloat-store' is not supported
args.append("mpfr_cv_gcc_floatconv_bug=no")
if self.settings.arch == "x86":
# fatal error: error in backend: Unsupported library call operation!
args.append("--disable-float128")
if self.options.exact_int == "mpir":
self._autotools.include_paths.append(self.build_folder)
if self.settings.compiler == "Visual Studio":
self._autotools.flags.append("-FS")
self._autotools.libs = []
self._autotools.configure(args=args, configure_dir=self._source_subfolder)
return self._autotools
def _configure_cmake(self):
if self._cmake:
return self._cmake
self._cmake = CMake(self)
self._cmake.configure(source_dir=os.path.join(self._source_subfolder, "src"))
return self._cmake
def _extract_makefile_variable(self, makefile, variable):
makefile_contents = tools.load(makefile)
match = re.search("{}[ \t]*=[ \t]*((?:(?:[a-zA-Z0-9 \t.=/_-])|(?:\\\\\"))*(?:\\\\\n(?:(?:[a-zA-Z0-9 \t.=/_-])|(?:\\\"))*)*)\n".format(variable), makefile_contents)
if not match:
raise ConanException("Cannot extract variable {} from {}".format(variable, makefile_contents))
lines = [line.strip(" \t\\") for line in match.group(1).split()]
return [item for line in lines for item in shlex.split(line) if item]
def _extract_mpfr_autotools_variables(self):
makefile_am = os.path.join(self._source_subfolder, "src", "Makefile.am")
makefile = os.path.join("src", "Makefile")
sources = self._extract_makefile_variable(makefile_am, "libmpfr_la_SOURCES")
headers = self._extract_makefile_variable(makefile_am, "include_HEADERS")
defs = self._extract_makefile_variable(makefile, "DEFS")
return sources, headers, defs
@contextlib.contextmanager
def _build_context(self):
if self.settings.compiler == "Visual Studio":
with tools.vcvars(self):
env = {
"AR": "lib",
"CC": "cl -nologo",
"CXX": "cl -nologo",
"LD": "link",
"NM": "dumpbin -symbols",
"OBJDUMP": ":",
"RANLIB": ":",
"STRIP": ":",
}
with tools.environment_append(env):
yield
else:
yield
def build(self):
for patch in self.conan_data.get("patches", {}).get(self.version, []):
tools.patch(**patch)
if self.options.exact_int == "mpir":
tools.replace_in_file(os.path.join(self._source_subfolder, "configure"),
"-lgmp", "-lmpir")
tools.replace_in_file(os.path.join(self._source_subfolder, "src", "mpfr.h"),
"<gmp.h>", "<mpir.h>")
tools.save("gmp.h", "#pragma once\n#include <mpir.h>\n")
with self._build_context():
autotools = self._configure_autotools()
if self.settings.os == "Windows":
cmakelists_in = tools.load("CMakeLists.txt.in")
sources, headers, definitions = self._extract_mpfr_autotools_variables()
tools.save(os.path.join(self._source_subfolder, "src", "CMakeLists.txt"), cmakelists_in.format(
mpfr_sources=" ".join(sources),
mpfr_headers=" ".join(headers),
definitions=" ".join(definitions),
))
cmake = self._configure_cmake()
cmake.build()
else:
autotools.make(args=["V=0"])
def package(self):
self.copy("COPYING", dst="licenses", src=self._source_subfolder)
if self.settings.os == "Windows":
cmake = self._configure_cmake()
cmake.install()
else:
autotools = self._configure_autotools()
autotools.install()
os.unlink(os.path.join(self.package_folder, "lib", "libmpfr.la"))
tools.rmdir(os.path.join(self.package_folder, "share"))
tools.rmdir(os.path.join(self.package_folder, "lib", "pkgconfig"))
def package_info(self):
self.cpp_info.libs = ["mpfr"]
if self.settings.os == "Windows" and self.options.shared:
self.cpp_info.defines = ["MPFR_DLL"]
| 3,461 |
503 | <filename>test/support/ExecutionTimeWatcher.java
package support;
import org.joda.time.DateTime;
import org.joda.time.Interval;
import org.junit.rules.TestWatcher;
import org.junit.runner.Description;
import play.Logger;
public class ExecutionTimeWatcher extends TestWatcher {
DateTime start;
DateTime end;
@Override
protected void starting(Description description) {
this.start = new DateTime();
}
@Override
protected void finished(Description description) {
this.end = new DateTime();
Interval interval = new Interval(start, end);
if ( interval.toDurationMillis() / 1000 > 3 ){
Logger.debug("\u001B[0;35m" + description.getMethodName() + ": " + interval.toDurationMillis() / 1000 + " sec\u001B[0m");
} else {
Logger.debug(description.getMethodName() + ": " + interval.toDurationMillis() / 1000 + " sec");
}
}
}
| 347 |
742 | <filename>ros/orocos_kinematics_dynamics/orocos_kdl/tests/framestest.hpp
#ifndef FRAMES_TEST_HPP
#define FRAMES_TEST_HPP
#include <cppunit/extensions/HelperMacros.h>
#include <frames.hpp>
#include <jntarray.hpp>
using namespace KDL;
class FramesTest : public CppUnit::TestFixture
{
CPPUNIT_TEST_SUITE( FramesTest);
CPPUNIT_TEST(TestVector);
CPPUNIT_TEST(TestTwist);
CPPUNIT_TEST(TestWrench);
CPPUNIT_TEST(TestRotation);
CPPUNIT_TEST(TestQuaternion);
CPPUNIT_TEST(TestFrame);
CPPUNIT_TEST(TestJntArray);
CPPUNIT_TEST(TestRotationDiff);
CPPUNIT_TEST(TestEuler);
CPPUNIT_TEST_SUITE_END();
public:
void setUp();
void tearDown();
void TestVector();
void TestTwist();
void TestWrench();
void TestRotation();
void TestQuaternion();
void TestFrame();
void TestJntArray();
void TestJntArrayWhenEmpty();
void TestRotationDiff();
void TestEuler();
private:
void TestVector2(Vector& v);
void TestTwist2(Twist& t);
void TestWrench2(Wrench& w);
void TestRotation2(const Vector& v,double a,double b,double c);
void TestOneRotation(const std::string& msg,
const KDL::Rotation& R,
const double expectedAngle,
const KDL::Vector& expectedAxis);
void TestArbitraryRotation(const std::string& msg,
const KDL::Vector& v,
const double angle,
const double expectedAngle,
const KDL::Vector& expectedVector);
void TestRangeArbitraryRotation(const std::string& msg,
const KDL::Vector& v,
const KDL::Vector& expectedVector);
};
#endif
| 882 |
338 | {
"division": "iVia Project",
"sortIndex": 180,
"lite": false,
"standard": true,
"userAgents": [
{
"userAgent": "iVia Project",
"browser": "ivia project",
"properties": {
"Parent": "DefaultProperties",
"Comment": "iVia Project"
},
"children": [
{
"match": "DataFountains/DMOZ Downloader*",
"browser": "datafountains/dmoz downloader"
},
{
"match": "DataFountains/DMOZ Feature Vector Corpus Creator*",
"browser": "datafountains/dmoz feature vector corpus"
}
]
}
]
}
| 292 |
2,346 | package org.traccar.protocol;
import org.junit.Test;
import org.traccar.ProtocolTest;
import org.traccar.model.Command;
public class NoranProtocolEncoderTest extends ProtocolTest {
@Test
public void testEncode() throws Exception {
var encoder = new NoranProtocolEncoder(null);
Command command = new Command();
command.setDeviceId(1);
command.setType(Command.TYPE_ENGINE_STOP);
verifyCommand(encoder, command, binary(
"0d0a2a4b5700440002000000000000002a4b572c3030302c3030372c3030303030302c302300000000000000000000000000000000000000000000000000000000000d0a"));
}
}
| 245 |
7,471 | <gh_stars>1000+
#pragma once
#include "mvItemRegistry.h"
namespace Marvel {
class mvToggledOpenHandler : public mvAppItem
{
public:
explicit mvToggledOpenHandler(mvUUID uuid);
void draw(ImDrawList* drawlist, float x, float y) override {}
void customAction(void* data = nullptr) override;
};
}
| 141 |
17,481 | /*
* Copyright (C) 2020 The Dagger 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 dagger.hilt.android.lifecycle;
import dagger.hilt.GeneratesRootInput;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Identifies a {@link androidx.lifecycle.ViewModel} for construction injection.
*
* <p>The {@code ViewModel} annotated with {@link HiltViewModel} will be available for creation by
* the {@link dagger.hilt.android.lifecycle.HiltViewModelFactory} and can be retrieved by default in
* an {@code Activity} or {@code Fragment} annotated with {@link
* dagger.hilt.android.AndroidEntryPoint}. The {@code HiltViewModel} containing a constructor
* annotated with {@link javax.inject.Inject} will have its dependencies defined in the constructor
* parameters injected by Dagger's Hilt.
*
* <p>Example:
*
* <pre>
* @HiltViewModel
* public class DonutViewModel extends ViewModel {
* @Inject
* public DonutViewModel(SavedStateHandle handle, RecipeRepository repository) {
* // ...
* }
* }
* </pre>
*
* <pre>
* @AndroidEntryPoint
* public class CookingActivity extends AppCompatActivity {
* public void onCreate(Bundle savedInstanceState) {
* DonutViewModel vm = new ViewModelProvider(this).get(DonutViewModel.class);
* }
* }
* </pre>
*
* <p>Exactly one constructor in the {@code ViewModel} must be annotated with {@code Inject}.
*
* <p>Only dependencies available in the {@link dagger.hilt.android.components.ViewModelComponent}
* can be injected into the {@code ViewModel}.
*
* <p>
*
* @see dagger.hilt.android.components.ViewModelComponent
*/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.CLASS)
@GeneratesRootInput
public @interface HiltViewModel {}
| 720 |
419 | //
// ElasticShapeLayer.h
// ElasticTransistionExample
//
// Created by Tigielle on 11/02/16.
// Copyright © 2016 <NAME>. All rights reserved.
//
#import <QuartzCore/QuartzCore.h>
#import "Utils.h"
@interface ElasticShapeLayer : CAShapeLayer
@property (nonatomic) Edge edge;
@property (nonatomic) CGPoint dragPoint;
@property (nonatomic) CGFloat radiusFactor;
@end
| 127 |
553 | package com.test.pattern;
import java.util.Observable;
import java.util.Observer;
public class CurrentConditionsDisplay implements Observer, DisplayElement {
private float temperature;
private float humidity;
Observable observable;
public CurrentConditionsDisplay(Observable observable) {
// weatherData.registerObserver(this);
this.observable = observable;
observable.addObserver(this);
}
// public void update(float temperature, float humidity, float pressure) {
// this.temperature = temperature;
// this.humidity = humidity;
// display();
// }
/**
* This method is called whenever the observed object is changed. An
* application calls an <tt>Observable</tt> object's
* <code>notifyObservers</code> method to have all the object's
* observers notified of the change.
*
* @param o the observable object.
* @param arg an argument passed to the <code>notifyObservers</code>
*/
@Override
public void update(Observable o, Object arg) {
if(o instanceof WeatherData){
WeatherData wd = (WeatherData)o;
temperature = wd.getTemperature();
humidity = wd.getHumidity();
display();
}
}
public void display() {
System.out.println("Current conditions: " + temperature
+ "F degrees and " + humidity + "% humidity");
}
}
| 399 |
678 | <gh_stars>100-1000
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree.
*/
#include "glean/lang/clang/path.h"
#include <algorithm>
namespace facebook {
namespace glean {
namespace clangx {
boost::filesystem::path goodPath(
boost::filesystem::path root,
boost::filesystem::path path) {
assert(root.is_absolute());
path = path.lexically_normal();
// NOTE: we can't use boost's lexically_relative because
// "../foo/bar".lexically_relative("/foo") isn't "bar".
if (path.is_relative()) {
auto root_begin = root.begin();
auto root_end = root.end();
auto path_begin = path.begin();
auto path_end = path.end();
auto done = false;
while (root_begin != root_end && path_begin != path_end && !done) {
if (*path_begin == "..") {
--root_end;
++path_begin;
} else if (root_end != root.end() && *path_begin == *root_end) {
++root_end;
++path_begin;
} else {
done = true;
}
}
boost::filesystem::path result;
while (root_end != root.end()) {
result /= "..";
++root_end;
}
while (path_begin != path_end) {
result /= *path_begin;
++path_begin;
}
return result;
} else {
auto d = std::mismatch(
path.begin(), path.end(), root.begin(), root.end());
if (d.second == root.end()) {
boost::filesystem::path ret;
for (auto i = d.first; i != path.end(); ++i) {
ret /= *i;
}
return ret;
} else {
return path;
}
}
}
boost::filesystem::path betterPath(
boost::filesystem::path path1,
boost::filesystem::path path2) {
return
!path1.empty() && (path1.is_relative() || path2.is_absolute())
? path1
: path2;
}
}
}
}
| 787 |
419 | #pragma once
#include <memory>
#include "Hypodermic/IRegistration.h"
namespace Hypodermic
{
class ActivatedRegistrationInfo
{
public:
ActivatedRegistrationInfo(const std::shared_ptr< IRegistration >& registration, const std::shared_ptr< void >& instance)
: m_registration(registration)
, m_instance(instance)
{
}
const std::shared_ptr< IRegistration >& registration() const
{
return m_registration;
}
const std::shared_ptr< void >& instance() const
{
return m_instance;
}
private:
const std::shared_ptr< IRegistration >& m_registration;
std::shared_ptr< void > m_instance;
};
} // namespace Hypodermic | 337 |
7,863 | <filename>src/VisVim/VisVim.cpp<gh_stars>1000+
// VisVim.cpp : Defines the initialization routines for the DLL.
//
#include "stdafx.h"
#include <initguid.h>
#include "VisVim.h"
#include "DSAddIn.h"
#include "Commands.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
CComModule _Module;
BEGIN_OBJECT_MAP (ObjectMap)
OBJECT_ENTRY (CLSID_DSAddIn, CDSAddIn)
END_OBJECT_MAP ()
class CVisVimApp : public CWinApp
{
public:
CVisVimApp ();
//{{AFX_VIRTUAL(CVisVimApp)
public:
virtual BOOL InitInstance ();
virtual int ExitInstance ();
//}}AFX_VIRTUAL
//{{AFX_MSG(CVisVimApp)
//}}AFX_MSG
DECLARE_MESSAGE_MAP ()
};
BEGIN_MESSAGE_MAP (CVisVimApp, CWinApp)
//{{AFX_MSG_MAP(CVisVimApp)
//}}AFX_MSG_MAP
END_MESSAGE_MAP ()
// The one and only CVisVimApp object
CVisVimApp theApp;
CVisVimApp::CVisVimApp ()
{
}
BOOL CVisVimApp::InitInstance ()
{
_Module.Init (ObjectMap, m_hInstance);
return CWinApp::InitInstance ();
}
int CVisVimApp::ExitInstance ()
{
_Module.Term ();
return CWinApp::ExitInstance ();
}
// Special entry points required for inproc servers
//
STDAPI DllGetClassObject (REFCLSID rclsid, REFIID riid, LPVOID * ppv)
{
AFX_MANAGE_STATE (AfxGetStaticModuleState ());
return _Module.GetClassObject (rclsid, riid, ppv);
}
STDAPI DllCanUnloadNow (void)
{
AFX_MANAGE_STATE (AfxGetStaticModuleState ());
return (AfxDllCanUnloadNow () == S_OK && _Module.GetLockCount () == 0)
? S_OK : S_FALSE;
}
// By exporting DllRegisterServer, you can use regsvr32.exe
//
STDAPI DllRegisterServer (void)
{
AFX_MANAGE_STATE (AfxGetStaticModuleState ());
HRESULT hRes;
// Registers object, typelib and all interfaces in typelib
hRes = _Module.RegisterServer (TRUE);
if (FAILED (hRes))
// Hack: When this fails we might be a normal user, while the
// admin already registered the module. Returning S_OK then
// makes it work. When the module was never registered it
// will soon fail in another way.
// old code: return hRes;
return S_OK;
_ATL_OBJMAP_ENTRY *pEntry = _Module.m_pObjMap;
CRegKey key;
LONG lRes = key.Open (HKEY_CLASSES_ROOT, _T ("CLSID"));
if (lRes == ERROR_SUCCESS)
{
USES_CONVERSION;
LPOLESTR lpOleStr;
StringFromCLSID (*pEntry->pclsid, &lpOleStr);
LPTSTR lpsz = OLE2T (lpOleStr);
lRes = key.Open (key, lpsz);
if (lRes == ERROR_SUCCESS)
{
CString strDescription;
strDescription.LoadString (IDS_VISVIM_DESCRIPTION);
key.SetKeyValue (_T ("Description"), strDescription);
}
CoTaskMemFree (lpOleStr);
}
if (lRes != ERROR_SUCCESS)
hRes = HRESULT_FROM_WIN32 (lRes);
return hRes;
}
// DllUnregisterServer - Removes entries from the system registry
//
STDAPI DllUnregisterServer (void)
{
AFX_MANAGE_STATE (AfxGetStaticModuleState ());
HRESULT hRes = S_OK;
_Module.UnregisterServer ();
return hRes;
}
// Debugging support
// GetLastErrorDescription is used in the implementation of the VERIFY_OK
// macro, defined in stdafx.h.
#ifdef _DEBUG
void GetLastErrorDescription (CComBSTR & bstr)
{
CComPtr < IErrorInfo > pErrorInfo;
if (GetErrorInfo (0, &pErrorInfo) == S_OK)
pErrorInfo->GetDescription (&bstr);
}
#endif //_DEBUG
| 1,289 |
543 | <reponame>CoenRijsdijk/Bytecoder
/*
* Copyright (c) 2002, 2007, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package sun.java2d;
import java.awt.Rectangle;
import java.awt.image.Raster;
import java.awt.image.ColorModel;
import java.awt.GraphicsConfiguration;
import sun.java2d.StateTrackable.State;
import sun.java2d.loops.SurfaceType;
import sun.java2d.pipe.NullPipe;
/**
* This class provides an empty implementation of the SurfaceData
* abstract superclass. All operations on it translate into NOP
* or harmless operations.
*/
public class NullSurfaceData extends SurfaceData {
public static final SurfaceData theInstance = new NullSurfaceData();
private NullSurfaceData() {
super(State.IMMUTABLE, SurfaceType.Any, ColorModel.getRGBdefault());
}
/**
* Sets this SurfaceData object to the invalid state. All Graphics
* objects must get a new SurfaceData object via the refresh method
* and revalidate their pipelines before continuing.
*/
public void invalidate() {
}
/**
* Return a new SurfaceData object that represents the current state
* of the destination that this SurfaceData object describes.
* This method is typically called when the SurfaceData is invalidated.
*/
public SurfaceData getReplacement() {
return this;
}
private static final NullPipe nullpipe = new NullPipe();
public void validatePipe(SunGraphics2D sg2d) {
sg2d.drawpipe = nullpipe;
sg2d.fillpipe = nullpipe;
sg2d.shapepipe = nullpipe;
sg2d.textpipe = nullpipe;
sg2d.imagepipe = nullpipe;
}
public GraphicsConfiguration getDeviceConfiguration() {
return null;
}
/**
* Return a readable Raster which contains the pixels for the
* specified rectangular region of the destination surface.
* The coordinate origin of the returned Raster is the same as
* the device space origin of the destination surface.
* In some cases the returned Raster might also be writeable.
* In most cases, the returned Raster might contain more pixels
* than requested.
*
* @see #useTightBBoxes
*/
public Raster getRaster(int x, int y, int w, int h) {
throw new InvalidPipeException("should be NOP");
}
/**
* Does the pixel accessibility of the destination surface
* suggest that rendering algorithms might want to take
* extra time to calculate a more accurate bounding box for
* the operation being performed?
* The typical case when this will be true is when a copy of
* the pixels has to be made when doing a getRaster. The
* fewer pixels copied, the faster the operation will go.
*
* @see #getRaster
*/
public boolean useTightBBoxes() {
return false;
}
/**
* Returns the pixel data for the specified Argb value packed
* into an integer for easy storage and conveyance.
*/
public int pixelFor(int rgb) {
return rgb;
}
/**
* Returns the Argb representation for the specified integer value
* which is packed in the format of the associated ColorModel.
*/
public int rgbFor(int pixel) {
return pixel;
}
/**
* Returns the bounds of the destination surface.
*/
public Rectangle getBounds() {
return new Rectangle();
}
/**
* Performs Security Permissions checks to see if a Custom
* Composite object should be allowed access to the pixels
* of this surface.
*/
protected void checkCustomComposite() {
return;
}
/**
* Performs a copyarea within this surface. Returns
* false if there is no algorithm to perform the copyarea
* given the current settings of the SunGraphics2D.
*/
public boolean copyArea(SunGraphics2D sg2d,
int x, int y, int w, int h, int dx, int dy)
{
return true;
}
/**
* Returns destination Image associated with this SurfaceData (null)
*/
public Object getDestination() {
return null;
}
}
| 1,717 |
14,793 | <filename>weixin-java-cp/src/main/java/me/chanjar/weixin/cp/bean/external/WxCpUserTransferCustomerReq.java
package me.chanjar.weixin.cp.bean.external;
import com.google.gson.annotations.SerializedName;
import lombok.Getter;
import lombok.Setter;
import me.chanjar.weixin.common.annotation.Required;
import me.chanjar.weixin.cp.util.json.WxCpGsonBuilder;
import java.io.Serializable;
import java.util.List;
/**
* 转接在职成员的客户给其他成员，请求对象
*
* @author pg
* @date 2021年6月21日
*/
@Getter
@Setter
public class WxCpUserTransferCustomerReq implements Serializable {
private static final long serialVersionUID = -309819538677411801L;
/**
* 原跟进成员的userid
*/
@SerializedName("handover_userid")
@Required
private String handOverUserid;
/**
* 接替成员的userid
*/
@SerializedName("takeover_userid")
@Required
private String takeOverUserid;
/**
* 客户的external_userid列表，每次最多分配100个客户
*/
@SerializedName("external_userid")
@Required
private List<String> externalUserid;
/**
* 转移成功后发给客户的消息，最多200个字符，不填则使用默认文案
*/
@SerializedName("transfer_success_msg")
private String transferMsg;
public String toJson() {
return WxCpGsonBuilder.create().toJson(this);
}
}
| 584 |
1,831 | <filename>logdevice/server/thrift/LogDeviceThriftServer.h
/**
* Copyright (c) 2020-present, Facebook, Inc. and its affiliates.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree.
*/
#pragma once
#include "logdevice/common/RequestExecutor.h"
#include "logdevice/common/Sockaddr.h"
namespace apache { namespace thrift {
class ThriftServer;
class ServerInterface;
}} // namespace apache::thrift
namespace facebook { namespace logdevice {
/**
* A base implementation for Thrift servers. The specific implementation is
* expected to be defined as plug-ins.
*/
class LogDeviceThriftServer {
public:
/**
* Creates a new Thrift server but returned instances will not accept
* connections until start() is called.
*
* @param name Used mostly for logging purposes to distinguish
* multiple servers running in the same process.
* @param listen_addr Address on which this server will listen for
* incoming request.
* @param handler Service-specific Thrift handler.
* @param request_executor API to post requests to workers.
*/
LogDeviceThriftServer(
const std::string& name,
const Sockaddr& listen_addr,
std::shared_ptr<apache::thrift::ServerInterface> handler,
RequestExecutor request_executor);
/**
* Starts listen and accept incoming requests.
*
* @return true iff server has successfully started
*/
virtual bool start() = 0;
/**
* Stops server and prevent any new requests from being accepted.
*/
virtual void stop() = 0;
virtual ~LogDeviceThriftServer() {}
protected:
const std::string name_;
std::shared_ptr<apache::thrift::ServerInterface> handler_;
std::shared_ptr<apache::thrift::ThriftServer> server_;
};
}} // namespace facebook::logdevice
| 613 |
1,590 | <reponame>libc16/azure-rest-api-specs<filename>specification/cognitiveservices/data-plane/FormRecognizer/preview/v2.1-preview.1/examples/CopyModel.json<gh_stars>1000+
{
"parameters": {
"endpoint": "{endpoint}",
"Content-Type": "application/json",
"Ocp-Apim-Subscription-Key": "{API key}",
"modelId": "{modelId}",
"body": {},
"copyRequest": {
"targetResourceId": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CognitiveServices/accounts/{resourceName}",
"targetResourceRegion": "westus2",
"copyAuthorization": {
"modelId": "{modelId}",
"accessToken": "{accessToken}",
"expirationDateTimeTicks": 637190189980000000
}
}
},
"responses": {
"202": {
"headers": {
"Operation-Location": "{endpoint}/formrecognizer/v2.1-preview.1/custom/models/{modelId}/copyResults/{resultId}"
}
}
}
}
| 393 |
1,226 | //
// TPSCardFieldManager.h
// TPSStripe
//
// Created by <NAME> on 01.11.16.
// Copyright © 2016 Tipsi. All rights reserved.
//
#import <React/RCTViewManager.h>
@interface TPSCardFieldManager : RCTViewManager
@end
| 85 |
521 | //
// ADJDeeplinkDelegate.h
// Adjust
//
// Created by <NAME> on 13/05/16.
// Copyright © 2016 adjust GmbH. All rights reserved.
//
#import <Foundation/Foundation.h>
#import "Adjust.h"
@interface ADJDeeplinkLaunchDelegate : NSObject <AdjustDelegate>
@end
@interface ADJDeeplinkNotLaunchDelegate : NSObject <AdjustDelegate>
@end
| 122 |
435 | {
"abstract": "Good documentation is important, but it should be your last resort. You\nneed to help users before they reach the docs - in the user interface\nitself.\n\nIn this talk, I'll discuss:\n\n- strategies for writing microcopy when you\u2019re short on space\n- what to explain in the UI, and what to save for the documentation\n- how to pick the right style of embedded help\n- what makes a great error message (and a terrible one)\n\n... with plenty of real-world examples of doing it right and wrong.\n",
"copyright_text": null,
"description": "Full talk description: http://www.writethedocs.org/conf/eu/2015/speakers/\n\nSlides: http://www.writethedocs.org/conf/eu/2015/schedule/\n\nFollow us on Twitter @writethedocs\n\nJoin our mailing list http://writethedocs.us11.list-manage.com/subscribe?u=fcfe905987123983cc93c7a46&id=e2e27d6167",
"duration": 1555,
"language": "eng",
"recorded": "2015-08-31",
"related_urls": [
{
"label": "Conference schedule",
"url": "http://www.writethedocs.org/conf/eu/2015/schedule/"
}
],
"speakers": [
"<NAME>"
],
"tags": [],
"thumbnail_url": "https://i.ytimg.com/vi/LemM9PHDX6w/hqdefault.jpg",
"title": "Before the docs: writing for user interfaces",
"videos": [
{
"type": "youtube",
"url": "https://www.youtube.com/watch?v=LemM9PHDX6w"
}
]
}
| 515 |
727 | <gh_stars>100-1000
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import pytest
import numpy as np
from keras import backend as K
from keras.models import Sequential
from keras.layers import Dense, Lambda, Masking
from keras.layers.wrappers import TimeDistributed
from keras.optimizers import RMSprop
from wtte import wtte as wtte
from wtte.data_generators import generate_weibull
def test_keras_unstack_hack():
y_true_np = np.random.random([1, 3, 2])
y_true_np[:, :, 0] = 0
y_true_np[:, :, 1] = 1
y_true_keras = K.variable(y_true_np)
y, u = wtte._keras_unstack_hack(y_true_keras)
y_true_keras_new = K.stack([y, u], axis=-1)
np.testing.assert_array_equal(K.eval(y_true_keras_new), y_true_np)
# SANITY CHECK: Use pure Weibull data censored at C(ensoring point).
# Should converge to the generating A(alpha) and B(eta) for each timestep
def get_data(discrete_time):
y_test, y_train, u_train = generate_weibull(A=real_a,
B=real_b,
# <np.inf -> impose censoring
C=censoring_point,
shape=[n_sequences,
n_timesteps, 1],
discrete_time=discrete_time)
# With random input it _should_ learn weight 0
x_train = x_test = np.random.uniform(
low=-1, high=1, size=[n_sequences, n_timesteps, n_features])
# y_test is uncencored data
y_test = np.append(y_test, np.ones_like(y_test), axis=-1)
y_train = np.append(y_train, u_train, axis=-1)
return y_train, x_train, y_test, x_test
n_sequences = 10000
n_timesteps = 2
n_features = 1
real_a = 3.
real_b = 2.
censoring_point = real_a * 2
mask_value = -10.
lr = 0.02
def model_no_masking(discrete_time, init_alpha, max_beta):
model = Sequential()
model.add(TimeDistributed(Dense(2), input_shape=(n_timesteps, n_features)))
model.add(Lambda(wtte.output_lambda, arguments={"init_alpha": init_alpha,
"max_beta_value": max_beta}))
if discrete_time:
loss = wtte.loss(kind='discrete').loss_function
else:
loss = wtte.loss(kind='continuous').loss_function
model.compile(loss=loss, optimizer=RMSprop(lr=lr))
return model
def model_masking(discrete_time, init_alpha, max_beta):
model = Sequential()
model.add(Masking(mask_value=mask_value,
input_shape=(n_timesteps, n_features)))
model.add(TimeDistributed(Dense(2)))
model.add(Lambda(wtte.output_lambda, arguments={"init_alpha": init_alpha,
"max_beta_value": max_beta}))
if discrete_time:
loss = wtte.loss(kind='discrete', reduce_loss=False).loss_function
else:
loss = wtte.loss(kind='continuous', reduce_loss=False).loss_function
model.compile(loss=loss, optimizer=RMSprop(
lr=lr), sample_weight_mode='temporal')
return model
def keras_loglik_runner(discrete_time, add_masking):
np.random.seed(1)
# tf.set_random_seed(1)
y_train, x_train, y_test, x_test = get_data(discrete_time=discrete_time)
if add_masking:
# If masking doesn't work, it'll learn nonzero weights (strong signal):
x_train[:int(n_sequences / 2), int(n_timesteps / 2):, :] = mask_value
y_train[:int(n_sequences / 2), int(n_timesteps / 2):, 0] = real_a * 300.
weights = np.ones([n_sequences, n_timesteps])
weights[:int(n_sequences / 2), int(n_timesteps / 2):] = 0.
model = model_masking(
discrete_time, init_alpha=real_a, max_beta=real_b * 3)
model.fit(x_train, y_train,
epochs=5,
batch_size=100,
verbose=0,
sample_weight=weights,
)
else:
model = model_no_masking(
discrete_time, init_alpha=real_a, max_beta=real_b * 3)
model.fit(x_train, y_train,
epochs=5,
batch_size=100,
verbose=0,
)
predicted = model.predict(x_test[:1, :, :])
a_val = predicted[:, :, 0].mean()
b_val = predicted[:, :, 1].mean()
print(np.abs(real_a - a_val), np.abs(real_b - b_val))
assert np.abs(real_a - a_val) < 0.1, 'alpha not converged'
assert np.abs(real_b - b_val) < 0.1, 'beta not converged'
def test_loglik_continuous():
keras_loglik_runner(discrete_time=False, add_masking=False)
def test_loglik_discrete():
keras_loglik_runner(discrete_time=True, add_masking=False)
def test_loglik_continuous_masking():
keras_loglik_runner(discrete_time=False, add_masking=True)
def test_output_lambda_initialization():
# Initializing beta =1 gives us a simple initialization rule for alpha.
# it also makes sense considering it initializes the hazard to flat
# and in general as a regular exponential regression model.
init_alpha = 5
n_features = 1
n_timesteps = 10
n_sequences = 5
np.random.seed(1)
model = Sequential()
# Identity layer
model.add(Lambda(lambda x: x, input_shape=(n_timesteps, n_features)))
model.add(Dense(2))
model.add(Lambda(wtte.output_lambda,
arguments={"init_alpha": init_alpha,
"max_beta_value": 4.,
"alpha_kernel_scalefactor": 1.
}))
# Test
x = np.random.normal(0, 0.01, size=[n_sequences, n_timesteps, n_features])
predicted = model.predict(x)
# Check that it initializes +- 0.1 from init_alpha,beta=1
abs_error = np.abs(predicted[:, :, 0].flatten() - init_alpha).mean()
assert abs_error < 0.1, 'alpha initialization error' + str(abs_error)
abs_error = np.abs(predicted[:, :, 1].flatten() - 1.).mean()
assert abs_error < 0.1, 'beta initialization error' + str(abs_error)
| 2,912 |
848 | # pylint: disable=g-bad-file-header
# Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Tests for tensorflow.python.client.graph_util."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import numpy as np
from tensorflow.core.framework import attr_value_pb2
from tensorflow.core.framework import graph_pb2
from tensorflow.core.framework import node_def_pb2
from tensorflow.python.framework import constant_op
from tensorflow.python.framework import dtypes
from tensorflow.python.framework import importer
from tensorflow.python.framework import ops
from tensorflow.python.framework import tensor_util
from tensorflow.python.framework import test_util
from tensorflow.python.ops import array_ops
from tensorflow.python.ops import gen_nn_ops
from tensorflow.python.ops import image_ops
from tensorflow.python.ops import math_ops # pylint: disable=unused-import
from tensorflow.python.ops import nn_ops
from tensorflow.python.platform import test
from tensorflow.python.tools import optimize_for_inference_lib
class OptimizeForInferenceTest(test.TestCase):
def create_node_def(self, op, name, inputs):
new_node = node_def_pb2.NodeDef()
new_node.op = op
new_node.name = name
for input_name in inputs:
new_node.input.extend([input_name])
return new_node
def create_constant_node_def(self, name, value, dtype, shape=None):
node = self.create_node_def("Const", name, [])
self.set_attr_dtype(node, "dtype", dtype)
self.set_attr_tensor(node, "value", value, dtype, shape)
return node
def set_attr_dtype(self, node, key, value):
node.attr[key].CopyFrom(
attr_value_pb2.AttrValue(type=value.as_datatype_enum))
def set_attr_tensor(self, node, key, value, dtype, shape=None):
node.attr[key].CopyFrom(
attr_value_pb2.AttrValue(tensor=tensor_util.make_tensor_proto(
value, dtype=dtype, shape=shape)))
def testOptimizeForInference(self):
self.maxDiff = 1000
unused_constant_name = "unused_constant"
unconnected_add_name = "unconnected_add"
a_constant_name = "a_constant"
b_constant_name = "b_constant"
a_check_name = "a_check"
b_check_name = "b_check"
a_identity_name = "a_identity"
b_identity_name = "b_identity"
add_name = "add"
unused_output_add_name = "unused_output_add"
graph_def = graph_pb2.GraphDef()
unused_constant = self.create_constant_node_def(
unused_constant_name, value=0, dtype=dtypes.float32, shape=[])
graph_def.node.extend([unused_constant])
unconnected_add_node = self.create_node_def(
"Add", unconnected_add_name,
[unused_constant_name, unused_constant_name])
self.set_attr_dtype(unconnected_add_node, "T", dtypes.float32)
graph_def.node.extend([unconnected_add_node])
a_constant = self.create_constant_node_def(
a_constant_name, value=1, dtype=dtypes.float32, shape=[])
graph_def.node.extend([a_constant])
a_check_node = self.create_node_def("CheckNumerics", a_check_name,
[a_constant_name])
graph_def.node.extend([a_check_node])
a_identity_node = self.create_node_def(
"Identity", a_identity_name, [a_constant_name, "^" + a_check_name])
graph_def.node.extend([a_identity_node])
b_constant = self.create_constant_node_def(
b_constant_name, value=1, dtype=dtypes.float32, shape=[])
graph_def.node.extend([b_constant])
b_check_node = self.create_node_def("CheckNumerics", b_check_name,
[b_constant_name])
graph_def.node.extend([b_check_node])
b_identity_node = self.create_node_def(
"Identity", b_identity_name, [b_constant_name, "^" + b_check_name])
graph_def.node.extend([b_identity_node])
add_node = self.create_node_def("Add", add_name,
[a_identity_name, b_identity_name])
self.set_attr_dtype(add_node, "T", dtypes.float32)
graph_def.node.extend([add_node])
unused_output_add_node = self.create_node_def("Add", unused_output_add_name,
[add_name, b_constant_name])
self.set_attr_dtype(unused_output_add_node, "T", dtypes.float32)
graph_def.node.extend([unused_output_add_node])
expected_output = graph_pb2.GraphDef()
a_constant = self.create_constant_node_def(
a_constant_name, value=1, dtype=dtypes.float32, shape=[])
expected_output.node.extend([a_constant])
b_constant = self.create_constant_node_def(
b_constant_name, value=1, dtype=dtypes.float32, shape=[])
expected_output.node.extend([b_constant])
add_node = self.create_node_def("Add", add_name,
[a_constant_name, b_constant_name])
self.set_attr_dtype(add_node, "T", dtypes.float32)
expected_output.node.extend([add_node])
output = optimize_for_inference_lib.optimize_for_inference(
graph_def, [], [add_name], dtypes.float32.as_datatype_enum)
self.assertProtoEquals(expected_output, output)
@test_util.run_deprecated_v1
def testFoldBatchNorms(self):
with self.cached_session() as sess:
inputs = [1, 4, 2, 5, 3, 6, -1, -4, -2, -5, -3, -6]
input_op = constant_op.constant(
np.array(inputs), shape=[1, 1, 6, 2], dtype=dtypes.float32)
weights = [1, 2, 3, 4, 0.1, 0.2, 0.3, 0.4]
weights_op = constant_op.constant(
np.array(weights), shape=[1, 2, 2, 2], dtype=dtypes.float32)
conv_op = nn_ops.conv2d(
input_op, weights_op, [1, 1, 1, 1], padding="SAME", name="conv_op")
mean_op = constant_op.constant(
np.array([10, 20]), shape=[2], dtype=dtypes.float32)
variance_op = constant_op.constant(
np.array([0.25, 0.5]), shape=[2], dtype=dtypes.float32)
beta_op = constant_op.constant(
np.array([0.1, 0.6]), shape=[2], dtype=dtypes.float32)
gamma_op = constant_op.constant(
np.array([1.0, 2.0]), shape=[2], dtype=dtypes.float32)
test_util.set_producer_version(ops.get_default_graph(), 8)
gen_nn_ops._batch_norm_with_global_normalization(
conv_op,
mean_op,
variance_op,
beta_op,
gamma_op,
0.00001,
False,
name="output")
original_graph_def = sess.graph_def
original_result = sess.run(["output:0"])
optimized_graph_def = optimize_for_inference_lib.fold_batch_norms(
original_graph_def)
with self.cached_session() as sess:
_ = importer.import_graph_def(
optimized_graph_def, input_map={}, name="optimized")
optimized_result = sess.run(["optimized/output:0"])
self.assertAllClose(original_result, optimized_result)
for node in optimized_graph_def.node:
self.assertNotEqual("BatchNormWithGlobalNormalization", node.op)
@test_util.run_deprecated_v1
def testFoldFusedBatchNorms(self):
for data_format, use_gpu, conv2d_func in [
("NHWC", False, nn_ops.conv2d), ("NCHW", True, nn_ops.conv2d),
("NHWC", False, nn_ops.depthwise_conv2d_native),
("NCHW", True, nn_ops.depthwise_conv2d_native)
]:
with self.cached_session(use_gpu=use_gpu) as sess:
inputs = [1, 4, 2, 5, 3, 6, -1, -4, -2, -5, -3, -6]
input_op = constant_op.constant(
np.array(inputs),
shape=[1, 1, 6, 2] if data_format == "NHWC" else [1, 2, 1, 6],
dtype=dtypes.float32)
if conv2d_func == nn_ops.conv2d:
weights = [1, 2, 3, 4, 0.1, 0.2, 0.3, 0.4]
weights_op = constant_op.constant(
np.array(weights), shape=[1, 2, 2, 2], dtype=dtypes.float32)
else:
weights = [1, 2, 0.3, 0.4]
weights_op = constant_op.constant(
np.array(weights), shape=[1, 2, 2, 1], dtype=dtypes.float32)
conv_op = conv2d_func(
input_op,
weights_op, [1, 1, 1, 1],
padding="SAME",
data_format=data_format,
name="conv_op")
mean_op = constant_op.constant(
np.array([10, 20]), shape=[2], dtype=dtypes.float32)
variance_op = constant_op.constant(
np.array([0.25, 0.5]), shape=[2], dtype=dtypes.float32)
beta_op = constant_op.constant(
np.array([0.1, 0.6]), shape=[2], dtype=dtypes.float32)
gamma_op = constant_op.constant(
np.array([1.0, 2.0]), shape=[2], dtype=dtypes.float32)
ops.get_default_graph().graph_def_versions.producer = 9
gen_nn_ops._fused_batch_norm(
conv_op,
gamma_op,
beta_op,
mean_op,
variance_op,
0.00001,
is_training=False,
data_format=data_format,
name="output")
original_graph_def = sess.graph_def
original_result = sess.run(["output:0"])
optimized_graph_def = optimize_for_inference_lib.fold_batch_norms(
original_graph_def)
_ = importer.import_graph_def(
optimized_graph_def, input_map={}, name="optimized")
optimized_result = sess.run(["optimized/output:0"])
self.assertAllClose(
original_result, optimized_result, rtol=1e-04, atol=1e-06)
for node in optimized_graph_def.node:
self.assertNotEqual("FusedBatchNorm", node.op)
@test_util.run_deprecated_v1
def testFuseResizePadAndConv(self):
with self.cached_session() as sess:
inputs = [1, 4, 2, 5, 3, 6, -1, -4, -2, -5, -3, -6]
input_op = constant_op.constant(
np.array(inputs), shape=[1, 2, 3, 2], dtype=dtypes.float32)
resize_op = image_ops.resize_bilinear(
input_op, [12, 4], align_corners=False)
pad_op = array_ops.pad(resize_op, [[0, 0], [1, 1], [2, 2], [0, 0]],
mode="REFLECT")
weights = [1, 2, 3, 4, 0.1, 0.2, 0.3, 0.4]
weights_op = constant_op.constant(
np.array(weights), shape=[1, 2, 2, 2], dtype=dtypes.float32)
nn_ops.conv2d(
pad_op, weights_op, [1, 1, 1, 1], padding="VALID", name="output")
original_graph_def = sess.graph_def
original_result = sess.run(["output:0"])
optimized_graph_def = optimize_for_inference_lib.fuse_resize_and_conv(
original_graph_def, ["output"])
with self.cached_session() as sess:
_ = importer.import_graph_def(
optimized_graph_def, input_map={}, name="optimized")
optimized_result = sess.run(["optimized/output:0"])
self.assertAllClose(original_result, optimized_result)
for node in optimized_graph_def.node:
self.assertNotEqual("Conv2D", node.op)
self.assertNotEqual("MirrorPad", node.op)
self.assertNotEqual("ResizeBilinear", node.op)
@test_util.run_deprecated_v1
def testFuseResizeAndConv(self):
with self.cached_session() as sess:
inputs = [1, 4, 2, 5, 3, 6, -1, -4, -2, -5, -3, -6]
input_op = constant_op.constant(
np.array(inputs), shape=[1, 2, 3, 2], dtype=dtypes.float32)
resize_op = image_ops.resize_bilinear(
input_op, [12, 4], align_corners=False)
weights = [1, 2, 3, 4, 0.1, 0.2, 0.3, 0.4]
weights_op = constant_op.constant(
np.array(weights), shape=[1, 2, 2, 2], dtype=dtypes.float32)
nn_ops.conv2d(
resize_op, weights_op, [1, 1, 1, 1], padding="VALID", name="output")
original_graph_def = sess.graph_def
original_result = sess.run(["output:0"])
optimized_graph_def = optimize_for_inference_lib.fuse_resize_and_conv(
original_graph_def, ["output"])
with self.cached_session() as sess:
_ = importer.import_graph_def(
optimized_graph_def, input_map={}, name="optimized")
optimized_result = sess.run(["optimized/output:0"])
self.assertAllClose(original_result, optimized_result)
for node in optimized_graph_def.node:
self.assertNotEqual("Conv2D", node.op)
self.assertNotEqual("MirrorPad", node.op)
@test_util.run_deprecated_v1
def testFusePadAndConv(self):
with self.cached_session() as sess:
inputs = [1, 4, 2, 5, 3, 6, -1, -4, -2, -5, -3, -6]
input_op = constant_op.constant(
np.array(inputs), shape=[1, 2, 3, 2], dtype=dtypes.float32)
pad_op = array_ops.pad(input_op, [[0, 0], [1, 1], [2, 2], [0, 0]],
mode="REFLECT")
weights = [1, 2, 3, 4, 0.1, 0.2, 0.3, 0.4]
weights_op = constant_op.constant(
np.array(weights), shape=[1, 2, 2, 2], dtype=dtypes.float32)
nn_ops.conv2d(
pad_op, weights_op, [1, 1, 1, 1], padding="VALID", name="output")
original_graph_def = sess.graph_def
original_result = sess.run(["output:0"])
optimized_graph_def = optimize_for_inference_lib.fuse_resize_and_conv(
original_graph_def, ["output"])
with self.cached_session() as sess:
_ = importer.import_graph_def(
optimized_graph_def, input_map={}, name="optimized")
optimized_result = sess.run(["optimized/output:0"])
self.assertAllClose(original_result, optimized_result)
for node in optimized_graph_def.node:
self.assertNotEqual("Conv2D", node.op)
self.assertNotEqual("ResizeBilinear", node.op)
if __name__ == "__main__":
test.main()
| 6,310 |
310 | {
"name": "JP-8000",
"description": "An analog synth.",
"url": "https://en.wikipedia.org/wiki/Roland_JP-8000"
} | 46 |
421 | //<Snippet1>
using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
public ref class GenericReflectionSample
{
};
int main()
{
// Creating a dynamic assembly requires an AssemblyName
// object, and the current application domain.
//
AssemblyName^ asmName =
gcnew AssemblyName("EmittedAssembly");
AppDomain^ domain = AppDomain::CurrentDomain;
AssemblyBuilder^ sampleAssemblyBuilder =
domain->DefineDynamicAssembly(asmName,
AssemblyBuilderAccess::RunAndSave);
// Define the module that contains the code. For an
// assembly with one module, the module name is the
// assembly name plus a file extension.
ModuleBuilder^ sampleModuleBuilder =
sampleAssemblyBuilder->DefineDynamicModule(asmName->Name,
asmName->Name + ".dll");
TypeBuilder^ sampleTypeBuilder =
sampleModuleBuilder->DefineType("SampleType",
TypeAttributes::Public | TypeAttributes::Abstract);
//<Snippet4>
// Define a Shared, Public method with standard calling
// conventions. Do not specify the parameter types or the
// return type, because type parameters will be used for
// those types, and the type parameters have not been
// defined yet.
MethodBuilder^ sampleMethodBuilder =
sampleTypeBuilder->DefineMethod("SampleMethod",
MethodAttributes::Public | MethodAttributes::Static);
//</Snippet4>
//<Snippet3>
// Defining generic parameters for the method makes it a
// generic method. By convention, type parameters are
// single alphabetic characters. T and U are used here.
//
array<String^>^ genericTypeNames = {"T", "U"};
array<GenericTypeParameterBuilder^>^ genericTypes =
sampleMethodBuilder->DefineGenericParameters(
genericTypeNames);
//</Snippet3>
//<Snippet7>
// Use the IsGenericMethod property to find out if a
// dynamic method is generic, and IsGenericMethodDefinition
// to find out if it defines a generic method.
Console::WriteLine("Is SampleMethod generic? {0}",
sampleMethodBuilder->IsGenericMethod);
Console::WriteLine(
"Is SampleMethod a generic method definition? {0}",
sampleMethodBuilder->IsGenericMethodDefinition);
//</Snippet7>
//<Snippet5>
// Set parameter types for the method. The method takes
// one parameter, and its type is specified by the first
// type parameter, T.
array<Type^>^ parameterTypes = {genericTypes[0]};
sampleMethodBuilder->SetParameters(parameterTypes);
// Set the return type for the method. The return type is
// specified by the second type parameter, U.
sampleMethodBuilder->SetReturnType(genericTypes[1]);
//</Snippet5>
// Generate a code body for the method. The method doesn't
// do anything except return null.
//
ILGenerator^ ilgen = sampleMethodBuilder->GetILGenerator();
ilgen->Emit(OpCodes::Ldnull);
ilgen->Emit(OpCodes::Ret);
//<Snippet6>
// Complete the type.
Type^ sampleType = sampleTypeBuilder->CreateType();
// To bind types to a dynamic generic method, you must
// first call the GetMethod method on the completed type.
// You can then define an array of types, and bind them
// to the method.
MethodInfo^ sampleMethodInfo = sampleType->GetMethod("SampleMethod");
array<Type^>^ boundParameters =
{String::typeid, GenericReflectionSample::typeid};
MethodInfo^ boundMethodInfo =
sampleMethodInfo->MakeGenericMethod(boundParameters);
// Display a string representing the bound method.
Console::WriteLine(boundMethodInfo);
//</Snippet6>
// Save the assembly, so it can be examined with Ildasm.exe.
sampleAssemblyBuilder->Save(asmName->Name + ".dll");
}
/* This code example produces the following output:
Is SampleMethod generic? True
Is SampleMethod a generic method definition? True
GenericReflectionSample SampleMethod[String,GenericReflectionSample](System.String)
*/
//</Snippet1>
| 1,416 |
1,127 | // Copyright (C) 2018-2022 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include <stddef.h>
// !!!!!!!!
// The data for this test (input and ref) was generated in clCaffe using the zf truncated prototxt with the following modifications:
// input height: 420 -> 210
// input width: 700 -> 350
// max proposals: 300 -> 50
// post nms topn: 150 -> 25
// !!!!!!!!
float cls_scores_data[] = {
0.999760f, 0.997614f, 0.999854f, 0.996280f, 0.994689f, 0.999543f, 0.999865f, // 0
0.999969f, 0.999885f, 0.999879f, 0.999758f, 0.999719f, 0.999626f, 0.999386f, // 7
0.999781f, 0.999807f, 0.999814f, 0.999798f, 0.999974f, 0.999963f, 0.999858f, // 14
0.998800f, 0.999405f, 0.999722f, 0.993661f, 0.999785f, 0.990695f, 0.978023f, // 21
0.997218f, 0.998441f, 0.999729f, 0.999761f, 0.999703f, 0.998955f, 0.997905f, // 28
0.998144f, 0.999102f, 0.999674f, 0.999181f, 0.994059f, 0.998818f, 0.999917f, // 35
0.999986f, 0.999887f, 0.999793f, 0.999773f, 0.999959f, 0.994999f, 0.999958f, // 42
0.989061f, 0.973381f, 0.995891f, 0.998625f, 0.996015f, 0.999271f, 0.999531f, // 49
0.997988f, 0.995717f, 0.968533f, 0.996499f, 0.996667f, 0.952375f, 0.882948f, // 56
0.965792f, 0.999604f, 0.999909f, 0.999885f, 0.999734f, 0.999543f, 0.999949f, // 63
0.997167f, 0.999995f, 0.997835f, 0.996311f, 0.989931f, 0.997972f, 0.996871f, // 70
0.985681f, 0.996386f, 0.995814f, 0.991769f, 0.960731f, 0.991291f, 0.985539f, // 77
0.894013f, 0.700601f, 0.886686f, 0.999796f, 0.999966f, 0.999992f, 0.999970f, // 84
0.999877f, 0.999967f, 0.999369f, 0.999971f, 0.998783f, 0.991663f, 0.991151f, // 91
0.998962f, 0.998531f, 0.999447f, 0.996570f, 0.996692f, 0.963337f, 0.914104f, // 98
0.995752f, 0.992903f, 0.970398f, 0.964943f, 0.992031f, 0.999977f, 0.999973f, // 105
0.999989f, 0.999901f, 0.999952f, 0.999971f, 0.999865f, 0.999988f, 0.999607f, // 112
0.996472f, 0.992275f, 0.998249f, 0.999689f, 0.999792f, 0.998995f, 0.996864f, // 119
0.915830f, 0.961017f, 0.997340f, 0.999554f, 0.996466f, 0.988443f, 0.994445f, // 126
0.999980f, 0.999989f, 0.999997f, 0.999932f, 0.999950f, 0.999925f, 0.999904f, // 133
0.999980f, 0.999488f, 0.998567f, 0.999101f, 0.999895f, 0.999989f, 0.999981f, // 140
0.999986f, 0.999957f, 0.999897f, 0.999858f, 0.999981f, 0.999966f, 0.999980f, // 147
0.999802f, 0.999529f, 0.999941f, 0.999998f, 0.999998f, 0.999988f, 0.999920f, // 154
0.999910f, 0.999903f, 0.999986f, 0.999826f, 0.999764f, 0.999321f, 0.999819f, // 161
0.999947f, 0.999978f, 0.999967f, 0.999857f, 0.999448f, 0.999531f, 0.999838f, // 168
0.999955f, 0.999411f, 0.993570f, 0.994893f, 0.999803f, 0.999877f, 0.999972f, // 175
0.999926f, 0.999954f, 0.999925f, 0.999788f, 0.999970f, 0.999705f, 0.998057f, // 182
0.999226f, 0.999471f, 0.999828f, 0.999590f, 0.998533f, 0.999250f, 0.998671f, // 189
0.999495f, 0.997583f, 0.982739f, 0.903012f, 0.955415f, 0.976917f, 0.997332f, // 196
0.999732f, 0.999773f, 0.999660f, 0.999915f, 0.999943f, 0.999365f, 0.999970f, // 203
0.999652f, 0.999237f, 0.998239f, 0.998708f, 0.999271f, 0.999483f, 0.997788f, // 210
0.996666f, 0.996630f, 0.998032f, 0.998487f, 0.973191f, 0.858837f, 0.906232f, // 217
0.965586f, 0.998687f, 0.999928f, 0.999945f, 0.998419f, 0.999824f, 0.999967f, // 224
0.999874f, 0.999971f, 0.999790f, 0.996396f, 0.997420f, 0.998715f, 0.995572f, // 231
0.998603f, 0.996269f, 0.999217f, 0.999036f, 0.999897f, 0.999815f, 0.994846f, // 238
0.860571f, 0.951439f, 0.932385f, 0.997515f, 0.999775f, 0.999977f, 0.999902f, // 245
0.999594f, 0.999975f, 0.999933f, 0.999975f, 0.999604f, 0.997754f, 0.997832f, // 252
0.997185f, 0.998882f, 0.999785f, 0.998945f, 0.999142f, 0.999618f, 0.999877f, // 259
0.999942f, 0.994331f, 0.985108f, 0.992910f, 0.990646f, 0.998899f, 0.999783f, // 266
0.999997f, 0.999830f, 0.999810f, 0.999684f, 0.999836f, 0.999678f, 0.999214f, // 273
0.997177f, 0.998292f, 0.993788f, 0.996324f, 0.995714f, 0.995189f, 0.997156f, // 280
0.997874f, 0.999060f, 0.996942f, 0.994102f, 0.985827f, 0.991195f, 0.992798f, // 287
0.999495f, 0.999980f, 0.999996f, 0.999889f, 0.999705f, 0.999702f, 0.999865f, // 294
0.999877f, 0.999468f, 0.998301f, 0.999109f, 0.998464f, 0.998180f, 0.996299f, // 301
0.996471f, 0.993834f, 0.994249f, 0.998304f, 0.998855f, 0.998657f, 0.998947f, // 308
0.999362f, 0.999766f, 0.999824f, 0.999805f, 0.999954f, 0.999649f, 0.999181f, // 315
0.996198f, 0.969997f, 0.990344f, 0.974068f, 0.989631f, 0.982654f, 0.982175f, // 322
0.995685f, 0.989821f, 0.990400f, 0.994498f, 0.983612f, 0.983035f, 0.979785f, // 329
0.989498f, 0.987983f, 0.995460f, 0.995709f, 0.992700f, 0.989960f, 0.983448f, // 336
0.972951f, 0.983038f, 0.995849f, 0.953501f, 0.994814f, 0.953191f, 0.987846f, // 343
0.987136f, 0.960681f, 0.956620f, 0.985869f, 0.977525f, 0.970702f, 0.945902f, // 350
0.985732f, 0.987192f, 0.993266f, 0.983946f, 0.982892f, 0.995270f, 0.998845f, // 357
0.998779f, 0.994529f, 0.984046f, 0.982643f, 0.999085f, 0.971369f, 0.999216f, // 364
0.941805f, 0.993725f, 0.960288f, 0.962136f, 0.885667f, 0.979034f, 0.976966f, // 371
0.952957f, 0.954654f, 0.984637f, 0.962852f, 0.974669f, 0.961519f, 0.995640f, // 378
0.997486f, 0.989937f, 0.989097f, 0.993949f, 0.985946f, 0.961074f, 0.999128f, // 385
0.994822f, 0.999594f, 0.972421f, 0.996484f, 0.978500f, 0.905665f, 0.543202f, // 392
0.580557f, 0.584553f, 0.479662f, 0.584665f, 0.669499f, 0.369245f, 0.728641f, // 399
0.925864f, 0.969121f, 0.960105f, 0.992419f, 0.996462f, 0.999416f, 0.998074f, // 406
0.990102f, 0.998639f, 0.993153f, 0.994321f, 0.961146f, 0.955374f, 0.841573f, // 413
0.644760f, 0.612033f, 0.592992f, 0.453401f, 0.314286f, 0.368358f, 0.412866f, // 420
0.347731f, 0.583194f, 0.576559f, 0.934077f, 0.947455f, 0.989646f, 0.990886f, // 427
0.997102f, 0.987593f, 0.986330f, 0.997549f, 0.993835f, 0.998290f, 0.968147f, // 434
0.915319f, 0.759578f, 0.303624f, 0.725361f, 0.555394f, 0.397444f, 0.206768f, // 441
0.145288f, 0.374900f, 0.303877f, 0.311079f, 0.547876f, 0.848138f, 0.889720f, // 448
0.991683f, 0.990137f, 0.997052f, 0.988971f, 0.995871f, 0.996238f, 0.996730f, // 455
0.998781f, 0.960781f, 0.934602f, 0.858142f, 0.653398f, 0.870650f, 0.956511f, // 462
0.920880f, 0.909397f, 0.931287f, 0.959581f, 0.880133f, 0.699706f, 0.648377f, // 469
0.942166f, 0.914327f, 0.986236f, 0.993957f, 0.994163f, 0.991457f, 0.991324f, // 476
0.996819f, 0.998433f, 0.998478f, 0.975620f, 0.953352f, 0.962704f, 0.574046f, // 483
0.705828f, 0.893073f, 0.929323f, 0.887734f, 0.858466f, 0.883048f, 0.799384f, // 490
0.488242f, 0.471657f, 0.747769f, 0.877862f, 0.988541f, 0.993086f, 0.996307f, // 497
0.995032f, 0.994185f, 0.997912f, 0.996914f, 0.997072f, 0.961510f, 0.912040f, // 504
0.971116f, 0.820241f, 0.844718f, 0.838774f, 0.589216f, 0.439355f, 0.379576f, // 511
0.542740f, 0.323931f, 0.153144f, 0.283005f, 0.909226f, 0.892069f, 0.984070f, // 518
0.978557f, 0.978070f, 0.991541f, 0.988522f, 0.998755f, 0.995174f, 0.999664f, // 525
0.989923f, 0.981631f, 0.990046f, 0.891157f, 0.919551f, 0.929645f, 0.890329f, // 532
0.843198f, 0.804238f, 0.748836f, 0.656154f, 0.370339f, 0.577034f, 0.948440f, // 539
0.958947f, 0.997103f, 0.988545f, 0.991007f, 0.975149f, 0.987809f, 0.999437f, // 546
0.999447f, 0.999856f, 0.998255f, 0.990059f, 0.991811f, 0.899978f, 0.818183f, // 553
0.832787f, 0.710880f, 0.618197f, 0.571525f, 0.683950f, 0.614582f, 0.686417f, // 560
0.765088f, 0.905834f, 0.914197f, 0.965693f, 0.982083f, 0.995691f, 0.997661f, // 567
0.987798f, 0.999593f, 0.997429f, 0.999985f, 0.998277f, 0.997462f, 0.991030f, // 574
0.897823f, 0.937336f, 0.932453f, 0.758912f, 0.806659f, 0.740961f, 0.895110f, // 581
0.899444f, 0.824788f, 0.876036f, 0.948416f, 0.922776f, 0.968857f, 0.970995f, // 588
0.992958f, 0.983983f, 0.969614f, 0.997587f, 0.993744f, 0.999684f, 0.996765f, // 595
0.985546f, 0.979127f, 0.844441f, 0.881639f, 0.849229f, 0.822146f, 0.800652f, // 602
0.790445f, 0.881262f, 0.728860f, 0.719565f, 0.775369f, 0.860437f, 0.884172f, // 609
0.971110f, 0.994612f, 0.996140f, 0.989965f, 0.986417f, 0.982382f, 0.899666f, // 616
0.978391f, 0.965273f, 0.975472f, 0.963377f, 0.833568f, 0.874908f, 0.873460f, // 623
0.809395f, 0.723682f, 0.705708f, 0.895638f, 0.830704f, 0.831258f, 0.794961f, // 630
0.819171f, 0.916302f, 0.929399f, 0.949790f, 0.893942f, 0.916434f, 0.893389f, // 637
0.888568f, 0.723448f, 0.824538f, 0.748599f, 0.912385f, 0.910238f, 0.849881f, // 644
0.806850f, 0.706813f, 0.677218f, 0.892135f, 0.785928f, 0.795219f, 0.834211f, // 651
0.836607f, 0.866503f, 0.920681f, 0.938905f, 0.903987f, 0.869993f, 0.790304f, // 658
0.691778f, 0.788635f, 0.731415f, 0.292696f, 0.506911f, 0.367870f, 0.730405f, // 665
0.821144f, 0.605525f, 0.343082f, 0.571531f, 0.581484f, 0.343038f, 0.358793f, // 672
0.718659f, 0.785855f, 0.828420f, 0.680030f, 0.752810f, 0.805862f, 0.856268f, // 679
0.613096f, 0.537594f, 0.619865f, 0.702573f, 0.911837f, 0.521979f, 0.717770f, // 686
0.706305f, 0.860205f, 0.873772f, 0.867362f, 0.531694f, 0.478688f, 0.514347f, // 693
0.563169f, 0.676293f, 0.850726f, 0.419226f, 0.845486f, 0.808221f, 0.933771f, // 700
0.960192f, 0.801797f, 0.867503f, 0.864051f, 0.838265f, 0.775403f, 0.902710f, // 707
0.760107f, 0.779129f, 0.779949f, 0.919224f, 0.829614f, 0.857095f, 0.317603f, // 714
0.612115f, 0.726438f, 0.562883f, 0.735437f, 0.847618f, 0.445833f, 0.706618f, // 721
0.697789f, 0.667618f, 0.679828f, 0.725863f, 0.842693f, 0.844795f, 0.875500f, // 728
0.850662f, 0.924195f, 0.835076f, 0.536677f, 0.646111f, 0.413658f, 0.404158f, // 735
0.087165f, 0.061926f, 0.100454f, 0.333942f, 0.266647f, 0.523658f, 0.658457f, // 742
0.236509f, 0.239853f, 0.108503f, 0.256146f, 0.350660f, 0.400979f, 0.521853f, // 749
0.467838f, 0.494477f, 0.847233f, 0.912449f, 0.860756f, 0.731967f, 0.681897f, // 756
0.406955f, 0.301521f, 0.044839f, 0.021107f, 0.029903f, 0.056354f, 0.070960f, // 763
0.061341f, 0.098331f, 0.039871f, 0.023180f, 0.046859f, 0.236035f, 0.261649f, // 770
0.516213f, 0.472581f, 0.473051f, 0.615177f, 0.861918f, 0.869517f, 0.769965f, // 777
0.669826f, 0.492565f, 0.393471f, 0.259393f, 0.040120f, 0.021358f, 0.010922f, // 784
0.012051f, 0.020779f, 0.048921f, 0.027165f, 0.012126f, 0.013826f, 0.014046f, // 791
0.139384f, 0.098426f, 0.377585f, 0.347929f, 0.316678f, 0.501830f, 0.697993f, // 798
0.857482f, 0.804920f, 0.676675f, 0.492651f, 0.368129f, 0.626094f, 0.094855f, // 805
0.029003f, 0.012540f, 0.013723f, 0.025631f, 0.022791f, 0.025637f, 0.009720f, // 812
0.007911f, 0.008195f, 0.122635f, 0.241276f, 0.604555f, 0.642974f, 0.519746f, // 819
0.564844f, 0.781997f, 0.860851f, 0.757326f, 0.635008f, 0.449969f, 0.380766f, // 826
0.689936f, 0.247608f, 0.097016f, 0.098563f, 0.075148f, 0.035460f, 0.054005f, // 833
0.021277f, 0.018945f, 0.016637f, 0.026240f, 0.090315f, 0.216662f, 0.348577f, // 840
0.278438f, 0.222277f, 0.642391f, 0.743720f, 0.904140f, 0.785186f, 0.820499f, // 847
0.565004f, 0.441343f, 0.679112f, 0.300936f, 0.178006f, 0.076504f, 0.242118f, // 854
0.077224f, 0.058206f, 0.011026f, 0.011983f, 0.010536f, 0.048396f, 0.094240f, // 861
0.189596f, 0.312272f, 0.075316f, 0.097815f, 0.413469f, 0.552727f, 0.949021f, // 868
0.768493f, 0.650804f, 0.474774f, 0.348153f, 0.755292f, 0.373893f, 0.397724f, // 875
0.148665f, 0.167840f, 0.067934f, 0.064996f, 0.026464f, 0.021125f, 0.010753f, // 882
0.026675f, 0.059142f, 0.110014f, 0.141964f, 0.223932f, 0.289303f, 0.485672f, // 889
0.668469f, 0.958467f, 0.390397f, 0.829152f, 0.238913f, 0.482665f, 0.405217f, // 896
0.220169f, 0.306487f, 0.158856f, 0.188860f, 0.237450f, 0.284332f, 0.252760f, // 903
0.085425f, 0.069374f, 0.079123f, 0.069466f, 0.129356f, 0.215579f, 0.241465f, // 910
0.202133f, 0.481209f, 0.594865f, 0.953197f, 0.469512f, 0.798204f, 0.433447f, // 917
0.542215f, 0.477647f, 0.139398f, 0.124062f, 0.119590f, 0.119725f, 0.134432f, // 924
0.142069f, 0.120058f, 0.080532f, 0.066760f, 0.205675f, 0.151697f, 0.155706f, // 931
0.319563f, 0.289189f, 0.158544f, 0.321576f, 0.712270f, 0.917505f, 0.599874f, // 938
0.546659f, 0.476803f, 0.634105f, 0.532294f, 0.272988f, 0.275814f, 0.334958f, // 945
0.332632f, 0.319392f, 0.299633f, 0.347133f, 0.175618f, 0.176744f, 0.174846f, // 952
0.258330f, 0.323873f, 0.260937f, 0.225014f, 0.264785f, 0.404971f, 0.499029f, // 959
0.999497f, 0.999733f, 0.999853f, 0.998535f, 0.957997f, 0.999180f, 0.999924f, // 966
0.999968f, 0.999975f, 0.999968f, 0.999809f, 0.999893f, 0.999837f, 0.999775f, // 973
0.999848f, 0.999625f, 0.999201f, 0.998891f, 0.999617f, 0.999884f, 0.999773f, // 980
0.998634f, 0.996673f, 0.999949f, 0.999912f, 0.999994f, 0.999546f, 0.989322f, // 987
0.999433f, 0.999847f, 0.999983f, 0.999989f, 0.999975f, 0.999887f, 0.999793f, // 994
0.999770f, 0.999851f, 0.999870f, 0.998437f, 0.995077f, 0.998152f, 0.999577f, // 1001
0.999992f, 0.999916f, 0.999954f, 0.999421f, 0.999971f, 0.999824f, 0.999987f, // 1008
0.997392f, 0.978402f, 0.999606f, 0.999880f, 0.999917f, 0.999993f, 0.999987f, // 1015
0.999856f, 0.999642f, 0.999470f, 0.999832f, 0.999424f, 0.988887f, 0.967358f, // 1022
0.987293f, 0.999777f, 0.999982f, 0.999963f, 0.999888f, 0.998823f, 0.999977f, // 1029
0.999253f, 0.999988f, 0.984433f, 0.962038f, 0.996645f, 0.999894f, 0.999963f, // 1036
0.999748f, 0.999618f, 0.998398f, 0.999649f, 0.998875f, 0.999624f, 0.999116f, // 1043
0.974202f, 0.684378f, 0.886511f, 0.998597f, 0.999937f, 0.999990f, 0.999976f, // 1050
0.999538f, 0.999990f, 0.999469f, 0.999911f, 0.990091f, 0.968860f, 0.998541f, // 1057
0.999956f, 0.999950f, 0.999985f, 0.998926f, 0.993699f, 0.994075f, 0.994959f, // 1064
0.999855f, 0.995840f, 0.976424f, 0.933430f, 0.968670f, 0.998340f, 0.999964f, // 1071
0.999978f, 0.999966f, 0.999711f, 0.999992f, 0.999765f, 0.999822f, 0.996191f, // 1078
0.987074f, 0.998523f, 0.999881f, 0.999860f, 0.999983f, 0.999445f, 0.995831f, // 1085
0.988292f, 0.997174f, 0.999872f, 0.999812f, 0.996974f, 0.946613f, 0.957796f, // 1092
0.997328f, 0.999825f, 0.999953f, 0.999964f, 0.999688f, 0.999992f, 0.999803f, // 1099
0.999479f, 0.998809f, 0.995591f, 0.999744f, 0.999992f, 0.999989f, 0.999994f, // 1106
0.999971f, 0.999941f, 0.999966f, 0.999954f, 0.999996f, 0.999990f, 0.999992f, // 1113
0.999418f, 0.995756f, 0.997124f, 0.999967f, 0.999957f, 0.999983f, 0.999844f, // 1120
0.999989f, 0.999834f, 0.999647f, 0.999631f, 0.999402f, 0.999782f, 0.999987f, // 1127
0.999981f, 0.999985f, 0.999970f, 0.999942f, 0.999950f, 0.999823f, 0.999938f, // 1134
0.999991f, 0.999783f, 0.988083f, 0.941956f, 0.982905f, 0.996510f, 0.999113f, // 1141
0.999739f, 0.999942f, 0.999985f, 0.999862f, 0.999330f, 0.999567f, 0.998863f, // 1148
0.999891f, 0.999973f, 0.999962f, 0.999926f, 0.999827f, 0.999934f, 0.999826f, // 1155
0.999826f, 0.999661f, 0.999167f, 0.988051f, 0.876655f, 0.902640f, 0.967358f, // 1162
0.996773f, 0.997971f, 0.998217f, 0.999786f, 0.999991f, 0.999808f, 0.999769f, // 1169
0.999651f, 0.999642f, 0.999932f, 0.999966f, 0.999942f, 0.999790f, 0.999892f, // 1176
0.999806f, 0.999869f, 0.999938f, 0.999936f, 0.998891f, 0.991069f, 0.975941f, // 1183
0.979335f, 0.993476f, 0.999441f, 0.999776f, 0.996695f, 0.999178f, 0.999996f, // 1190
0.999978f, 0.999931f, 0.999954f, 0.999363f, 0.999942f, 0.999961f, 0.999806f, // 1197
0.999871f, 0.999961f, 0.999972f, 0.999985f, 0.999999f, 0.999999f, 0.999983f, // 1204
0.998594f, 0.996478f, 0.982044f, 0.996349f, 0.999287f, 0.999954f, 0.999397f, // 1211
0.998363f, 0.999998f, 0.999995f, 0.999969f, 0.999910f, 0.999640f, 0.999959f, // 1218
0.999937f, 0.999872f, 0.999974f, 0.999989f, 0.999968f, 0.999981f, 0.999987f, // 1225
0.999990f, 0.999923f, 0.999066f, 0.996527f, 0.993612f, 0.999199f, 0.999944f, // 1232
0.999997f, 0.999759f, 0.999654f, 0.999999f, 0.999989f, 0.999988f, 0.999940f, // 1239
0.999686f, 0.999916f, 0.999906f, 0.999782f, 0.999596f, 0.999825f, 0.999813f, // 1246
0.999889f, 0.999917f, 0.999872f, 0.999913f, 0.997598f, 0.991883f, 0.992452f, // 1253
0.999756f, 0.999988f, 0.999998f, 0.999977f, 0.999463f, 0.999971f, 0.999972f, // 1260
0.999992f, 0.999915f, 0.999493f, 0.999882f, 0.999876f, 0.999546f, 0.999159f, // 1267
0.999592f, 0.999371f, 0.999258f, 0.999744f, 0.999901f, 0.999881f, 0.999743f, // 1274
0.999392f, 0.999711f, 0.999972f, 0.999989f, 0.999953f, 0.999879f, 0.998937f, // 1281
0.992113f, 0.977029f, 0.985282f, 0.909553f, 0.926129f, 0.896014f, 0.949489f, // 1288
0.992746f, 0.993495f, 0.995457f, 0.994664f, 0.987973f, 0.983728f, 0.963049f, // 1295
0.976884f, 0.971395f, 0.968997f, 0.981907f, 0.977866f, 0.985096f, 0.977582f, // 1302
0.961854f, 0.971201f, 0.996346f, 0.977614f, 0.992298f, 0.942566f, 0.933911f, // 1309
0.823994f, 0.956478f, 0.949016f, 0.989743f, 0.983017f, 0.983782f, 0.977440f, // 1316
0.980739f, 0.983628f, 0.979537f, 0.936331f, 0.858010f, 0.971435f, 0.997348f, // 1323
0.999288f, 0.998125f, 0.995031f, 0.988316f, 0.999095f, 0.977485f, 0.999016f, // 1330
0.962232f, 0.963755f, 0.631680f, 0.933954f, 0.728761f, 0.914504f, 0.959326f, // 1337
0.917330f, 0.866254f, 0.962668f, 0.927347f, 0.904164f, 0.868322f, 0.884115f, // 1344
0.972339f, 0.993103f, 0.994758f, 0.993805f, 0.965747f, 0.949517f, 0.999158f, // 1351
0.986056f, 0.998169f, 0.948556f, 0.971136f, 0.871568f, 0.906326f, 0.695860f, // 1358
0.548789f, 0.442352f, 0.501772f, 0.390472f, 0.435836f, 0.402781f, 0.796551f, // 1365
0.897642f, 0.887577f, 0.928106f, 0.996205f, 0.996821f, 0.999505f, 0.994576f, // 1372
0.981797f, 0.999044f, 0.985085f, 0.989434f, 0.872405f, 0.811320f, 0.411090f, // 1379
0.630367f, 0.850732f, 0.547475f, 0.413042f, 0.428982f, 0.404978f, 0.349761f, // 1386
0.477280f, 0.793972f, 0.719923f, 0.700229f, 0.735202f, 0.987932f, 0.988996f, // 1393
0.997995f, 0.986107f, 0.974046f, 0.998298f, 0.969031f, 0.992329f, 0.880470f, // 1400
0.660777f, 0.297330f, 0.354794f, 0.851255f, 0.528148f, 0.441363f, 0.399079f, // 1407
0.282934f, 0.336675f, 0.335466f, 0.524325f, 0.586797f, 0.479315f, 0.466199f, // 1414
0.980393f, 0.987887f, 0.998833f, 0.993989f, 0.992860f, 0.998245f, 0.990333f, // 1421
0.993726f, 0.897509f, 0.580930f, 0.306392f, 0.476747f, 0.918474f, 0.899765f, // 1428
0.843685f, 0.862607f, 0.896648f, 0.874069f, 0.713457f, 0.469581f, 0.260021f, // 1435
0.255751f, 0.549801f, 0.930796f, 0.984948f, 0.995557f, 0.994133f, 0.991139f, // 1442
0.997137f, 0.995805f, 0.993660f, 0.912765f, 0.584159f, 0.564443f, 0.454247f, // 1449
0.876793f, 0.917262f, 0.895287f, 0.960393f, 0.937284f, 0.858638f, 0.727810f, // 1456
0.107323f, 0.094254f, 0.053740f, 0.404548f, 0.952841f, 0.979792f, 0.995610f, // 1463
0.995458f, 0.991962f, 0.998340f, 0.996968f, 0.995433f, 0.947564f, 0.557899f, // 1470
0.510490f, 0.722521f, 0.953451f, 0.929864f, 0.767441f, 0.844743f, 0.820140f, // 1477
0.721148f, 0.569400f, 0.208037f, 0.342727f, 0.632607f, 0.705470f, 0.961242f, // 1484
0.984216f, 0.994391f, 0.994183f, 0.989294f, 0.998905f, 0.997580f, 0.999488f, // 1491
0.993341f, 0.965337f, 0.964574f, 0.952546f, 0.987110f, 0.987293f, 0.968956f, // 1498
0.966872f, 0.966354f, 0.945835f, 0.931620f, 0.625058f, 0.672368f, 0.898064f, // 1505
0.938643f, 0.992843f, 0.997877f, 0.999132f, 0.990606f, 0.988509f, 0.999498f, // 1512
0.999617f, 0.999972f, 0.999662f, 0.996818f, 0.992909f, 0.977505f, 0.986234f, // 1519
0.981044f, 0.962260f, 0.959226f, 0.974940f, 0.989887f, 0.977104f, 0.906481f, // 1526
0.907825f, 0.953851f, 0.934680f, 0.971690f, 0.991948f, 0.999128f, 0.998621f, // 1533
0.986659f, 0.999640f, 0.999347f, 0.999996f, 0.999277f, 0.998432f, 0.992496f, // 1540
0.980933f, 0.994455f, 0.991148f, 0.936293f, 0.962135f, 0.915295f, 0.954144f, // 1547
0.979226f, 0.941273f, 0.916849f, 0.964255f, 0.912469f, 0.968713f, 0.991871f, // 1554
0.996845f, 0.991198f, 0.942430f, 0.995088f, 0.995815f, 0.999900f, 0.998671f, // 1561
0.990578f, 0.960266f, 0.812697f, 0.896493f, 0.881006f, 0.863730f, 0.835431f, // 1568
0.892318f, 0.923837f, 0.864730f, 0.893482f, 0.850471f, 0.866329f, 0.883857f, // 1575
0.973513f, 0.997406f, 0.998598f, 0.997252f, 0.984303f, 0.969704f, 0.906427f, // 1582
0.985393f, 0.966973f, 0.963818f, 0.899985f, 0.764385f, 0.838437f, 0.864566f, // 1589
0.785489f, 0.789968f, 0.736458f, 0.899924f, 0.855828f, 0.807684f, 0.826774f, // 1596
0.837121f, 0.886432f, 0.978468f, 0.991832f, 0.966848f, 0.964845f, 0.910712f, // 1603
0.855299f, 0.712047f, 0.727652f, 0.511531f, 0.583237f, 0.632007f, 0.730399f, // 1610
0.814443f, 0.824655f, 0.833140f, 0.913107f, 0.807246f, 0.784723f, 0.737805f, // 1617
0.758298f, 0.690821f, 0.696955f, 0.843361f, 0.870489f, 0.828577f, 0.771499f, // 1624
0.712055f, 0.619777f, 0.685800f, 0.443506f, 0.575696f, 0.422641f, 0.652189f, // 1631
0.602859f, 0.628068f, 0.527269f, 0.788988f, 0.651555f, 0.464847f, 0.605121f, // 1638
0.752782f, 0.791347f, 0.806856f, 0.637396f, 0.522266f, 0.703096f, 0.885479f, // 1645
0.820196f, 0.825606f, 0.814776f, 0.595017f, 0.835167f, 0.783081f, 0.854805f, // 1652
0.858609f, 0.921839f, 0.767072f, 0.810653f, 0.545878f, 0.646392f, 0.592960f, // 1659
0.627860f, 0.743636f, 0.912323f, 0.572211f, 0.842405f, 0.888886f, 0.917378f, // 1666
0.935476f, 0.871345f, 0.940898f, 0.935297f, 0.856684f, 0.742654f, 0.857495f, // 1673
0.789229f, 0.751434f, 0.829616f, 0.923690f, 0.810574f, 0.775529f, 0.354988f, // 1680
0.743024f, 0.727567f, 0.591648f, 0.804080f, 0.940856f, 0.629125f, 0.836846f, // 1687
0.829974f, 0.701143f, 0.747231f, 0.874164f, 0.951534f, 0.971029f, 0.929958f, // 1694
0.702368f, 0.888289f, 0.846405f, 0.623694f, 0.747457f, 0.478133f, 0.174285f, // 1701
0.085599f, 0.130264f, 0.194132f, 0.588187f, 0.535293f, 0.763333f, 0.784651f, // 1708
0.383962f, 0.408097f, 0.226135f, 0.300047f, 0.324524f, 0.599570f, 0.843785f, // 1715
0.913996f, 0.735049f, 0.625757f, 0.866219f, 0.805777f, 0.707550f, 0.730362f, // 1722
0.433394f, 0.211320f, 0.048615f, 0.077644f, 0.063318f, 0.088399f, 0.157592f, // 1729
0.183132f, 0.165966f, 0.064351f, 0.037464f, 0.124407f, 0.242683f, 0.242699f, // 1736
0.673224f, 0.782381f, 0.820321f, 0.774675f, 0.727654f, 0.852186f, 0.606563f, // 1743
0.717671f, 0.537678f, 0.323996f, 0.075599f, 0.015523f, 0.031548f, 0.013561f, // 1750
0.019603f, 0.032282f, 0.067733f, 0.033151f, 0.011739f, 0.009005f, 0.005905f, // 1757
0.044726f, 0.064372f, 0.413025f, 0.472732f, 0.451143f, 0.547363f, 0.644876f, // 1764
0.812567f, 0.692145f, 0.714148f, 0.547532f, 0.291447f, 0.392314f, 0.046687f, // 1771
0.038928f, 0.029809f, 0.023035f, 0.053392f, 0.054591f, 0.060529f, 0.019434f, // 1778
0.002721f, 0.003585f, 0.051150f, 0.120061f, 0.567339f, 0.688389f, 0.760716f, // 1785
0.804160f, 0.626254f, 0.861594f, 0.765137f, 0.772215f, 0.627873f, 0.381387f, // 1792
0.390245f, 0.196466f, 0.113428f, 0.129522f, 0.093196f, 0.084715f, 0.156252f, // 1799
0.101556f, 0.056507f, 0.027248f, 0.057363f, 0.151247f, 0.227260f, 0.423423f, // 1806
0.529300f, 0.654602f, 0.854520f, 0.653776f, 0.888866f, 0.818421f, 0.877624f, // 1813
0.812885f, 0.654068f, 0.659864f, 0.386556f, 0.258964f, 0.128604f, 0.258983f, // 1820
0.213130f, 0.223074f, 0.072424f, 0.059449f, 0.032588f, 0.104698f, 0.189352f, // 1827
0.296665f, 0.401676f, 0.347865f, 0.572963f, 0.730474f, 0.475673f, 0.914870f, // 1834
0.836139f, 0.874182f, 0.896286f, 0.776951f, 0.876888f, 0.607976f, 0.588553f, // 1841
0.277133f, 0.358344f, 0.205281f, 0.191824f, 0.104481f, 0.088596f, 0.044452f, // 1848
0.096065f, 0.168654f, 0.209575f, 0.231857f, 0.480104f, 0.809522f, 0.833009f, // 1855
0.653328f, 0.927858f, 0.696302f, 0.946167f, 0.745575f, 0.855820f, 0.711776f, // 1862
0.282464f, 0.486443f, 0.354680f, 0.398541f, 0.451188f, 0.476508f, 0.410548f, // 1869
0.191992f, 0.193113f, 0.193733f, 0.226326f, 0.222284f, 0.374854f, 0.640101f, // 1876
0.848109f, 0.799415f, 0.391757f, 0.815723f, 0.713017f, 0.915503f, 0.762712f, // 1883
0.732930f, 0.462720f, 0.109928f, 0.165662f, 0.162975f, 0.188768f, 0.181095f, // 1890
0.240185f, 0.221834f, 0.199734f, 0.160855f, 0.314757f, 0.169385f, 0.226659f, // 1897
0.467615f, 0.659094f, 0.664336f, 0.710697f, 0.534815f, 0.766002f, 0.560993f, // 1904
0.495162f, 0.499407f, 0.624246f, 0.406035f, 0.156340f, 0.223907f, 0.299512f, // 1911
0.251434f, 0.278354f, 0.244217f, 0.299649f, 0.188096f, 0.162461f, 0.215128f, // 1918
0.293723f, 0.277333f, 0.294707f, 0.398474f, 0.395312f, 0.456742f, 0.464048f, // 1925
0.600926f, 0.949765f, 0.934801f, 0.907741f, 0.955718f, 0.973685f, 0.973320f, // 1932
0.948474f, 0.967413f, 0.955089f, 0.921578f, 0.950469f, 0.967702f, 0.912325f, // 1939
0.918200f, 0.934038f, 0.948527f, 0.973938f, 0.919118f, 0.917107f, 0.888288f, // 1946
0.927474f, 0.722152f, 0.244802f, 0.999223f, 0.999608f, 0.998246f, 0.998300f, // 1953
0.992470f, 0.988249f, 0.997343f, 0.999251f, 0.997541f, 0.996770f, 0.993966f, // 1960
0.994242f, 0.976160f, 0.978450f, 0.991602f, 0.998060f, 0.999601f, 0.998134f, // 1967
0.999578f, 0.999228f, 0.997265f, 0.801990f, 0.371084f, 0.999679f, 0.999934f, // 1974
0.998457f, 0.998569f, 0.996675f, 0.995883f, 0.996376f, 0.999771f, 0.997144f, // 1981
0.978518f, 0.940507f, 0.977218f, 0.994284f, 0.993288f, 0.997512f, 0.999286f, // 1988
0.999681f, 0.997522f, 0.999560f, 0.987282f, 0.970239f, 0.398418f, 0.375668f, // 1995
0.999761f, 0.999949f, 0.998636f, 0.997664f, 0.996325f, 0.994516f, 0.999518f, // 2002
0.999698f, 0.999033f, 0.994652f, 0.995763f, 0.998113f, 0.998807f, 0.996574f, // 2009
0.996182f, 0.998047f, 0.999758f, 0.996963f, 0.999895f, 0.999047f, 0.996030f, // 2016
0.635083f, 0.410343f, 0.999733f, 0.999793f, 0.998661f, 0.996395f, 0.999384f, // 2023
0.998636f, 0.999864f, 0.999995f, 0.999982f, 0.998342f, 0.999344f, 0.999820f, // 2030
0.999831f, 0.999087f, 0.998244f, 0.999851f, 0.999596f, 0.996652f, 0.999480f, // 2037
0.998927f, 0.998670f, 0.763438f, 0.313442f, 0.999638f, 0.999798f, 0.999641f, // 2044
0.997940f, 0.999541f, 0.998566f, 0.999966f, 0.999998f, 0.999763f, 0.989215f, // 2051
0.997441f, 0.999861f, 0.999812f, 0.999916f, 0.999819f, 0.999877f, 0.997525f, // 2058
0.997226f, 0.999108f, 0.999596f, 0.999030f, 0.681158f, 0.580622f, 0.998785f, // 2065
0.999733f, 0.999733f, 0.999560f, 0.999856f, 0.999529f, 0.999868f, 0.999998f, // 2072
0.999904f, 0.999808f, 0.999977f, 0.999996f, 0.999996f, 0.999989f, 0.999986f, // 2079
0.999961f, 0.999122f, 0.997761f, 0.999379f, 0.999351f, 0.999676f, 0.863771f, // 2086
0.465344f, 0.999244f, 0.999696f, 0.998742f, 0.999013f, 0.999872f, 0.999854f, // 2093
0.999901f, 0.999996f, 0.999919f, 0.999741f, 0.999988f, 0.999990f, 0.999958f, // 2100
0.999987f, 0.999967f, 0.999861f, 0.993905f, 0.962008f, 0.950310f, 0.988468f, // 2107
0.994145f, 0.780255f, 0.365118f, 0.999139f, 0.999606f, 0.999409f, 0.999791f, // 2114
0.999974f, 0.999925f, 0.999875f, 0.999925f, 0.998207f, 0.998831f, 0.999693f, // 2121
0.999928f, 0.999938f, 0.999977f, 0.999950f, 0.999410f, 0.986830f, 0.983311f, // 2128
0.990541f, 0.995200f, 0.976557f, 0.587724f, 0.425631f, 0.999128f, 0.999951f, // 2135
0.999665f, 0.999939f, 0.999971f, 0.999928f, 0.999942f, 0.999947f, 0.999914f, // 2142
0.999559f, 0.999824f, 0.999979f, 0.999983f, 0.999980f, 0.999951f, 0.999951f, // 2149
0.999123f, 0.999232f, 0.999606f, 0.999667f, 0.990535f, 0.579369f, 0.608125f, // 2156
0.999933f, 0.999988f, 0.999989f, 0.999992f, 0.999989f, 0.999943f, 0.999856f, // 2163
0.999785f, 0.999063f, 0.998811f, 0.999852f, 0.999999f, 0.999994f, 0.999995f, // 2170
0.999976f, 0.999938f, 0.999243f, 0.999801f, 0.999818f, 0.999837f, 0.997427f, // 2177
0.639657f, 0.693216f, 0.999861f, 0.999977f, 0.999925f, 0.999970f, 0.999981f, // 2184
0.999034f, 0.997785f, 0.997919f, 0.997132f, 0.994201f, 0.997864f, 0.999142f, // 2191
0.999664f, 0.999865f, 0.999842f, 0.999820f, 0.999471f, 0.999836f, 0.999820f, // 2198
0.999981f, 0.999020f, 0.860136f, 0.637859f, 0.997729f, 0.999777f, 0.999879f, // 2205
0.999933f, 0.999945f, 0.999416f, 0.996995f, 0.986361f, 0.992333f, 0.989375f, // 2212
0.994577f, 0.994233f, 0.996775f, 0.999411f, 0.999163f, 0.998508f, 0.996014f, // 2219
0.998042f, 0.998398f, 0.999650f, 0.998167f, 0.901296f, 0.396867f, 0.921693f, // 2226
0.986825f, 0.971296f, 0.939976f, 0.978027f, 0.855301f, 0.800659f, 0.675073f, // 2233
0.594583f, 0.631939f, 0.649042f, 0.707789f, 0.815095f, 0.950930f, 0.985610f, // 2240
0.988100f, 0.961680f, 0.969541f, 0.964333f, 0.987416f, 0.965892f, 0.555017f, // 2247
0.995320f, 0.997420f, 0.996714f, 0.980694f, 0.930224f, 0.964299f, 0.996459f, // 2254
0.999343f, 0.999531f, 0.999813f, 0.999655f, 0.999614f, 0.999143f, 0.995404f, // 2261
0.997803f, 0.994492f, 0.982230f, 0.994730f, 0.996584f, 0.999079f, 0.998013f, // 2268
0.983936f, 0.958837f, 0.998311f, 0.992634f, 0.996801f, 0.985490f, 0.966606f, // 2275
0.920423f, 0.997256f, 0.999508f, 0.999705f, 0.998133f, 0.998486f, 0.998754f, // 2282
0.997977f, 0.997650f, 0.998197f, 0.985003f, 0.946107f, 0.991604f, 0.999038f, // 2289
0.999890f, 0.999402f, 0.997718f, 0.966347f, 0.999243f, 0.996934f, 0.999875f, // 2296
0.998620f, 0.991077f, 0.941607f, 0.998390f, 0.998539f, 0.999736f, 0.999602f, // 2303
0.999402f, 0.998010f, 0.999728f, 0.999768f, 0.999369f, 0.996464f, 0.958146f, // 2310
0.993080f, 0.999644f, 0.999956f, 0.999786f, 0.995660f, 0.976597f, 0.999261f, // 2317
0.987759f, 0.999595f, 0.985363f, 0.980867f, 0.957977f, 0.998836f, 0.999197f, // 2324
0.999171f, 0.996650f, 0.998535f, 0.997843f, 0.998551f, 0.998808f, 0.999132f, // 2331
0.995360f, 0.962728f, 0.986097f, 0.999488f, 0.999954f, 0.999978f, 0.999521f, // 2338
0.979989f, 0.999326f, 0.994894f, 0.998882f, 0.963884f, 0.943364f, 0.839346f, // 2345
0.992016f, 0.999163f, 0.997890f, 0.995197f, 0.995632f, 0.997706f, 0.996845f, // 2352
0.998821f, 0.998530f, 0.991585f, 0.850172f, 0.861352f, 0.997270f, 0.999667f, // 2359
0.999908f, 0.998699f, 0.967972f, 0.999082f, 0.988694f, 0.997295f, 0.966732f, // 2366
0.952354f, 0.897622f, 0.991166f, 0.998581f, 0.999230f, 0.996675f, 0.995899f, // 2373
0.996952f, 0.989293f, 0.995633f, 0.997313f, 0.978568f, 0.699924f, 0.690766f, // 2380
0.990987f, 0.999342f, 0.999895f, 0.998909f, 0.987861f, 0.998822f, 0.979511f, // 2387
0.994167f, 0.958958f, 0.862164f, 0.869394f, 0.987629f, 0.998234f, 0.990867f, // 2394
0.975746f, 0.957307f, 0.970657f, 0.947247f, 0.964356f, 0.977829f, 0.972257f, // 2401
0.606357f, 0.810743f, 0.946467f, 0.996844f, 0.999618f, 0.998788f, 0.989042f, // 2408
0.997581f, 0.984186f, 0.990194f, 0.941927f, 0.808491f, 0.889203f, 0.983078f, // 2415
0.998727f, 0.997596f, 0.993065f, 0.996396f, 0.990487f, 0.967266f, 0.952851f, // 2422
0.886775f, 0.840517f, 0.312708f, 0.561963f, 0.960788f, 0.991422f, 0.999434f, // 2429
0.998416f, 0.987788f, 0.998633f, 0.994752f, 0.995783f, 0.979334f, 0.860826f, // 2436
0.894491f, 0.979784f, 0.998699f, 0.996680f, 0.993239f, 0.997599f, 0.995377f, // 2443
0.991049f, 0.993156f, 0.989192f, 0.979493f, 0.834377f, 0.910544f, 0.972160f, // 2450
0.995772f, 0.999530f, 0.996463f, 0.984437f, 0.998546f, 0.996284f, 0.999325f, // 2457
0.995241f, 0.978137f, 0.976941f, 0.992351f, 0.998637f, 0.998980f, 0.998154f, // 2464
0.997838f, 0.998551f, 0.999271f, 0.999200f, 0.997537f, 0.981594f, 0.982910f, // 2471
0.974992f, 0.989986f, 0.999602f, 0.999874f, 0.995589f, 0.984457f, 0.999405f, // 2478
0.999422f, 0.999987f, 0.999929f, 0.997599f, 0.990875f, 0.994682f, 0.999465f, // 2485
0.999698f, 0.999920f, 0.999932f, 0.999989f, 0.999996f, 0.999988f, 0.999493f, // 2492
0.994799f, 0.993678f, 0.981531f, 0.989578f, 0.998918f, 0.999964f, 0.999159f, // 2499
0.990164f, 0.999741f, 0.999760f, 0.999996f, 0.999711f, 0.996886f, 0.988947f, // 2506
0.998472f, 0.999824f, 0.999887f, 0.999830f, 0.999918f, 0.999881f, 0.999908f, // 2513
0.999954f, 0.999643f, 0.992624f, 0.988765f, 0.947734f, 0.994570f, 0.999875f, // 2520
0.999954f, 0.998875f, 0.969794f, 0.997662f, 0.997789f, 0.999981f, 0.999864f, // 2527
0.996617f, 0.989894f, 0.984416f, 0.992734f, 0.992695f, 0.993807f, 0.995475f, // 2534
0.998718f, 0.998526f, 0.998288f, 0.998557f, 0.994377f, 0.979668f, 0.967072f, // 2541
0.994164f, 0.999768f, 0.999941f, 0.999681f, 0.985456f, 0.988429f, 0.985800f, // 2548
0.996389f, 0.990383f, 0.965439f, 0.929420f, 0.965837f, 0.980372f, 0.979791f, // 2555
0.976185f, 0.978258f, 0.975756f, 0.984068f, 0.985150f, 0.973726f, 0.963949f, // 2562
0.972321f, 0.982316f, 0.998850f, 0.999639f, 0.997139f, 0.991873f, 0.960782f, // 2569
0.860259f, 0.793689f, 0.814665f, 0.620909f, 0.686968f, 0.700748f, 0.810235f, // 2576
0.882421f, 0.901557f, 0.897309f, 0.920904f, 0.850107f, 0.866574f, 0.852236f, // 2583
0.853363f, 0.844470f, 0.793812f, 0.851349f, 0.870078f, 0.845024f, 0.841836f, // 2590
0.742105f, 0.590677f, 0.596554f, 0.307091f, 0.338657f, 0.340840f, 0.595050f, // 2597
0.363950f, 0.602039f, 0.579551f, 0.834194f, 0.706989f, 0.557275f, 0.625534f, // 2604
0.769359f, 0.846276f, 0.808552f, 0.739828f, 0.519999f, 0.710256f, 0.874513f, // 2611
0.863189f, 0.873880f, 0.821666f, 0.701217f, 0.758820f, 0.732059f, 0.823750f, // 2618
0.868708f, 0.836741f, 0.268665f, 0.542382f, 0.539994f, 0.743183f, 0.839936f, // 2625
0.742037f, 0.712789f, 0.899580f, 0.781539f, 0.736318f, 0.824613f, 0.799552f, // 2632
0.902588f, 0.867854f, 0.916722f, 0.934359f, 0.815969f, 0.824805f, 0.722846f, // 2639
0.691248f, 0.821582f, 0.900751f, 0.893516f, 0.698096f, 0.737380f, 0.515137f, // 2646
0.805213f, 0.847517f, 0.812602f, 0.877190f, 0.952128f, 0.755334f, 0.828252f, // 2653
0.865427f, 0.740972f, 0.802123f, 0.903185f, 0.905838f, 0.972267f, 0.919966f, // 2660
0.832427f, 0.820274f, 0.798164f, 0.768064f, 0.799386f, 0.681307f, 0.293922f, // 2667
0.253659f, 0.245923f, 0.170811f, 0.709970f, 0.729100f, 0.820269f, 0.845529f, // 2674
0.521248f, 0.720505f, 0.593013f, 0.447274f, 0.385268f, 0.684210f, 0.819118f, // 2681
0.942906f, 0.831179f, 0.754654f, 0.808069f, 0.667453f, 0.768767f, 0.718095f, // 2688
0.569414f, 0.285227f, 0.158761f, 0.156699f, 0.172950f, 0.202512f, 0.336660f, // 2695
0.387381f, 0.292251f, 0.251043f, 0.275878f, 0.309788f, 0.380635f, 0.339995f, // 2702
0.737848f, 0.844182f, 0.903539f, 0.815349f, 0.725265f, 0.811065f, 0.487493f, // 2709
0.722378f, 0.524301f, 0.404123f, 0.132734f, 0.050153f, 0.095692f, 0.035386f, // 2716
0.033459f, 0.039964f, 0.064926f, 0.036158f, 0.023269f, 0.024424f, 0.018195f, // 2723
0.088027f, 0.115534f, 0.543538f, 0.756011f, 0.816860f, 0.751750f, 0.673653f, // 2730
0.780329f, 0.597466f, 0.648485f, 0.567675f, 0.387298f, 0.422935f, 0.146613f, // 2737
0.176970f, 0.060803f, 0.034791f, 0.098365f, 0.083148f, 0.068478f, 0.028501f, // 2744
0.007086f, 0.014170f, 0.104720f, 0.256416f, 0.725843f, 0.814762f, 0.941145f, // 2751
0.914093f, 0.689452f, 0.837827f, 0.662989f, 0.746218f, 0.576571f, 0.495961f, // 2758
0.550802f, 0.471109f, 0.463699f, 0.358716f, 0.210557f, 0.357545f, 0.421787f, // 2765
0.286442f, 0.182915f, 0.124884f, 0.195914f, 0.389157f, 0.454768f, 0.596423f, // 2772
0.793609f, 0.944089f, 0.936855f, 0.809449f, 0.850031f, 0.690370f, 0.743842f, // 2779
0.598679f, 0.648354f, 0.714775f, 0.736854f, 0.690222f, 0.567378f, 0.511236f, // 2786
0.614512f, 0.603006f, 0.446932f, 0.334361f, 0.203149f, 0.252754f, 0.417231f, // 2793
0.387606f, 0.467971f, 0.803492f, 0.943461f, 0.914764f, 0.771719f, 0.833416f, // 2800
0.776535f, 0.848807f, 0.756169f, 0.702348f, 0.836633f, 0.747974f, 0.814534f, // 2807
0.741986f, 0.828032f, 0.786272f, 0.811099f, 0.599511f, 0.561004f, 0.267352f, // 2814
0.382673f, 0.331975f, 0.262123f, 0.328907f, 0.676862f, 0.935148f, 0.944753f, // 2821
0.813679f, 0.881163f, 0.842899f, 0.891803f, 0.573629f, 0.756353f, 0.729213f, // 2828
0.531663f, 0.657881f, 0.660261f, 0.801406f, 0.785293f, 0.773909f, 0.739786f, // 2835
0.539762f, 0.484735f, 0.445992f, 0.331300f, 0.168319f, 0.305843f, 0.776060f, // 2842
0.959297f, 0.900030f, 0.613553f, 0.736117f, 0.850956f, 0.895126f, 0.760500f, // 2849
0.709520f, 0.546130f, 0.257588f, 0.290614f, 0.237174f, 0.260291f, 0.278631f, // 2856
0.346136f, 0.313535f, 0.424835f, 0.359886f, 0.476868f, 0.292926f, 0.262160f, // 2863
0.403108f, 0.802857f, 0.919488f, 0.890001f, 0.619180f, 0.709039f, 0.881420f, // 2870
0.626771f, 0.579302f, 0.629346f, 0.469115f, 0.250758f, 0.291180f, 0.360947f, // 2877
0.294612f, 0.363423f, 0.354445f, 0.457371f, 0.350559f, 0.316234f, 0.375029f, // 2884
0.557682f, 0.558848f, 0.696183f, 0.808220f, 0.783618f, 0.720922f, 0.670358f, // 2891
0.000240f, 0.002386f, 0.000146f, 0.003720f, 0.005311f, 0.000457f, 0.000135f, // 2898
0.000031f, 0.000115f, 0.000121f, 0.000242f, 0.000281f, 0.000374f, 0.000614f, // 2905
0.000219f, 0.000193f, 0.000186f, 0.000202f, 0.000026f, 0.000037f, 0.000142f, // 2912
0.001200f, 0.000595f, 0.000278f, 0.006339f, 0.000215f, 0.009305f, 0.021977f, // 2919
0.002782f, 0.001559f, 0.000271f, 0.000239f, 0.000297f, 0.001044f, 0.002096f, // 2926
0.001856f, 0.000898f, 0.000326f, 0.000819f, 0.005941f, 0.001182f, 0.000083f, // 2933
0.000014f, 0.000113f, 0.000207f, 0.000227f, 0.000041f, 0.005001f, 0.000042f, // 2940
0.010939f, 0.026619f, 0.004109f, 0.001375f, 0.003985f, 0.000729f, 0.000469f, // 2947
0.002013f, 0.004283f, 0.031467f, 0.003501f, 0.003333f, 0.047625f, 0.117052f, // 2954
0.034208f, 0.000396f, 0.000091f, 0.000114f, 0.000266f, 0.000457f, 0.000051f, // 2961
0.002833f, 0.000005f, 0.002165f, 0.003689f, 0.010069f, 0.002028f, 0.003129f, // 2968
0.014319f, 0.003614f, 0.004186f, 0.008231f, 0.039269f, 0.008709f, 0.014461f, // 2975
0.105987f, 0.299399f, 0.113314f, 0.000204f, 0.000034f, 0.000008f, 0.000030f, // 2982
0.000123f, 0.000033f, 0.000631f, 0.000029f, 0.001217f, 0.008337f, 0.008849f, // 2989
0.001038f, 0.001469f, 0.000553f, 0.003430f, 0.003308f, 0.036663f, 0.085896f, // 2996
0.004248f, 0.007097f, 0.029601f, 0.035057f, 0.007969f, 0.000023f, 0.000027f, // 3003
0.000011f, 0.000099f, 0.000048f, 0.000029f, 0.000135f, 0.000012f, 0.000393f, // 3010
0.003528f, 0.007725f, 0.001751f, 0.000311f, 0.000208f, 0.001005f, 0.003136f, // 3017
0.084169f, 0.038983f, 0.002660f, 0.000446f, 0.003534f, 0.011557f, 0.005555f, // 3024
0.000020f, 0.000011f, 0.000003f, 0.000068f, 0.000050f, 0.000074f, 0.000096f, // 3031
0.000020f, 0.000512f, 0.001433f, 0.000899f, 0.000105f, 0.000011f, 0.000019f, // 3038
0.000014f, 0.000043f, 0.000103f, 0.000142f, 0.000019f, 0.000034f, 0.000020f, // 3045
0.000198f, 0.000471f, 0.000060f, 0.000002f, 0.000002f, 0.000012f, 0.000080f, // 3052
0.000090f, 0.000097f, 0.000014f, 0.000175f, 0.000236f, 0.000679f, 0.000181f, // 3059
0.000053f, 0.000022f, 0.000033f, 0.000143f, 0.000552f, 0.000469f, 0.000162f, // 3066
0.000045f, 0.000589f, 0.006430f, 0.005107f, 0.000197f, 0.000123f, 0.000028f, // 3073
0.000074f, 0.000046f, 0.000075f, 0.000212f, 0.000030f, 0.000295f, 0.001943f, // 3080
0.000774f, 0.000529f, 0.000172f, 0.000410f, 0.001467f, 0.000750f, 0.001329f, // 3087
0.000505f, 0.002417f, 0.017261f, 0.096988f, 0.044585f, 0.023083f, 0.002668f, // 3094
0.000268f, 0.000227f, 0.000340f, 0.000085f, 0.000057f, 0.000635f, 0.000030f, // 3101
0.000348f, 0.000763f, 0.001761f, 0.001292f, 0.000729f, 0.000517f, 0.002212f, // 3108
0.003333f, 0.003370f, 0.001968f, 0.001513f, 0.026809f, 0.141163f, 0.093767f, // 3115
0.034414f, 0.001313f, 0.000072f, 0.000055f, 0.001581f, 0.000176f, 0.000033f, // 3122
0.000126f, 0.000029f, 0.000210f, 0.003604f, 0.002580f, 0.001285f, 0.004428f, // 3129
0.001397f, 0.003731f, 0.000783f, 0.000964f, 0.000103f, 0.000185f, 0.005154f, // 3136
0.139429f, 0.048561f, 0.067615f, 0.002485f, 0.000225f, 0.000023f, 0.000098f, // 3143
0.000406f, 0.000025f, 0.000067f, 0.000025f, 0.000396f, 0.002246f, 0.002167f, // 3150
0.002815f, 0.001118f, 0.000215f, 0.001055f, 0.000858f, 0.000382f, 0.000123f, // 3157
0.000058f, 0.005669f, 0.014892f, 0.007090f, 0.009354f, 0.001101f, 0.000217f, // 3164
0.000003f, 0.000170f, 0.000190f, 0.000316f, 0.000164f, 0.000322f, 0.000786f, // 3171
0.002823f, 0.001708f, 0.006212f, 0.003676f, 0.004286f, 0.004811f, 0.002844f, // 3178
0.002126f, 0.000940f, 0.003058f, 0.005898f, 0.014173f, 0.008805f, 0.007202f, // 3185
0.000505f, 0.000020f, 0.000004f, 0.000111f, 0.000295f, 0.000298f, 0.000135f, // 3192
0.000123f, 0.000532f, 0.001699f, 0.000891f, 0.001536f, 0.001820f, 0.003701f, // 3199
0.003529f, 0.006166f, 0.005751f, 0.001696f, 0.001145f, 0.001343f, 0.001053f, // 3206
0.000638f, 0.000234f, 0.000176f, 0.000195f, 0.000046f, 0.000351f, 0.000819f, // 3213
0.003802f, 0.030003f, 0.009656f, 0.025932f, 0.010369f, 0.017346f, 0.017825f, // 3220
0.004315f, 0.010179f, 0.009600f, 0.005502f, 0.016388f, 0.016965f, 0.020215f, // 3227
0.010502f, 0.012017f, 0.004540f, 0.004291f, 0.007300f, 0.010040f, 0.016552f, // 3234
0.027049f, 0.016962f, 0.004151f, 0.046499f, 0.005186f, 0.046809f, 0.012154f, // 3241
0.012864f, 0.039319f, 0.043380f, 0.014131f, 0.022475f, 0.029298f, 0.054098f, // 3248
0.014268f, 0.012808f, 0.006734f, 0.016054f, 0.017108f, 0.004730f, 0.001155f, // 3255
0.001221f, 0.005471f, 0.015954f, 0.017357f, 0.000915f, 0.028631f, 0.000784f, // 3262
0.058195f, 0.006275f, 0.039713f, 0.037864f, 0.114333f, 0.020966f, 0.023034f, // 3269
0.047043f, 0.045346f, 0.015363f, 0.037148f, 0.025331f, 0.038481f, 0.004360f, // 3276
0.002514f, 0.010063f, 0.010903f, 0.006051f, 0.014054f, 0.038926f, 0.000872f, // 3283
0.005178f, 0.000406f, 0.027579f, 0.003516f, 0.021501f, 0.094335f, 0.456798f, // 3290
0.419443f, 0.415447f, 0.520338f, 0.415335f, 0.330501f, 0.630755f, 0.271359f, // 3297
0.074136f, 0.030879f, 0.039895f, 0.007581f, 0.003538f, 0.000584f, 0.001926f, // 3304
0.009898f, 0.001361f, 0.006847f, 0.005679f, 0.038854f, 0.044626f, 0.158427f, // 3311
0.355240f, 0.387967f, 0.407008f, 0.546599f, 0.685714f, 0.631642f, 0.587134f, // 3318
0.652269f, 0.416806f, 0.423441f, 0.065923f, 0.052545f, 0.010354f, 0.009114f, // 3325
0.002898f, 0.012407f, 0.013670f, 0.002451f, 0.006165f, 0.001709f, 0.031853f, // 3332
0.084681f, 0.240422f, 0.696376f, 0.274639f, 0.444606f, 0.602556f, 0.793232f, // 3339
0.854712f, 0.625100f, 0.696123f, 0.688921f, 0.452124f, 0.151862f, 0.110280f, // 3346
0.008317f, 0.009863f, 0.002948f, 0.011029f, 0.004129f, 0.003762f, 0.003270f, // 3353
0.001219f, 0.039219f, 0.065398f, 0.141858f, 0.346602f, 0.129350f, 0.043489f, // 3360
0.079120f, 0.090603f, 0.068713f, 0.040419f, 0.119867f, 0.300294f, 0.351623f, // 3367
0.057834f, 0.085673f, 0.013764f, 0.006043f, 0.005837f, 0.008543f, 0.008676f, // 3374
0.003181f, 0.001567f, 0.001522f, 0.024380f, 0.046648f, 0.037296f, 0.425954f, // 3381
0.294172f, 0.106927f, 0.070677f, 0.112266f, 0.141534f, 0.116952f, 0.200616f, // 3388
0.511758f, 0.528343f, 0.252231f, 0.122138f, 0.011459f, 0.006914f, 0.003693f, // 3395
0.004968f, 0.005815f, 0.002088f, 0.003086f, 0.002928f, 0.038490f, 0.087960f, // 3402
0.028884f, 0.179759f, 0.155282f, 0.161226f, 0.410784f, 0.560645f, 0.620424f, // 3409
0.457260f, 0.676069f, 0.846856f, 0.716995f, 0.090774f, 0.107931f, 0.015931f, // 3416
0.021443f, 0.021930f, 0.008459f, 0.011478f, 0.001245f, 0.004826f, 0.000336f, // 3423
0.010077f, 0.018369f, 0.009954f, 0.108843f, 0.080449f, 0.070355f, 0.109671f, // 3430
0.156802f, 0.195762f, 0.251164f, 0.343846f, 0.629661f, 0.422966f, 0.051560f, // 3437
0.041053f, 0.002897f, 0.011455f, 0.008993f, 0.024851f, 0.012191f, 0.000563f, // 3444
0.000553f, 0.000143f, 0.001745f, 0.009941f, 0.008189f, 0.100022f, 0.181817f, // 3451
0.167213f, 0.289120f, 0.381803f, 0.428475f, 0.316050f, 0.385418f, 0.313583f, // 3458
0.234912f, 0.094166f, 0.085803f, 0.034307f, 0.017917f, 0.004309f, 0.002339f, // 3465
0.012202f, 0.000407f, 0.002571f, 0.000015f, 0.001723f, 0.002538f, 0.008970f, // 3472
0.102177f, 0.062664f, 0.067547f, 0.241088f, 0.193341f, 0.259039f, 0.104890f, // 3479
0.100556f, 0.175212f, 0.123964f, 0.051584f, 0.077224f, 0.031143f, 0.029005f, // 3486
0.007042f, 0.016017f, 0.030386f, 0.002413f, 0.006256f, 0.000316f, 0.003235f, // 3493
0.014454f, 0.020873f, 0.155559f, 0.118361f, 0.150771f, 0.177854f, 0.199348f, // 3500
0.209555f, 0.118738f, 0.271140f, 0.280435f, 0.224631f, 0.139563f, 0.115828f, // 3507
0.028890f, 0.005388f, 0.003860f, 0.010035f, 0.013583f, 0.017618f, 0.100334f, // 3514
0.021609f, 0.034727f, 0.024528f, 0.036623f, 0.166432f, 0.125092f, 0.126540f, // 3521
0.190605f, 0.276318f, 0.294292f, 0.104362f, 0.169296f, 0.168742f, 0.205039f, // 3528
0.180829f, 0.083698f, 0.070601f, 0.050210f, 0.106058f, 0.083566f, 0.106611f, // 3535
0.111432f, 0.276552f, 0.175462f, 0.251401f, 0.087615f, 0.089762f, 0.150119f, // 3542
0.193150f, 0.293187f, 0.322782f, 0.107865f, 0.214072f, 0.204781f, 0.165789f, // 3549
0.163394f, 0.133497f, 0.079319f, 0.061095f, 0.096013f, 0.130007f, 0.209696f, // 3556
0.308222f, 0.211365f, 0.268585f, 0.707304f, 0.493089f, 0.632130f, 0.269595f, // 3563
0.178856f, 0.394475f, 0.656918f, 0.428469f, 0.418516f, 0.656962f, 0.641207f, // 3570
0.281341f, 0.214145f, 0.171580f, 0.319970f, 0.247190f, 0.194138f, 0.143732f, // 3577
0.386904f, 0.462406f, 0.380135f, 0.297427f, 0.088163f, 0.478021f, 0.282230f, // 3584
0.293695f, 0.139795f, 0.126228f, 0.132638f, 0.468306f, 0.521312f, 0.485653f, // 3591
0.436831f, 0.323707f, 0.149274f, 0.580774f, 0.154514f, 0.191779f, 0.066229f, // 3598
0.039808f, 0.198203f, 0.132497f, 0.135949f, 0.161735f, 0.224597f, 0.097290f, // 3605
0.239893f, 0.220871f, 0.220051f, 0.080776f, 0.170386f, 0.142905f, 0.682397f, // 3612
0.387885f, 0.273563f, 0.437117f, 0.264563f, 0.152382f, 0.554167f, 0.293382f, // 3619
0.302211f, 0.332382f, 0.320172f, 0.274137f, 0.157307f, 0.155205f, 0.124500f, // 3626
0.149338f, 0.075805f, 0.164924f, 0.463323f, 0.353889f, 0.586342f, 0.595842f, // 3633
0.912835f, 0.938074f, 0.899546f, 0.666058f, 0.733353f, 0.476342f, 0.341543f, // 3640
0.763491f, 0.760147f, 0.891497f, 0.743854f, 0.649339f, 0.599021f, 0.478147f, // 3647
0.532162f, 0.505523f, 0.152767f, 0.087551f, 0.139245f, 0.268033f, 0.318103f, // 3654
0.593045f, 0.698479f, 0.955161f, 0.978893f, 0.970097f, 0.943646f, 0.929040f, // 3661
0.938659f, 0.901669f, 0.960129f, 0.976820f, 0.953141f, 0.763965f, 0.738351f, // 3668
0.483787f, 0.527419f, 0.526949f, 0.384823f, 0.138082f, 0.130483f, 0.230035f, // 3675
0.330174f, 0.507435f, 0.606529f, 0.740607f, 0.959880f, 0.978642f, 0.989078f, // 3682
0.987949f, 0.979221f, 0.951079f, 0.972835f, 0.987874f, 0.986174f, 0.985954f, // 3689
0.860616f, 0.901574f, 0.622415f, 0.652071f, 0.683322f, 0.498170f, 0.302007f, // 3696
0.142518f, 0.195080f, 0.323325f, 0.507349f, 0.631871f, 0.373906f, 0.905145f, // 3703
0.970997f, 0.987460f, 0.986277f, 0.974369f, 0.977209f, 0.974363f, 0.990280f, // 3710
0.992089f, 0.991805f, 0.877365f, 0.758724f, 0.395445f, 0.357026f, 0.480254f, // 3717
0.435156f, 0.218003f, 0.139149f, 0.242674f, 0.364992f, 0.550031f, 0.619234f, // 3724
0.310064f, 0.752392f, 0.902984f, 0.901437f, 0.924852f, 0.964540f, 0.945994f, // 3731
0.978723f, 0.981055f, 0.983363f, 0.973760f, 0.909685f, 0.783338f, 0.651423f, // 3738
0.721562f, 0.777723f, 0.357609f, 0.256280f, 0.095860f, 0.214814f, 0.179501f, // 3745
0.434996f, 0.558657f, 0.320888f, 0.699064f, 0.821994f, 0.923496f, 0.757882f, // 3752
0.922776f, 0.941794f, 0.988974f, 0.988017f, 0.989464f, 0.951604f, 0.905760f, // 3759
0.810404f, 0.687728f, 0.924684f, 0.902185f, 0.586531f, 0.447273f, 0.050979f, // 3766
0.231507f, 0.349196f, 0.525226f, 0.651847f, 0.244708f, 0.626107f, 0.602276f, // 3773
0.851335f, 0.832160f, 0.932066f, 0.935004f, 0.973536f, 0.978875f, 0.989247f, // 3780
0.973325f, 0.940858f, 0.889986f, 0.858036f, 0.776068f, 0.710697f, 0.514328f, // 3787
0.331531f, 0.041533f, 0.609604f, 0.170848f, 0.761087f, 0.517335f, 0.594783f, // 3794
0.779831f, 0.693513f, 0.841144f, 0.811140f, 0.762550f, 0.715668f, 0.747240f, // 3801
0.914575f, 0.930626f, 0.920877f, 0.930534f, 0.870644f, 0.784421f, 0.758535f, // 3808
0.797867f, 0.518791f, 0.405135f, 0.046803f, 0.530488f, 0.201796f, 0.566553f, // 3815
0.457785f, 0.522353f, 0.860603f, 0.875938f, 0.880410f, 0.880275f, 0.865568f, // 3822
0.857931f, 0.879942f, 0.919468f, 0.933240f, 0.794325f, 0.848303f, 0.844294f, // 3829
0.680437f, 0.710811f, 0.841456f, 0.678424f, 0.287730f, 0.082495f, 0.400126f, // 3836
0.453341f, 0.523197f, 0.365895f, 0.467706f, 0.727012f, 0.724186f, 0.665042f, // 3843
0.667368f, 0.680608f, 0.700367f, 0.652867f, 0.824382f, 0.823256f, 0.825154f, // 3850
0.741670f, 0.676127f, 0.739063f, 0.774986f, 0.735215f, 0.595029f, 0.500971f, // 3857
0.000503f, 0.000267f, 0.000147f, 0.001465f, 0.042003f, 0.000820f, 0.000076f, // 3864
0.000032f, 0.000025f, 0.000032f, 0.000191f, 0.000107f, 0.000163f, 0.000225f, // 3871
0.000152f, 0.000375f, 0.000799f, 0.001109f, 0.000383f, 0.000116f, 0.000227f, // 3878
0.001366f, 0.003327f, 0.000051f, 0.000089f, 0.000006f, 0.000454f, 0.010678f, // 3885
0.000567f, 0.000153f, 0.000017f, 0.000011f, 0.000025f, 0.000113f, 0.000207f, // 3892
0.000230f, 0.000149f, 0.000130f, 0.001563f, 0.004923f, 0.001848f, 0.000423f, // 3899
0.000008f, 0.000084f, 0.000046f, 0.000578f, 0.000029f, 0.000176f, 0.000013f, // 3906
0.002608f, 0.021597f, 0.000394f, 0.000120f, 0.000083f, 0.000007f, 0.000013f, // 3913
0.000144f, 0.000358f, 0.000530f, 0.000168f, 0.000576f, 0.011113f, 0.032642f, // 3920
0.012707f, 0.000223f, 0.000018f, 0.000037f, 0.000112f, 0.001177f, 0.000023f, // 3927
0.000747f, 0.000012f, 0.015567f, 0.037962f, 0.003355f, 0.000106f, 0.000037f, // 3934
0.000252f, 0.000382f, 0.001602f, 0.000351f, 0.001125f, 0.000376f, 0.000884f, // 3941
0.025798f, 0.315622f, 0.113489f, 0.001403f, 0.000063f, 0.000010f, 0.000024f, // 3948
0.000462f, 0.000010f, 0.000531f, 0.000089f, 0.009909f, 0.031140f, 0.001459f, // 3955
0.000045f, 0.000050f, 0.000015f, 0.001074f, 0.006301f, 0.005925f, 0.005041f, // 3962
0.000145f, 0.004160f, 0.023576f, 0.066570f, 0.031330f, 0.001660f, 0.000036f, // 3969
0.000022f, 0.000034f, 0.000288f, 0.000007f, 0.000235f, 0.000178f, 0.003809f, // 3976
0.012926f, 0.001477f, 0.000119f, 0.000140f, 0.000017f, 0.000555f, 0.004169f, // 3983
0.011708f, 0.002826f, 0.000128f, 0.000188f, 0.003026f, 0.053387f, 0.042204f, // 3990
0.002672f, 0.000175f, 0.000047f, 0.000036f, 0.000312f, 0.000008f, 0.000197f, // 3997
0.000521f, 0.001191f, 0.004409f, 0.000256f, 0.000008f, 0.000011f, 0.000006f, // 4004
0.000029f, 0.000059f, 0.000034f, 0.000046f, 0.000004f, 0.000010f, 0.000008f, // 4011
0.000582f, 0.004244f, 0.002876f, 0.000033f, 0.000043f, 0.000017f, 0.000156f, // 4018
0.000011f, 0.000166f, 0.000353f, 0.000369f, 0.000598f, 0.000218f, 0.000013f, // 4025
0.000019f, 0.000015f, 0.000030f, 0.000058f, 0.000050f, 0.000177f, 0.000062f, // 4032
0.000009f, 0.000217f, 0.011917f, 0.058044f, 0.017095f, 0.003490f, 0.000887f, // 4039
0.000262f, 0.000058f, 0.000015f, 0.000138f, 0.000670f, 0.000433f, 0.001137f, // 4046
0.000109f, 0.000027f, 0.000038f, 0.000074f, 0.000173f, 0.000066f, 0.000174f, // 4053
0.000174f, 0.000339f, 0.000833f, 0.011949f, 0.123345f, 0.097360f, 0.032642f, // 4060
0.003227f, 0.002029f, 0.001783f, 0.000214f, 0.000009f, 0.000192f, 0.000231f, // 4067
0.000349f, 0.000358f, 0.000068f, 0.000034f, 0.000058f, 0.000210f, 0.000108f, // 4074
0.000194f, 0.000131f, 0.000062f, 0.000064f, 0.001109f, 0.008931f, 0.024059f, // 4081
0.020665f, 0.006524f, 0.000559f, 0.000224f, 0.003305f, 0.000822f, 0.000004f, // 4088
0.000022f, 0.000069f, 0.000046f, 0.000637f, 0.000058f, 0.000039f, 0.000194f, // 4095
0.000129f, 0.000039f, 0.000028f, 0.000015f, 0.000001f, 0.000001f, 0.000017f, // 4102
0.001405f, 0.003522f, 0.017956f, 0.003651f, 0.000713f, 0.000046f, 0.000603f, // 4109
0.001637f, 0.000002f, 0.000005f, 0.000031f, 0.000090f, 0.000360f, 0.000041f, // 4116
0.000063f, 0.000128f, 0.000026f, 0.000011f, 0.000032f, 0.000019f, 0.000013f, // 4123
0.000010f, 0.000077f, 0.000934f, 0.003473f, 0.006388f, 0.000801f, 0.000056f, // 4130
0.000003f, 0.000241f, 0.000346f, 0.000001f, 0.000011f, 0.000012f, 0.000060f, // 4137
0.000314f, 0.000084f, 0.000094f, 0.000218f, 0.000404f, 0.000175f, 0.000187f, // 4144
0.000111f, 0.000083f, 0.000128f, 0.000087f, 0.002402f, 0.008117f, 0.007548f, // 4151
0.000244f, 0.000012f, 0.000002f, 0.000023f, 0.000537f, 0.000029f, 0.000028f, // 4158
0.000008f, 0.000085f, 0.000506f, 0.000118f, 0.000124f, 0.000454f, 0.000841f, // 4165
0.000407f, 0.000629f, 0.000742f, 0.000256f, 0.000099f, 0.000119f, 0.000257f, // 4172
0.000608f, 0.000289f, 0.000028f, 0.000011f, 0.000047f, 0.000120f, 0.001063f, // 4179
0.007887f, 0.022971f, 0.014718f, 0.090447f, 0.073871f, 0.103986f, 0.050511f, // 4186
0.007254f, 0.006505f, 0.004543f, 0.005336f, 0.012027f, 0.016272f, 0.036951f, // 4193
0.023116f, 0.028605f, 0.031003f, 0.018094f, 0.022134f, 0.014904f, 0.022418f, // 4200
0.038146f, 0.028799f, 0.003654f, 0.022387f, 0.007702f, 0.057434f, 0.066089f, // 4207
0.176006f, 0.043522f, 0.050984f, 0.010257f, 0.016983f, 0.016218f, 0.022560f, // 4214
0.019261f, 0.016372f, 0.020463f, 0.063669f, 0.141990f, 0.028565f, 0.002652f, // 4221
0.000712f, 0.001875f, 0.004969f, 0.011684f, 0.000905f, 0.022515f, 0.000984f, // 4228
0.037767f, 0.036244f, 0.368320f, 0.066046f, 0.271239f, 0.085496f, 0.040674f, // 4235
0.082670f, 0.133746f, 0.037332f, 0.072653f, 0.095836f, 0.131678f, 0.115885f, // 4242
0.027661f, 0.006897f, 0.005242f, 0.006195f, 0.034253f, 0.050483f, 0.000842f, // 4249
0.013944f, 0.001831f, 0.051444f, 0.028864f, 0.128432f, 0.093675f, 0.304140f, // 4256
0.451211f, 0.557648f, 0.498228f, 0.609528f, 0.564164f, 0.597219f, 0.203449f, // 4263
0.102358f, 0.112423f, 0.071894f, 0.003795f, 0.003179f, 0.000495f, 0.005424f, // 4270
0.018203f, 0.000956f, 0.014915f, 0.010566f, 0.127595f, 0.188680f, 0.588910f, // 4277
0.369633f, 0.149268f, 0.452525f, 0.586958f, 0.571018f, 0.595022f, 0.650239f, // 4284
0.522720f, 0.206028f, 0.280077f, 0.299771f, 0.264798f, 0.012068f, 0.011004f, // 4291
0.002005f, 0.013893f, 0.025954f, 0.001702f, 0.030969f, 0.007671f, 0.119530f, // 4298
0.339223f, 0.702670f, 0.645206f, 0.148745f, 0.471852f, 0.558637f, 0.600921f, // 4305
0.717066f, 0.663325f, 0.664534f, 0.475675f, 0.413203f, 0.520685f, 0.533801f, // 4312
0.019607f, 0.012113f, 0.001167f, 0.006011f, 0.007140f, 0.001755f, 0.009667f, // 4319
0.006274f, 0.102491f, 0.419070f, 0.693608f, 0.523253f, 0.081526f, 0.100235f, // 4326
0.156315f, 0.137393f, 0.103353f, 0.125931f, 0.286543f, 0.530419f, 0.739979f, // 4333
0.744249f, 0.450199f, 0.069204f, 0.015052f, 0.004443f, 0.005867f, 0.008861f, // 4340
0.002863f, 0.004195f, 0.006340f, 0.087235f, 0.415841f, 0.435557f, 0.545753f, // 4347
0.123207f, 0.082738f, 0.104713f, 0.039607f, 0.062716f, 0.141362f, 0.272190f, // 4354
0.892677f, 0.905746f, 0.946260f, 0.595452f, 0.047159f, 0.020208f, 0.004390f, // 4361
0.004542f, 0.008038f, 0.001660f, 0.003032f, 0.004567f, 0.052436f, 0.442101f, // 4368
0.489510f, 0.277479f, 0.046549f, 0.070136f, 0.232559f, 0.155257f, 0.179860f, // 4375
0.278852f, 0.430600f, 0.791963f, 0.657273f, 0.367393f, 0.294530f, 0.038758f, // 4382
0.015784f, 0.005609f, 0.005817f, 0.010706f, 0.001095f, 0.002421f, 0.000512f, // 4389
0.006659f, 0.034663f, 0.035426f, 0.047454f, 0.012890f, 0.012707f, 0.031044f, // 4396
0.033128f, 0.033646f, 0.054165f, 0.068380f, 0.374942f, 0.327632f, 0.101936f, // 4403
0.061357f, 0.007157f, 0.002123f, 0.000868f, 0.009394f, 0.011491f, 0.000502f, // 4410
0.000383f, 0.000028f, 0.000338f, 0.003182f, 0.007091f, 0.022495f, 0.013766f, // 4417
0.018956f, 0.037741f, 0.040774f, 0.025060f, 0.010113f, 0.022896f, 0.093519f, // 4424
0.092175f, 0.046149f, 0.065320f, 0.028310f, 0.008052f, 0.000872f, 0.001379f, // 4431
0.013341f, 0.000360f, 0.000653f, 0.000004f, 0.000723f, 0.001568f, 0.007504f, // 4438
0.019067f, 0.005545f, 0.008852f, 0.063707f, 0.037865f, 0.084705f, 0.045856f, // 4445
0.020774f, 0.058727f, 0.083151f, 0.035745f, 0.087531f, 0.031287f, 0.008129f, // 4452
0.003155f, 0.008802f, 0.057570f, 0.004912f, 0.004185f, 0.000100f, 0.001329f, // 4459
0.009422f, 0.039734f, 0.187303f, 0.103507f, 0.118994f, 0.136270f, 0.164569f, // 4466
0.107682f, 0.076163f, 0.135270f, 0.106518f, 0.149529f, 0.133671f, 0.116143f, // 4473
0.026487f, 0.002594f, 0.001402f, 0.002748f, 0.015697f, 0.030296f, 0.093573f, // 4480
0.014608f, 0.033027f, 0.036182f, 0.100015f, 0.235615f, 0.161563f, 0.135434f, // 4487
0.214511f, 0.210032f, 0.263542f, 0.100076f, 0.144172f, 0.192316f, 0.173226f, // 4494
0.162879f, 0.113568f, 0.021532f, 0.008167f, 0.033152f, 0.035154f, 0.089288f, // 4501
0.144701f, 0.287953f, 0.272348f, 0.488469f, 0.416763f, 0.367993f, 0.269601f, // 4508
0.185557f, 0.175345f, 0.166860f, 0.086893f, 0.192754f, 0.215277f, 0.262195f, // 4515
0.241702f, 0.309179f, 0.303045f, 0.156639f, 0.129511f, 0.171423f, 0.228501f, // 4522
0.287945f, 0.380223f, 0.314200f, 0.556494f, 0.424304f, 0.577359f, 0.347811f, // 4529
0.397141f, 0.371932f, 0.472731f, 0.211012f, 0.348445f, 0.535153f, 0.394879f, // 4536
0.247218f, 0.208653f, 0.193144f, 0.362604f, 0.477734f, 0.296904f, 0.114521f, // 4543
0.179804f, 0.174394f, 0.185224f, 0.404983f, 0.164833f, 0.216919f, 0.145195f, // 4550
0.141390f, 0.078161f, 0.232928f, 0.189347f, 0.454122f, 0.353608f, 0.407040f, // 4557
0.372140f, 0.256364f, 0.087677f, 0.427789f, 0.157595f, 0.111114f, 0.082622f, // 4564
0.064524f, 0.128655f, 0.059102f, 0.064703f, 0.143316f, 0.257346f, 0.142505f, // 4571
0.210771f, 0.248566f, 0.170384f, 0.076310f, 0.189426f, 0.224471f, 0.645012f, // 4578
0.256976f, 0.272433f, 0.408352f, 0.195920f, 0.059144f, 0.370875f, 0.163154f, // 4585
0.170026f, 0.298857f, 0.252769f, 0.125836f, 0.048466f, 0.028971f, 0.070042f, // 4592
0.297632f, 0.111711f, 0.153595f, 0.376306f, 0.252543f, 0.521867f, 0.825715f, // 4599
0.914401f, 0.869736f, 0.805868f, 0.411813f, 0.464707f, 0.236667f, 0.215349f, // 4606
0.616038f, 0.591902f, 0.773865f, 0.699953f, 0.675476f, 0.400430f, 0.156215f, // 4613
0.086004f, 0.264951f, 0.374243f, 0.133781f, 0.194223f, 0.292450f, 0.269638f, // 4620
0.566606f, 0.788680f, 0.951385f, 0.922356f, 0.936682f, 0.911601f, 0.842408f, // 4627
0.816868f, 0.834034f, 0.935649f, 0.962536f, 0.875593f, 0.757317f, 0.757301f, // 4634
0.326776f, 0.217619f, 0.179679f, 0.225325f, 0.272346f, 0.147814f, 0.393437f, // 4641
0.282329f, 0.462322f, 0.676004f, 0.924401f, 0.984477f, 0.968452f, 0.986439f, // 4648
0.980397f, 0.967718f, 0.932267f, 0.966849f, 0.988261f, 0.990995f, 0.994095f, // 4655
0.955274f, 0.935628f, 0.586975f, 0.527268f, 0.548857f, 0.452637f, 0.355124f, // 4662
0.187433f, 0.307855f, 0.285852f, 0.452468f, 0.708553f, 0.607686f, 0.953313f, // 4669
0.961072f, 0.970191f, 0.976965f, 0.946608f, 0.945409f, 0.939471f, 0.980566f, // 4676
0.997279f, 0.996415f, 0.948850f, 0.879939f, 0.432661f, 0.311611f, 0.239284f, // 4683
0.195840f, 0.373746f, 0.138406f, 0.234863f, 0.227785f, 0.372128f, 0.618613f, // 4690
0.609755f, 0.803534f, 0.886572f, 0.870478f, 0.906804f, 0.915285f, 0.843748f, // 4697
0.898444f, 0.943493f, 0.972753f, 0.942636f, 0.848753f, 0.772740f, 0.576577f, // 4704
0.470700f, 0.345398f, 0.145480f, 0.346224f, 0.111134f, 0.181579f, 0.122376f, // 4711
0.187115f, 0.345932f, 0.340136f, 0.613444f, 0.741036f, 0.871396f, 0.741017f, // 4718
0.786870f, 0.776926f, 0.927576f, 0.940551f, 0.967412f, 0.895302f, 0.810648f, // 4725
0.703335f, 0.598324f, 0.652135f, 0.427037f, 0.269526f, 0.524327f, 0.085130f, // 4732
0.163861f, 0.125818f, 0.103714f, 0.223049f, 0.123111f, 0.392024f, 0.411447f, // 4739
0.722867f, 0.641656f, 0.794719f, 0.808176f, 0.895519f, 0.911404f, 0.955548f, // 4746
0.903935f, 0.831346f, 0.790425f, 0.768143f, 0.519896f, 0.190478f, 0.166991f, // 4753
0.346672f, 0.072141f, 0.303698f, 0.053833f, 0.254425f, 0.144180f, 0.288224f, // 4760
0.717536f, 0.513557f, 0.645320f, 0.601459f, 0.548812f, 0.523492f, 0.589452f, // 4767
0.808008f, 0.806887f, 0.806266f, 0.773674f, 0.777716f, 0.625146f, 0.359899f, // 4774
0.151891f, 0.200585f, 0.608243f, 0.184277f, 0.286983f, 0.084497f, 0.237288f, // 4781
0.267070f, 0.537280f, 0.890072f, 0.834338f, 0.837025f, 0.811232f, 0.818905f, // 4788
0.759815f, 0.778166f, 0.800266f, 0.839145f, 0.685243f, 0.830615f, 0.773341f, // 4795
0.532385f, 0.340906f, 0.335664f, 0.289303f, 0.465185f, 0.233998f, 0.439007f, // 4802
0.504838f, 0.500593f, 0.375754f, 0.593965f, 0.843660f, 0.776093f, 0.700488f, // 4809
0.748566f, 0.721646f, 0.755783f, 0.700351f, 0.811904f, 0.837539f, 0.784872f, // 4816
0.706277f, 0.722667f, 0.705293f, 0.601526f, 0.604688f, 0.543258f, 0.535952f, // 4823
0.399074f, 0.050235f, 0.065199f, 0.092259f, 0.044282f, 0.026315f, 0.026680f, // 4830
0.051526f, 0.032587f, 0.044911f, 0.078422f, 0.049531f, 0.032298f, 0.087675f, // 4837
0.081800f, 0.065962f, 0.051473f, 0.026062f, 0.080882f, 0.082893f, 0.111712f, // 4844
0.072526f, 0.277848f, 0.755198f, 0.000777f, 0.000392f, 0.001754f, 0.001700f, // 4851
0.007530f, 0.011751f, 0.002657f, 0.000749f, 0.002459f, 0.003230f, 0.006034f, // 4858
0.005758f, 0.023840f, 0.021550f, 0.008398f, 0.001940f, 0.000399f, 0.001866f, // 4865
0.000422f, 0.000772f, 0.002735f, 0.198010f, 0.628916f, 0.000321f, 0.000066f, // 4872
0.001543f, 0.001431f, 0.003325f, 0.004117f, 0.003624f, 0.000229f, 0.002856f, // 4879
0.021481f, 0.059493f, 0.022782f, 0.005716f, 0.006712f, 0.002488f, 0.000714f, // 4886
0.000319f, 0.002478f, 0.000440f, 0.012718f, 0.029761f, 0.601582f, 0.624332f, // 4893
0.000239f, 0.000051f, 0.001364f, 0.002336f, 0.003675f, 0.005484f, 0.000482f, // 4900
0.000302f, 0.000967f, 0.005348f, 0.004237f, 0.001887f, 0.001193f, 0.003426f, // 4907
0.003818f, 0.001953f, 0.000242f, 0.003037f, 0.000105f, 0.000953f, 0.003970f, // 4914
0.364917f, 0.589657f, 0.000267f, 0.000207f, 0.001339f, 0.003605f, 0.000616f, // 4921
0.001364f, 0.000136f, 0.000005f, 0.000018f, 0.001658f, 0.000656f, 0.000180f, // 4928
0.000169f, 0.000913f, 0.001756f, 0.000149f, 0.000404f, 0.003348f, 0.000520f, // 4935
0.001073f, 0.001330f, 0.236562f, 0.686558f, 0.000362f, 0.000202f, 0.000359f, // 4942
0.002060f, 0.000459f, 0.001434f, 0.000034f, 0.000002f, 0.000237f, 0.010785f, // 4949
0.002559f, 0.000139f, 0.000188f, 0.000084f, 0.000181f, 0.000123f, 0.002475f, // 4956
0.002774f, 0.000892f, 0.000404f, 0.000970f, 0.318842f, 0.419378f, 0.001215f, // 4963
0.000267f, 0.000267f, 0.000440f, 0.000144f, 0.000471f, 0.000132f, 0.000002f, // 4970
0.000096f, 0.000191f, 0.000023f, 0.000004f, 0.000004f, 0.000011f, 0.000014f, // 4977
0.000039f, 0.000878f, 0.002239f, 0.000621f, 0.000649f, 0.000324f, 0.136229f, // 4984
0.534656f, 0.000756f, 0.000304f, 0.001258f, 0.000987f, 0.000128f, 0.000146f, // 4991
0.000099f, 0.000004f, 0.000081f, 0.000259f, 0.000012f, 0.000010f, 0.000042f, // 4998
0.000013f, 0.000033f, 0.000139f, 0.006095f, 0.037991f, 0.049690f, 0.011532f, // 5005
0.005855f, 0.219745f, 0.634882f, 0.000861f, 0.000394f, 0.000591f, 0.000209f, // 5012
0.000026f, 0.000075f, 0.000125f, 0.000075f, 0.001793f, 0.001169f, 0.000307f, // 5019
0.000071f, 0.000062f, 0.000023f, 0.000050f, 0.000590f, 0.013170f, 0.016689f, // 5026
0.009459f, 0.004800f, 0.023443f, 0.412276f, 0.574369f, 0.000872f, 0.000049f, // 5033
0.000335f, 0.000061f, 0.000029f, 0.000072f, 0.000058f, 0.000053f, 0.000086f, // 5040
0.000441f, 0.000177f, 0.000021f, 0.000017f, 0.000020f, 0.000049f, 0.000049f, // 5047
0.000877f, 0.000768f, 0.000394f, 0.000333f, 0.009465f, 0.420631f, 0.391875f, // 5054
0.000067f, 0.000012f, 0.000011f, 0.000008f, 0.000011f, 0.000057f, 0.000143f, // 5061
0.000215f, 0.000937f, 0.001189f, 0.000148f, 0.000001f, 0.000006f, 0.000005f, // 5068
0.000024f, 0.000062f, 0.000757f, 0.000199f, 0.000182f, 0.000163f, 0.002573f, // 5075
0.360343f, 0.306784f, 0.000139f, 0.000022f, 0.000075f, 0.000030f, 0.000019f, // 5082
0.000966f, 0.002215f, 0.002081f, 0.002868f, 0.005799f, 0.002136f, 0.000858f, // 5089
0.000336f, 0.000135f, 0.000158f, 0.000180f, 0.000529f, 0.000164f, 0.000180f, // 5096
0.000019f, 0.000980f, 0.139864f, 0.362141f, 0.002271f, 0.000223f, 0.000121f, // 5103
0.000067f, 0.000055f, 0.000584f, 0.003005f, 0.013639f, 0.007667f, 0.010625f, // 5110
0.005423f, 0.005767f, 0.003225f, 0.000589f, 0.000837f, 0.001492f, 0.003986f, // 5117
0.001957f, 0.001602f, 0.000350f, 0.001833f, 0.098704f, 0.603133f, 0.078307f, // 5124
0.013175f, 0.028704f, 0.060024f, 0.021973f, 0.144699f, 0.199341f, 0.324927f, // 5131
0.405417f, 0.368061f, 0.350958f, 0.292210f, 0.184905f, 0.049070f, 0.014390f, // 5138
0.011900f, 0.038320f, 0.030459f, 0.035667f, 0.012584f, 0.034108f, 0.444983f, // 5145
0.004680f, 0.002580f, 0.003286f, 0.019306f, 0.069776f, 0.035701f, 0.003541f, // 5152
0.000657f, 0.000469f, 0.000187f, 0.000345f, 0.000386f, 0.000857f, 0.004596f, // 5159
0.002197f, 0.005508f, 0.017770f, 0.005270f, 0.003416f, 0.000921f, 0.001987f, // 5166
0.016064f, 0.041163f, 0.001689f, 0.007366f, 0.003199f, 0.014510f, 0.033394f, // 5173
0.079577f, 0.002744f, 0.000492f, 0.000295f, 0.001867f, 0.001514f, 0.001246f, // 5180
0.002023f, 0.002350f, 0.001803f, 0.014997f, 0.053893f, 0.008396f, 0.000962f, // 5187
0.000110f, 0.000598f, 0.002282f, 0.033653f, 0.000757f, 0.003066f, 0.000125f, // 5194
0.001380f, 0.008923f, 0.058393f, 0.001610f, 0.001461f, 0.000264f, 0.000398f, // 5201
0.000598f, 0.001990f, 0.000272f, 0.000232f, 0.000631f, 0.003536f, 0.041854f, // 5208
0.006920f, 0.000356f, 0.000044f, 0.000214f, 0.004340f, 0.023403f, 0.000739f, // 5215
0.012241f, 0.000405f, 0.014637f, 0.019133f, 0.042023f, 0.001164f, 0.000803f, // 5222
0.000829f, 0.003350f, 0.001465f, 0.002157f, 0.001449f, 0.001192f, 0.000868f, // 5229
0.004640f, 0.037272f, 0.013903f, 0.000512f, 0.000045f, 0.000022f, 0.000479f, // 5236
0.020011f, 0.000674f, 0.005106f, 0.001118f, 0.036116f, 0.056636f, 0.160654f, // 5243
0.007984f, 0.000837f, 0.002110f, 0.004803f, 0.004368f, 0.002294f, 0.003155f, // 5250
0.001179f, 0.001470f, 0.008415f, 0.149828f, 0.138648f, 0.002730f, 0.000333f, // 5257
0.000092f, 0.001301f, 0.032028f, 0.000918f, 0.011307f, 0.002705f, 0.033268f, // 5264
0.047645f, 0.102378f, 0.008834f, 0.001419f, 0.000770f, 0.003325f, 0.004101f, // 5271
0.003048f, 0.010707f, 0.004367f, 0.002687f, 0.021432f, 0.300076f, 0.309234f, // 5278
0.009013f, 0.000658f, 0.000105f, 0.001091f, 0.012139f, 0.001178f, 0.020489f, // 5285
0.005833f, 0.041042f, 0.137836f, 0.130606f, 0.012371f, 0.001766f, 0.009132f, // 5292
0.024254f, 0.042693f, 0.029343f, 0.052753f, 0.035644f, 0.022171f, 0.027743f, // 5299
0.393643f, 0.189257f, 0.053533f, 0.003156f, 0.000382f, 0.001212f, 0.010958f, // 5306
0.002419f, 0.015814f, 0.009806f, 0.058073f, 0.191509f, 0.110797f, 0.016922f, // 5313
0.001273f, 0.002404f, 0.006935f, 0.003604f, 0.009513f, 0.032734f, 0.047149f, // 5320
0.113224f, 0.159484f, 0.687292f, 0.438037f, 0.039212f, 0.008578f, 0.000566f, // 5327
0.001584f, 0.012212f, 0.001367f, 0.005248f, 0.004217f, 0.020666f, 0.139174f, // 5334
0.105509f, 0.020216f, 0.001301f, 0.003320f, 0.006761f, 0.002401f, 0.004623f, // 5341
0.008951f, 0.006844f, 0.010808f, 0.020507f, 0.165623f, 0.089456f, 0.027840f, // 5348
0.004228f, 0.000470f, 0.003537f, 0.015563f, 0.001455f, 0.003716f, 0.000675f, // 5355
0.004759f, 0.021863f, 0.023059f, 0.007649f, 0.001363f, 0.001019f, 0.001846f, // 5362
0.002162f, 0.001449f, 0.000729f, 0.000800f, 0.002463f, 0.018406f, 0.017090f, // 5369
0.025008f, 0.010014f, 0.000398f, 0.000126f, 0.004411f, 0.015543f, 0.000595f, // 5376
0.000578f, 0.000012f, 0.000071f, 0.002401f, 0.009125f, 0.005318f, 0.000535f, // 5383
0.000302f, 0.000080f, 0.000068f, 0.000011f, 0.000004f, 0.000012f, 0.000507f, // 5390
0.005200f, 0.006322f, 0.018469f, 0.010422f, 0.001082f, 0.000036f, 0.000841f, // 5397
0.009836f, 0.000259f, 0.000240f, 0.000004f, 0.000289f, 0.003114f, 0.011053f, // 5404
0.001528f, 0.000176f, 0.000113f, 0.000170f, 0.000082f, 0.000119f, 0.000092f, // 5411
0.000046f, 0.000357f, 0.007376f, 0.011235f, 0.052266f, 0.005430f, 0.000125f, // 5418
0.000046f, 0.001125f, 0.030206f, 0.002338f, 0.002211f, 0.000019f, 0.000136f, // 5425
0.003382f, 0.010106f, 0.015584f, 0.007266f, 0.007305f, 0.006193f, 0.004525f, // 5432
0.001282f, 0.001474f, 0.001712f, 0.001443f, 0.005623f, 0.020332f, 0.032928f, // 5439
0.005836f, 0.000232f, 0.000059f, 0.000319f, 0.014544f, 0.011571f, 0.014200f, // 5446
0.003611f, 0.009617f, 0.034561f, 0.070580f, 0.034163f, 0.019629f, 0.020209f, // 5453
0.023815f, 0.021742f, 0.024245f, 0.015932f, 0.014850f, 0.026274f, 0.036051f, // 5460
0.027679f, 0.017684f, 0.001150f, 0.000361f, 0.002861f, 0.008127f, 0.039218f, // 5467
0.139741f, 0.206311f, 0.185335f, 0.379091f, 0.313032f, 0.299252f, 0.189765f, // 5474
0.117579f, 0.098443f, 0.102691f, 0.079096f, 0.149893f, 0.133426f, 0.147764f, // 5481
0.146637f, 0.155530f, 0.206188f, 0.148651f, 0.129922f, 0.154976f, 0.158164f, // 5488
0.257895f, 0.409323f, 0.403446f, 0.692909f, 0.661343f, 0.659160f, 0.404950f, // 5495
0.636051f, 0.397961f, 0.420449f, 0.165806f, 0.293011f, 0.442725f, 0.374466f, // 5502
0.230641f, 0.153724f, 0.191448f, 0.260172f, 0.480001f, 0.289744f, 0.125487f, // 5509
0.136811f, 0.126120f, 0.178334f, 0.298783f, 0.241180f, 0.267941f, 0.176250f, // 5516
0.131292f, 0.163259f, 0.731335f, 0.457619f, 0.460006f, 0.256817f, 0.160064f, // 5523
0.257963f, 0.287211f, 0.100420f, 0.218461f, 0.263682f, 0.175387f, 0.200448f, // 5530
0.097412f, 0.132146f, 0.083278f, 0.065641f, 0.184031f, 0.175195f, 0.277154f, // 5537
0.308752f, 0.178418f, 0.099249f, 0.106484f, 0.301904f, 0.262620f, 0.484863f, // 5544
0.194787f, 0.152482f, 0.187398f, 0.122810f, 0.047873f, 0.244666f, 0.171748f, // 5551
0.134573f, 0.259028f, 0.197877f, 0.096814f, 0.094162f, 0.027733f, 0.080034f, // 5558
0.167573f, 0.179726f, 0.201836f, 0.231936f, 0.200614f, 0.318693f, 0.706078f, // 5565
0.746341f, 0.754077f, 0.829189f, 0.290030f, 0.270900f, 0.179731f, 0.154470f, // 5572
0.478752f, 0.279495f, 0.406987f, 0.552726f, 0.614732f, 0.315790f, 0.180882f, // 5579
0.057094f, 0.168821f, 0.245346f, 0.191931f, 0.332547f, 0.231233f, 0.281905f, // 5586
0.430586f, 0.714773f, 0.841239f, 0.843301f, 0.827050f, 0.797488f, 0.663340f, // 5593
0.612619f, 0.707749f, 0.748957f, 0.724122f, 0.690212f, 0.619365f, 0.660005f, // 5600
0.262152f, 0.155818f, 0.096461f, 0.184651f, 0.274735f, 0.188935f, 0.512507f, // 5607
0.277622f, 0.475699f, 0.595877f, 0.867266f, 0.949847f, 0.904308f, 0.964614f, // 5614
0.966541f, 0.960036f, 0.935074f, 0.963842f, 0.976731f, 0.975576f, 0.981805f, // 5621
0.911973f, 0.884466f, 0.456462f, 0.243988f, 0.183140f, 0.248250f, 0.326347f, // 5628
0.219671f, 0.402534f, 0.351515f, 0.432325f, 0.612702f, 0.577065f, 0.853387f, // 5635
0.823030f, 0.939197f, 0.965209f, 0.901635f, 0.916852f, 0.931522f, 0.971499f, // 5642
0.992914f, 0.985830f, 0.895280f, 0.743584f, 0.274157f, 0.185238f, 0.058855f, // 5649
0.085907f, 0.310548f, 0.162173f, 0.337011f, 0.253782f, 0.423429f, 0.504039f, // 5656
0.449198f, 0.528891f, 0.536301f, 0.641284f, 0.789443f, 0.642455f, 0.578213f, // 5663
0.713558f, 0.817085f, 0.875116f, 0.804086f, 0.610843f, 0.545232f, 0.403577f, // 5670
0.206391f, 0.055911f, 0.063145f, 0.190551f, 0.149969f, 0.309630f, 0.256158f, // 5677
0.401321f, 0.351646f, 0.285225f, 0.263146f, 0.309778f, 0.432622f, 0.488764f, // 5684
0.385488f, 0.396994f, 0.553068f, 0.665639f, 0.796851f, 0.747246f, 0.582769f, // 5691
0.612394f, 0.532029f, 0.196508f, 0.056539f, 0.085236f, 0.228281f, 0.166584f, // 5698
0.223465f, 0.151193f, 0.243831f, 0.297652f, 0.163367f, 0.252026f, 0.185466f, // 5705
0.258014f, 0.171968f, 0.213729f, 0.188901f, 0.400489f, 0.438996f, 0.732648f, // 5712
0.617327f, 0.668025f, 0.737877f, 0.671093f, 0.323138f, 0.064852f, 0.055247f, // 5719
0.186321f, 0.118837f, 0.157101f, 0.108197f, 0.426371f, 0.243647f, 0.270787f, // 5726
0.468337f, 0.342119f, 0.339739f, 0.198594f, 0.214707f, 0.226091f, 0.260214f, // 5733
0.460238f, 0.515265f, 0.554008f, 0.668700f, 0.831681f, 0.694157f, 0.223940f, // 5740
0.040703f, 0.099970f, 0.386447f, 0.263883f, 0.149044f, 0.104874f, 0.239500f, // 5747
0.290480f, 0.453870f, 0.742412f, 0.709386f, 0.762826f, 0.739709f, 0.721369f, // 5754
0.653865f, 0.686465f, 0.575165f, 0.640114f, 0.523132f, 0.707074f, 0.737840f, // 5761
0.596892f, 0.197143f, 0.080512f, 0.109999f, 0.380820f, 0.290961f, 0.118580f, // 5768
0.373229f, 0.420698f, 0.370654f, 0.530885f, 0.749241f, 0.708820f, 0.639053f, // 5775
0.705388f, 0.636577f, 0.645555f, 0.542629f, 0.649441f, 0.683766f, 0.624971f, // 5782
0.442319f, 0.441152f, 0.303817f, 0.191780f, 0.216382f, 0.279078f, 0.329642f, // 5789
};
size_t cls_scores_data_size = sizeof(cls_scores_data) / sizeof(cls_scores_data[0]);
float bbox_pred_data[] = {
0.006756f, 0.062491f, 0.113831f, 0.063944f, 0.024297f, 0.009997f, -0.043972f, // 0
-0.051204f, -0.036587f, -0.048956f, -0.021944f, -0.011054f, -0.023826f, -0.003094f, // 7
-0.025690f, -0.012323f, -0.050170f, -0.043965f, -0.070886f, -0.073030f, -0.052720f, // 14
-0.031728f, -0.002943f, 0.019459f, 0.081261f, 0.131690f, 0.079081f, 0.060464f, // 21
0.053028f, -0.000740f, -0.057226f, -0.061122f, -0.060031f, -0.042141f, -0.019677f, // 28
-0.057622f, -0.034892f, -0.012757f, -0.016674f, -0.069439f, -0.097793f, -0.163116f, // 35
-0.154070f, -0.069163f, 0.001579f, 0.006734f, 0.029766f, 0.043414f, 0.091557f, // 42
0.080250f, 0.054972f, 0.038119f, -0.018596f, -0.066556f, -0.089845f, -0.068290f, // 49
-0.066188f, -0.063900f, -0.041102f, -0.012241f, 0.016284f, 0.008947f, -0.023090f, // 56
-0.050430f, -0.124230f, -0.161700f, -0.095664f, -0.057944f, -0.024310f, 0.047309f, // 63
0.040948f, 0.114683f, 0.091233f, 0.086797f, 0.044141f, 0.014311f, -0.020745f, // 70
-0.087884f, -0.059212f, -0.039462f, -0.039696f, -0.049854f, -0.024422f, 0.021382f, // 77
0.014929f, -0.032617f, -0.038473f, -0.092884f, -0.135001f, -0.177583f, -0.101400f, // 84
0.010431f, 0.054667f, 0.024300f, 0.091408f, 0.069529f, 0.046450f, -0.003564f, // 91
-0.018168f, -0.015623f, -0.040428f, -0.044236f, -0.024771f, -0.013782f, -0.019360f, // 98
-0.045121f, 0.008991f, 0.005889f, -0.055875f, -0.057755f, -0.078120f, -0.094223f, // 105
-0.120088f, -0.078466f, 0.015814f, 0.044132f, 0.046949f, 0.107520f, 0.080040f, // 112
0.054983f, 0.009632f, -0.057873f, -0.040977f, -0.058749f, -0.043190f, -0.000237f, // 119
0.012520f, 0.016806f, -0.013124f, 0.001649f, 0.001733f, -0.040773f, -0.052762f, // 126
-0.095145f, -0.138426f, -0.155720f, -0.073430f, -0.001773f, 0.067399f, 0.064256f, // 133
0.083492f, 0.075192f, 0.034017f, 0.032716f, -0.024322f, -0.040400f, 0.003228f, // 140
-0.039995f, 0.001472f, 0.030291f, 0.005046f, -0.010476f, -0.007436f, -0.020516f, // 147
-0.118009f, -0.078903f, -0.112752f, -0.157899f, -0.113039f, -0.062663f, 0.010040f, // 154
0.065072f, 0.063746f, 0.114623f, 0.058704f, 0.049952f, 0.061126f, 0.030012f, // 161
-0.024521f, -0.043885f, -0.034703f, 0.008102f, 0.025561f, 0.028279f, 0.046325f, // 168
0.035441f, -0.005910f, -0.063013f, -0.058615f, -0.135505f, -0.139825f, -0.142390f, // 175
-0.062057f, 0.015461f, 0.066387f, 0.058223f, 0.130988f, 0.074407f, 0.037210f, // 182
0.056378f, 0.032825f, -0.030276f, -0.046373f, -0.039746f, -0.021358f, 0.001630f, // 189
0.020514f, 0.059904f, 0.027180f, -0.000994f, -0.079340f, -0.074141f, -0.130174f, // 196
-0.137217f, -0.139897f, -0.119927f, -0.009487f, 0.063393f, 0.043726f, 0.133786f, // 203
0.060298f, 0.018043f, 0.046884f, 0.018174f, -0.034585f, -0.081232f, -0.077225f, // 210
-0.055879f, -0.031072f, -0.009002f, 0.013615f, -0.033781f, -0.049456f, -0.107660f, // 217
-0.081217f, -0.158274f, -0.156664f, -0.165170f, -0.118352f, -0.035838f, 0.078114f, // 224
0.070709f, 0.116475f, 0.100635f, 0.032834f, 0.007598f, -0.021000f, -0.058858f, // 231
-0.104435f, -0.116757f, -0.092693f, -0.088822f, -0.064683f, -0.041829f, -0.047115f, // 238
-0.096250f, -0.091444f, -0.055776f, -0.089885f, -0.089572f, -0.127653f, -0.133473f, // 245
-0.030361f, 0.108382f, 0.040964f, 0.080842f, 0.010655f, -0.012835f, 0.002187f, // 252
-0.020509f, -0.044425f, -0.073892f, -0.083775f, -0.064889f, -0.076980f, -0.096131f, // 259
-0.086259f, -0.061553f, -0.104739f, -0.113292f, -0.084270f, -0.109193f, -0.132607f, // 266
-0.204923f, -0.092120f, 0.000490f, 0.045301f, -0.025227f, 0.028258f, 0.025712f, // 273
0.050703f, 0.053918f, -0.045033f, -0.058957f, -0.043595f, -0.059031f, -0.045938f, // 280
-0.076127f, -0.108927f, -0.097380f, -0.083156f, -0.134752f, -0.122623f, -0.069790f, // 287
-0.087261f, -0.166239f, -0.217776f, -0.120298f, -0.009825f, 0.007451f, 0.010375f, // 294
0.024058f, 0.045761f, 0.049955f, 0.070592f, 0.018057f, -0.001711f, 0.015509f, // 301
0.002567f, 0.015427f, 0.011950f, 0.003258f, -0.006584f, 0.003169f, -0.009733f, // 308
-0.047931f, -0.054635f, -0.026136f, -0.055278f, -0.059309f, -0.024034f, 0.000538f, // 315
-0.055635f, 0.002366f, 0.028922f, 0.160725f, 0.139126f, 0.157822f, 0.102556f, // 322
0.048419f, 0.065824f, 0.085409f, 0.100535f, 0.132813f, 0.139843f, 0.113862f, // 329
0.139533f, 0.093993f, 0.133827f, 0.122975f, 0.076213f, -0.006181f, -0.047606f, // 336
-0.042117f, -0.000351f, 0.005487f, -0.004748f, -0.021968f, 0.053254f, 0.053006f, // 343
0.094140f, 0.091223f, 0.085605f, 0.078722f, 0.130068f, 0.143752f, 0.114212f, // 350
0.123571f, 0.111608f, 0.128058f, 0.110996f, 0.066212f, 0.070923f, 0.061051f, // 357
0.033209f, 0.001184f, 0.042962f, 0.028412f, -0.008534f, 0.005425f, -0.029615f, // 364
-0.049972f, -0.066171f, 0.008362f, -0.010730f, -0.003882f, 0.025177f, 0.081435f, // 371
0.069423f, 0.037400f, -0.019886f, 0.038569f, 0.058475f, 0.044809f, 0.015664f, // 378
-0.044028f, -0.036462f, -0.034747f, -0.017361f, 0.023022f, 0.062784f, -0.028529f, // 385
0.017188f, -0.082874f, -0.012746f, -0.026301f, 0.016536f, 0.016605f, -0.062505f, // 392
0.014384f, 0.084947f, 0.087778f, 0.112815f, 0.064523f, 0.116127f, 0.060251f, // 399
0.045478f, 0.001783f, -0.034136f, -0.030093f, -0.052966f, 0.017316f, 0.016853f, // 406
0.065426f, -0.035185f, -0.026682f, -0.080411f, -0.010943f, -0.000674f, 0.021952f, // 413
0.007690f, -0.051291f, -0.003506f, 0.057344f, 0.032605f, 0.034955f, 0.043942f, // 420
0.041108f, 0.023278f, 0.007402f, 0.006395f, -0.013253f, -0.048756f, -0.033758f, // 427
0.012009f, 0.035873f, 0.065757f, -0.061807f, -0.025344f, -0.062031f, -0.043955f, // 434
-0.011667f, -0.045104f, -0.021290f, -0.082469f, -0.041199f, -0.041765f, -0.060205f, // 441
-0.075411f, -0.033353f, -0.018057f, -0.064873f, -0.085732f, -0.011260f, -0.040956f, // 448
-0.013617f, -0.033245f, -0.015474f, -0.002988f, 0.064202f, -0.079726f, -0.005539f, // 455
-0.021197f, -0.021035f, -0.040569f, -0.022181f, -0.021637f, -0.062958f, -0.036281f, // 462
-0.076713f, -0.094538f, -0.091781f, -0.039217f, -0.031256f, -0.079987f, -0.093169f, // 469
-0.010113f, -0.040690f, 0.025406f, 0.042802f, 0.063725f, 0.070069f, 0.061229f, // 476
-0.053214f, 0.072926f, 0.014816f, -0.027411f, -0.100377f, -0.115553f, -0.080283f, // 483
-0.028477f, -0.036048f, -0.080362f, -0.060181f, -0.042758f, -0.064390f, -0.017106f, // 490
-0.016983f, -0.013327f, -0.021324f, -0.082562f, -0.016226f, 0.022171f, 0.048423f, // 497
0.046005f, 0.050081f, -0.043121f, 0.034111f, 0.007560f, -0.017893f, -0.080116f, // 504
-0.135378f, -0.119255f, -0.006430f, -0.036061f, -0.052196f, -0.051664f, -0.047366f, // 511
-0.093195f, -0.062225f, -0.046710f, -0.057208f, -0.032980f, -0.031465f, -0.030082f, // 518
-0.010489f, 0.013295f, 0.004917f, 0.077104f, -0.028134f, 0.057533f, 0.024548f, // 525
-0.005678f, -0.020729f, -0.055141f, -0.022825f, 0.050014f, 0.012142f, -0.004790f, // 532
-0.047620f, -0.027696f, -0.041192f, -0.014304f, 0.033296f, 0.005614f, 0.009168f, // 539
-0.013832f, -0.032200f, -0.049080f, -0.023914f, 0.026827f, 0.081236f, -0.038641f, // 546
0.084201f, 0.005477f, -0.020937f, -0.009534f, -0.039340f, -0.006018f, -0.021172f, // 553
-0.027573f, -0.051181f, -0.087745f, -0.075718f, -0.057195f, -0.049644f, 0.001042f, // 560
-0.000198f, -0.030945f, -0.036744f, -0.064082f, 0.005884f, -0.000550f, 0.064498f, // 567
0.046649f, 0.007226f, 0.043124f, 0.023653f, -0.003145f, -0.034472f, -0.056292f, // 574
-0.059254f, -0.098636f, -0.166988f, -0.142746f, -0.140280f, -0.123250f, -0.159957f, // 581
-0.166934f, -0.141648f, -0.097823f, -0.110787f, -0.111505f, -0.129998f, -0.057475f, // 588
-0.012270f, 0.015800f, 0.057602f, -0.042402f, 0.041177f, -0.057334f, -0.046211f, // 595
-0.054554f, -0.063633f, -0.037211f, -0.065051f, -0.084868f, -0.109807f, -0.139411f, // 602
-0.156851f, -0.125107f, -0.069642f, -0.075389f, -0.096445f, -0.096533f, -0.094240f, // 609
-0.110843f, -0.075076f, -0.037128f, -0.012462f, 0.018251f, 0.070149f, 0.089407f, // 616
0.019672f, -0.014560f, -0.015722f, -0.000601f, 0.044009f, 0.049153f, 0.032304f, // 623
-0.000920f, 0.003042f, 0.002254f, 0.010362f, -0.011011f, -0.020520f, -0.051161f, // 630
-0.068397f, -0.072188f, -0.037433f, 0.020620f, 0.029672f, 0.023556f, 0.037754f, // 637
0.030843f, 0.122464f, 0.017785f, -0.022493f, -0.123580f, 0.020116f, 0.180494f, // 644
0.235604f, 0.288751f, 0.325399f, 0.190310f, 0.241014f, 0.208539f, 0.133076f, // 651
0.147519f, 0.091785f, -0.031870f, -0.041742f, 0.043786f, 0.159438f, 0.150522f, // 658
0.123170f, 0.088424f, 0.259235f, 0.168729f, 0.086201f, -0.037095f, -0.145347f, // 665
-0.022521f, 0.187247f, 0.402210f, 0.408685f, 0.343381f, 0.238274f, 0.278809f, // 672
0.270079f, 0.216845f, 0.146817f, -0.030821f, -0.049007f, -0.107332f, -0.059419f, // 679
0.262701f, 0.173840f, 0.200904f, 0.090173f, 0.281362f, 0.152497f, 0.091163f, // 686
-0.092854f, -0.156477f, 0.034047f, 0.115681f, 0.215744f, 0.330599f, 0.282674f, // 693
0.181376f, 0.212245f, 0.207292f, 0.248175f, 0.095351f, -0.075029f, -0.114773f, // 700
-0.177506f, 0.067785f, 0.249091f, 0.193228f, 0.164329f, 0.026508f, 0.259298f, // 707
-0.023563f, 0.063033f, -0.164808f, -0.179451f, 0.022108f, 0.137097f, 0.247429f, // 714
0.114672f, 0.133115f, 0.063321f, 0.178621f, 0.163577f, 0.281048f, 0.196815f, // 721
-0.023639f, -0.102610f, -0.080556f, -0.003049f, 0.140631f, 0.178320f, 0.141211f, // 728
0.005924f, 0.298014f, 0.026142f, 0.121843f, -0.101121f, -0.095319f, 0.108799f, // 735
0.205437f, 0.252523f, 0.214764f, 0.148122f, 0.161741f, 0.174642f, 0.144497f, // 742
0.292580f, 0.096371f, 0.030662f, -0.058053f, 0.014672f, -0.056615f, 0.101402f, // 749
0.167615f, 0.128042f, 0.002095f, 0.284251f, 0.003759f, 0.010542f, -0.086954f, // 756
-0.056512f, 0.053891f, 0.156159f, 0.147571f, 0.219972f, 0.244183f, 0.225711f, // 763
0.200207f, 0.116340f, 0.283989f, 0.216064f, 0.021744f, -0.018257f, 0.036817f, // 770
-0.072531f, -0.006662f, 0.105259f, 0.090270f, 0.053502f, 0.278857f, 0.048204f, // 777
-0.013172f, -0.016972f, -0.044413f, 0.074651f, 0.235012f, 0.260429f, 0.150463f, // 784
0.173080f, 0.211325f, 0.191225f, 0.069685f, 0.170454f, 0.147219f, 0.113835f, // 791
0.004173f, 0.018630f, -0.027680f, 0.051522f, 0.184219f, 0.130164f, 0.099539f, // 798
0.250803f, 0.070520f, -0.040671f, -0.001982f, -0.042434f, 0.026579f, 0.209171f, // 805
0.215037f, 0.205074f, 0.249855f, 0.296364f, 0.239035f, 0.072492f, 0.132803f, // 812
0.190586f, 0.096318f, 0.015131f, -0.037281f, -0.138736f, -0.071902f, -0.002703f, // 819
0.078796f, 0.151291f, 0.252884f, 0.110317f, 0.020937f, 0.083890f, -0.005249f, // 826
0.068050f, 0.242975f, 0.238483f, 0.205044f, 0.288158f, 0.401943f, 0.288594f, // 833
0.154817f, 0.161557f, 0.173906f, 0.090662f, -0.081507f, -0.075100f, -0.147438f, // 840
0.012947f, 0.136589f, 0.033554f, 0.159698f, 0.247950f, 0.193731f, 0.133669f, // 847
0.167237f, 0.082349f, 0.146290f, 0.292535f, 0.344488f, 0.265151f, 0.309856f, // 854
0.304385f, 0.281659f, 0.265829f, 0.246883f, 0.167255f, 0.115874f, -0.004294f, // 861
-0.029647f, -0.126531f, 0.068474f, 0.157344f, 0.073696f, 0.012388f, 0.321792f, // 868
0.274013f, 0.246946f, 0.190182f, 0.107197f, 0.182179f, 0.324747f, 0.330210f, // 875
0.304213f, 0.404604f, 0.407646f, 0.432719f, 0.572197f, 0.500201f, 0.294235f, // 882
0.137146f, 0.068921f, -0.037203f, -0.003786f, 0.107031f, 0.251031f, 0.026465f, // 889
0.029902f, 0.346020f, 0.270750f, 0.239789f, 0.132601f, 0.021923f, 0.154665f, // 896
0.348056f, 0.376850f, 0.355767f, 0.401342f, 0.463876f, 0.480068f, 0.508824f, // 903
0.438741f, 0.251091f, 0.114369f, 0.089685f, -0.011111f, 0.057077f, 0.313149f, // 910
0.413313f, 0.201024f, 0.088398f, 0.237372f, 0.193258f, 0.289070f, 0.297188f, // 917
0.202402f, 0.279195f, 0.428145f, 0.454660f, 0.452797f, 0.485078f, 0.458232f, // 924
0.529839f, 0.534125f, 0.453412f, 0.409976f, 0.267627f, 0.201328f, 0.173388f, // 931
0.232364f, 0.417267f, 0.485833f, 0.314501f, 0.095637f, 0.084563f, 0.127877f, // 938
0.223417f, 0.164649f, 0.062842f, 0.081824f, 0.169790f, 0.151796f, 0.172497f, // 945
0.209249f, 0.231528f, 0.199743f, 0.203700f, 0.223708f, 0.245357f, 0.193866f, // 952
0.147577f, 0.123907f, 0.257951f, 0.350945f, 0.362098f, 0.224431f, 0.100296f, // 959
0.007482f, -0.003326f, 0.059708f, -0.132291f, -0.127979f, -0.142337f, -0.084721f, // 966
-0.185797f, -0.110813f, -0.058294f, -0.133746f, -0.148763f, -0.154803f, -0.065788f, // 973
-0.047339f, 0.071880f, 0.031415f, -0.103082f, 0.011717f, 0.024012f, 0.034472f, // 980
0.137118f, -0.014738f, -0.005773f, 0.017734f, -0.027045f, -0.109072f, -0.040570f, // 987
-0.081296f, -0.206447f, -0.006086f, 0.052434f, -0.045914f, -0.135379f, -0.152461f, // 994
-0.105031f, -0.023508f, -0.142618f, 0.012106f, 0.039475f, -0.075893f, -0.275218f, // 1001
-0.175763f, -0.125777f, 0.151091f, -0.045795f, 0.041316f, 0.179018f, -0.001667f, // 1008
0.045011f, -0.022549f, 0.099769f, -0.001067f, 0.135118f, 0.297756f, 0.249342f, // 1015
0.128096f, 0.060032f, 0.008391f, 0.142563f, -0.041364f, -0.038018f, 0.130407f, // 1022
0.017126f, -0.151868f, 0.041251f, 0.060820f, 0.219450f, 0.052444f, 0.085219f, // 1029
0.183745f, 0.161311f, 0.240766f, 0.175256f, 0.260104f, 0.050921f, 0.234909f, // 1036
0.344669f, 0.401769f, 0.290213f, 0.449013f, 0.350757f, 0.374214f, 0.109881f, // 1043
0.257941f, 0.245003f, 0.191389f, 0.044812f, 0.007327f, 0.050628f, 0.206992f, // 1050
0.078853f, 0.184938f, 0.318646f, 0.329208f, 0.403532f, 0.443894f, 0.462619f, // 1057
0.243657f, 0.258109f, 0.523989f, 0.549617f, 0.496200f, 0.522584f, 0.550625f, // 1064
0.505392f, 0.360718f, 0.405510f, 0.346778f, 0.391397f, 0.162382f, 0.125303f, // 1071
0.113799f, 0.206177f, 0.092197f, 0.230963f, 0.457090f, 0.428311f, 0.407098f, // 1078
0.491421f, 0.503064f, 0.484530f, 0.346080f, 0.616611f, 0.546565f, 0.471571f, // 1085
0.479555f, 0.422918f, 0.580288f, 0.542071f, 0.530415f, 0.565367f, 0.475491f, // 1092
0.259855f, 0.092370f, -0.039558f, 0.087137f, -0.060093f, 0.301958f, 0.223850f, // 1099
0.147252f, 0.286418f, 0.483702f, 0.573835f, 0.607057f, 0.396901f, 0.528302f, // 1106
0.476123f, 0.438046f, 0.533679f, 0.529970f, 0.540467f, 0.550611f, 0.623730f, // 1113
0.554027f, 0.369441f, 0.245163f, 0.067933f, -0.186553f, -0.060438f, -0.094205f, // 1120
0.143522f, 0.033705f, -0.070037f, 0.170166f, 0.375757f, 0.447497f, 0.586904f, // 1127
0.383261f, 0.399960f, 0.401027f, 0.272194f, 0.363475f, 0.394000f, 0.364098f, // 1134
0.654894f, 0.616718f, 0.486040f, 0.296141f, 0.045221f, -0.092031f, -0.316311f, // 1141
-0.146881f, -0.017171f, 0.163664f, 0.055993f, -0.070103f, 0.029800f, 0.248610f, // 1148
0.396026f, 0.434043f, 0.191933f, 0.298839f, 0.298260f, 0.380281f, 0.304267f, // 1155
0.455885f, 0.368528f, 0.355561f, 0.327053f, 0.124681f, 0.054216f, 0.023914f, // 1162
-0.019774f, -0.039411f, -0.055269f, 0.124338f, 0.143303f, -0.169638f, -0.235306f, // 1169
-0.098475f, 0.006192f, 0.113939f, 0.186552f, -0.042376f, -0.116226f, 0.009319f, // 1176
0.223015f, 0.223637f, 0.178214f, 0.150206f, 0.089152f, 0.053572f, -0.025198f, // 1183
-0.025780f, -0.044947f, 0.062421f, 0.045594f, 0.001060f, 0.043083f, 0.018773f, // 1190
-0.228662f, -0.271350f, -0.162022f, -0.187481f, -0.010316f, 0.053311f, -0.166158f, // 1197
-0.099929f, -0.109605f, 0.084491f, 0.001115f, -0.001640f, -0.031990f, 0.054440f, // 1204
0.004487f, -0.049542f, -0.116091f, -0.019955f, -0.085865f, -0.048728f, -0.050993f, // 1211
0.070886f, -0.135612f, -0.393557f, -0.708037f, -0.630679f, -0.416895f, -0.038072f, // 1218
-0.073075f, -0.241263f, -0.075407f, -0.136275f, -0.145549f, -0.140769f, -0.193452f, // 1225
-0.043583f, -0.031167f, -0.048750f, -0.180594f, -0.209616f, -0.132306f, -0.128040f, // 1232
-0.100973f, -0.125928f, 0.005298f, -0.380852f, -0.578026f, -0.780627f, -0.669598f, // 1239
-0.449924f, -0.096097f, -0.064631f, -0.181443f, -0.248122f, -0.379710f, -0.350831f, // 1246
-0.263335f, -0.172290f, -0.141608f, -0.218875f, -0.243136f, -0.240364f, -0.227126f, // 1253
-0.180497f, -0.322443f, -0.170450f, -0.217935f, -0.068931f, -0.382536f, -0.414315f, // 1260
-0.445414f, -0.309349f, -0.248470f, 0.001060f, -0.074559f, -0.158195f, -0.228133f, // 1267
-0.189052f, -0.277562f, -0.238431f, -0.206355f, -0.197449f, -0.132471f, -0.020529f, // 1274
0.009204f, -0.008712f, -0.121580f, -0.337206f, -0.194449f, -0.297010f, -0.048314f, // 1281
0.009056f, 0.015468f, 0.037658f, 0.010542f, 0.004587f, 0.008199f, -0.011962f, // 1288
-0.019569f, -0.015578f, -0.028495f, -0.006151f, -0.005996f, -0.011260f, -0.006183f, // 1295
-0.008080f, -0.007481f, -0.024434f, -0.017180f, -0.017350f, -0.018304f, -0.019942f, // 1302
-0.023441f, -0.014436f, 0.003661f, 0.024208f, 0.063592f, 0.019867f, 0.026706f, // 1309
0.039823f, 0.022042f, -0.003334f, -0.012203f, -0.029667f, -0.009459f, 0.004750f, // 1316
-0.023266f, -0.014300f, 0.004747f, 0.009777f, -0.019144f, -0.024244f, -0.037647f, // 1323
-0.037459f, -0.017183f, -0.010154f, -0.003244f, -0.006259f, 0.021345f, 0.058142f, // 1330
0.031789f, 0.029864f, 0.039575f, 0.015698f, 0.008531f, -0.009987f, -0.014071f, // 1337
-0.003001f, 0.014706f, 0.017634f, 0.008235f, 0.038329f, 0.011937f, 0.004083f, // 1344
-0.002293f, -0.016276f, -0.022842f, -0.005739f, -0.010526f, -0.013813f, -0.001854f, // 1351
0.027186f, 0.079688f, 0.045142f, 0.059671f, 0.048791f, 0.012225f, 0.007069f, // 1358
-0.007482f, -0.009611f, 0.004193f, 0.018361f, 0.008105f, 0.006595f, 0.013879f, // 1365
0.010951f, -0.002218f, -0.003651f, -0.009289f, -0.027155f, -0.030568f, -0.023220f, // 1372
-0.009873f, 0.007681f, 0.017909f, 0.064561f, 0.030156f, 0.035262f, 0.028142f, // 1379
0.004810f, -0.000172f, 0.005796f, -0.013191f, 0.001712f, 0.012406f, 0.010858f, // 1386
-0.000868f, 0.005304f, -0.003816f, -0.017582f, -0.017555f, -0.013002f, -0.020883f, // 1393
-0.028583f, -0.016190f, -0.036595f, 0.021899f, 0.023308f, 0.063130f, 0.023728f, // 1400
0.037464f, 0.028923f, -0.008595f, -0.005024f, -0.006405f, -0.008645f, 0.012005f, // 1407
0.018575f, 0.018308f, 0.005141f, 0.001179f, -0.000524f, -0.007249f, -0.005554f, // 1414
-0.020682f, -0.027965f, -0.041177f, -0.017296f, -0.043666f, 0.026442f, 0.029850f, // 1421
0.040440f, 0.029819f, 0.030985f, 0.042807f, 0.013823f, 0.000307f, 0.021925f, // 1428
0.001542f, 0.020714f, 0.023811f, 0.007065f, 0.000714f, 0.009400f, 0.008215f, // 1435
-0.034894f, -0.019740f, -0.025428f, -0.035594f, -0.031225f, -0.030061f, -0.052887f, // 1442
0.022201f, 0.023415f, 0.049119f, 0.037781f, 0.042614f, 0.070819f, 0.040360f, // 1449
0.004921f, 0.009108f, 0.006902f, 0.022927f, 0.023307f, 0.017298f, 0.025708f, // 1456
0.034716f, 0.011633f, -0.014804f, -0.011159f, -0.035313f, -0.028821f, -0.036267f, // 1463
-0.028180f, -0.033173f, 0.030899f, 0.020176f, 0.052070f, 0.037719f, 0.030274f, // 1470
0.065336f, 0.043504f, 0.003072f, -0.001961f, -0.002954f, 0.004074f, 0.009986f, // 1477
0.017269f, 0.033340f, 0.021340f, 0.005238f, -0.034881f, -0.018592f, -0.030074f, // 1484
-0.024008f, -0.036550f, -0.044829f, -0.027260f, 0.033863f, 0.004016f, 0.057853f, // 1491
0.020909f, 0.016592f, 0.055743f, 0.031006f, -0.003160f, -0.017573f, -0.012226f, // 1498
-0.004295f, 0.007531f, 0.013742f, 0.021393f, 0.001311f, -0.023935f, -0.042192f, // 1505
-0.020381f, -0.037379f, -0.030946f, -0.041420f, -0.035234f, -0.024281f, 0.046810f, // 1512
0.018889f, 0.053401f, 0.037855f, 0.018871f, 0.033814f, 0.008882f, 0.000516f, // 1519
-0.023774f, -0.033881f, -0.014264f, -0.021371f, -0.022111f, -0.008511f, -0.010157f, // 1526
-0.044985f, -0.041653f, -0.006544f, -0.000672f, -0.006229f, -0.028324f, -0.044599f, // 1533
-0.019839f, 0.051194f, 0.026944f, 0.064627f, 0.000286f, 0.014986f, 0.042467f, // 1540
0.011552f, -0.014521f, -0.025913f, -0.020306f, -0.015216f, -0.030319f, -0.031803f, // 1547
-0.032186f, -0.013910f, -0.042272f, -0.055116f, -0.021512f, -0.029680f, -0.039314f, // 1554
-0.070248f, -0.037884f, -0.016761f, 0.029264f, -0.015002f, 0.050598f, 0.031317f, // 1561
0.044614f, 0.060191f, -0.002369f, -0.014458f, -0.018184f, -0.018393f, -0.005383f, // 1568
-0.022938f, -0.040188f, -0.037663f, -0.024979f, -0.052809f, -0.052341f, -0.026714f, // 1575
-0.023907f, -0.056434f, -0.076886f, -0.047074f, -0.021632f, 0.013593f, 0.025120f, // 1582
0.048447f, 0.041318f, 0.035950f, 0.038258f, 0.007325f, -0.000044f, 0.009398f, // 1589
0.010516f, 0.018496f, 0.010895f, 0.002291f, 0.002414f, 0.005866f, 0.002113f, // 1596
-0.030446f, -0.027827f, -0.016851f, -0.015778f, -0.010057f, 0.002205f, 0.005803f, // 1603
-0.041824f, -0.034088f, -0.011245f, 0.036318f, 0.004751f, 0.046564f, 0.031302f, // 1610
0.026780f, 0.044818f, 0.021663f, 0.023944f, 0.049766f, 0.055201f, 0.041888f, // 1617
0.038533f, 0.014729f, 0.031647f, 0.035582f, 0.008697f, -0.023514f, -0.010751f, // 1624
0.000546f, 0.017015f, 0.010168f, 0.016414f, 0.032577f, 0.071485f, 0.069531f, // 1631
0.091355f, 0.074272f, 0.057384f, 0.085287f, 0.094896f, 0.082403f, 0.057839f, // 1638
0.080232f, 0.100757f, 0.072898f, 0.079517f, 0.055485f, 0.072572f, 0.086079f, // 1645
0.054964f, 0.038623f, 0.033650f, 0.015247f, 0.031118f, 0.056938f, 0.078955f, // 1652
0.054685f, 0.072614f, 0.104196f, 0.097416f, 0.069652f, 0.103232f, 0.121925f, // 1659
0.133726f, 0.107432f, 0.081140f, 0.096450f, 0.106358f, 0.093454f, 0.091745f, // 1666
0.091540f, 0.078469f, 0.062588f, 0.037086f, 0.030629f, 0.028280f, 0.029189f, // 1673
0.064575f, 0.068570f, 0.056217f, 0.034687f, 0.054215f, 0.078756f, 0.076195f, // 1680
0.100551f, 0.132338f, 0.107937f, 0.097227f, 0.096338f, 0.107048f, 0.103015f, // 1687
0.076325f, 0.035225f, 0.048573f, 0.072872f, 0.054340f, 0.039349f, 0.032588f, // 1694
0.044109f, 0.023060f, 0.032438f, 0.032288f, 0.015758f, 0.019030f, -0.000527f, // 1701
0.010887f, 0.008843f, 0.049612f, 0.044485f, 0.024928f, 0.025536f, 0.029415f, // 1708
0.035121f, 0.065531f, 0.032552f, -0.001534f, 0.009575f, 0.039034f, 0.066564f, // 1715
0.047611f, 0.029017f, 0.024234f, -0.002638f, -0.012463f, 0.000513f, 0.005402f, // 1722
0.011179f, 0.010222f, 0.008931f, -0.013317f, -0.016969f, -0.000027f, -0.000513f, // 1729
-0.006956f, -0.024970f, -0.011323f, 0.010771f, 0.002847f, 0.005386f, 0.003813f, // 1736
0.052123f, 0.064429f, 0.041007f, 0.023682f, 0.028599f, -0.040089f, -0.056265f, // 1743
-0.047727f, -0.023625f, -0.011894f, -0.024209f, -0.023032f, -0.048132f, -0.082480f, // 1750
-0.075723f, -0.072989f, -0.090578f, -0.100529f, -0.069239f, -0.046047f, -0.052196f, // 1757
-0.044043f, -0.033692f, -0.005733f, 0.010726f, 0.025753f, 0.039325f, 0.028059f, // 1764
-0.022644f, -0.013292f, -0.032972f, -0.022504f, -0.041995f, -0.065378f, -0.075261f, // 1771
-0.074025f, -0.081056f, -0.074778f, -0.047774f, -0.071484f, -0.085068f, -0.072132f, // 1778
-0.069948f, -0.039601f, -0.055928f, -0.049828f, -0.018935f, 0.008228f, 0.040793f, // 1785
0.053953f, 0.045607f, -0.025989f, -0.012609f, -0.011192f, -0.014400f, -0.036410f, // 1792
-0.083714f, -0.108654f, -0.088334f, -0.085738f, -0.067822f, -0.069326f, -0.082322f, // 1799
-0.103680f, -0.102683f, -0.091160f, -0.074144f, -0.048866f, -0.042114f, -0.023920f, // 1806
0.004845f, 0.050514f, 0.034779f, 0.032850f, -0.040255f, -0.006277f, -0.030225f, // 1813
-0.042729f, -0.057966f, -0.050558f, -0.067098f, -0.054863f, -0.063161f, -0.078146f, // 1820
-0.074171f, -0.075366f, -0.095768f, -0.116484f, -0.092605f, -0.059569f, -0.040386f, // 1827
-0.038493f, -0.037714f, 0.011803f, 0.043482f, 0.028583f, 0.026276f, -0.077103f, // 1834
-0.068553f, -0.095108f, -0.133627f, -0.089239f, -0.061506f, -0.049755f, -0.052685f, // 1841
-0.080900f, -0.107241f, -0.120836f, -0.132390f, -0.163475f, -0.156377f, -0.115491f, // 1848
-0.053749f, -0.040074f, -0.030617f, -0.056957f, -0.037411f, -0.038052f, -0.008884f, // 1855
0.017632f, -0.077473f, -0.073981f, -0.087736f, -0.103452f, -0.047856f, -0.064017f, // 1862
-0.085512f, -0.114463f, -0.139361f, -0.133176f, -0.122207f, -0.151441f, -0.154429f, // 1869
-0.142915f, -0.114352f, -0.063857f, -0.049561f, -0.041319f, -0.090717f, -0.094940f, // 1876
-0.075013f, -0.020845f, 0.004928f, -0.009253f, -0.015901f, 0.003621f, -0.034532f, // 1883
-0.005492f, -0.024729f, -0.047933f, -0.047768f, -0.051753f, -0.050116f, -0.037155f, // 1890
-0.056730f, -0.059511f, -0.034007f, -0.031284f, -0.010560f, -0.004824f, -0.004852f, // 1897
-0.045006f, -0.030292f, -0.021231f, -0.024137f, 0.005163f, 0.034513f, -0.004585f, // 1904
0.000132f, -0.014145f, -0.009202f, -0.040335f, -0.034014f, -0.016634f, -0.014454f, // 1911
-0.022647f, -0.016167f, -0.023088f, -0.032279f, -0.037198f, -0.051791f, -0.043051f, // 1918
-0.041882f, -0.038399f, -0.039517f, -0.000436f, -0.002330f, 0.005871f, 0.011974f, // 1925
0.119722f, 0.079009f, 0.097197f, 0.074042f, 0.047292f, 0.083014f, 0.112511f, // 1932
0.162507f, 0.177560f, 0.193920f, 0.135610f, 0.140658f, 0.135183f, 0.082767f, // 1939
0.119944f, 0.107907f, 0.073154f, 0.087777f, 0.111612f, 0.092320f, 0.105273f, // 1946
0.118606f, 0.148013f, 0.250438f, 0.195796f, 0.212594f, 0.158086f, 0.045938f, // 1953
0.027222f, 0.156525f, 0.152776f, 0.180144f, 0.229533f, 0.250776f, 0.229320f, // 1960
0.155087f, 0.108335f, 0.106129f, 0.073720f, -0.009943f, 0.037600f, 0.133423f, // 1967
0.226329f, 0.268987f, 0.289545f, 0.238566f, 0.233488f, 0.155549f, 0.196618f, // 1974
0.138130f, -0.009169f, -0.008483f, 0.073776f, 0.081170f, 0.079868f, 0.053094f, // 1981
0.061925f, 0.034654f, 0.032238f, 0.079596f, 0.036187f, -0.001239f, -0.080673f, // 1988
-0.038169f, 0.138359f, 0.152236f, 0.175284f, 0.102324f, 0.101283f, 0.236146f, // 1995
0.182766f, 0.185284f, 0.134154f, 0.033367f, 0.011424f, -0.088146f, 0.002090f, // 2002
-0.068685f, -0.066260f, -0.059461f, -0.125758f, -0.133177f, -0.037509f, 0.044293f, // 2009
-0.032909f, -0.019120f, 0.006526f, 0.182667f, 0.154137f, 0.258518f, 0.154144f, // 2016
0.116876f, 0.280936f, 0.174286f, 0.182966f, 0.119408f, 0.036114f, 0.039276f, // 2023
0.087325f, 0.115877f, 0.019196f, -0.036122f, 0.030973f, -0.062713f, -0.093104f, // 2030
0.013045f, 0.109092f, 0.079624f, 0.018831f, 0.046046f, 0.219230f, 0.210461f, // 2037
0.280469f, 0.195191f, 0.159294f, 0.237788f, 0.130484f, 0.177513f, 0.146396f, // 2044
0.059571f, -0.004620f, -0.000577f, 0.136297f, 0.031760f, 0.018238f, 0.064219f, // 2051
-0.026393f, -0.015190f, 0.009162f, 0.066950f, 0.082036f, 0.036990f, 0.077936f, // 2058
0.219654f, 0.220016f, 0.314613f, 0.227666f, 0.186890f, 0.222637f, 0.199628f, // 2065
0.226324f, 0.189472f, 0.075798f, 0.026633f, 0.056811f, 0.205824f, 0.167940f, // 2072
0.198592f, 0.228873f, 0.200999f, 0.160862f, 0.120459f, 0.099973f, 0.065315f, // 2079
0.038808f, 0.088003f, 0.165255f, 0.223013f, 0.283938f, 0.250484f, 0.216923f, // 2086
0.223012f, 0.248304f, 0.243223f, 0.206374f, 0.152830f, 0.066531f, 0.095340f, // 2093
0.176009f, 0.188766f, 0.180258f, 0.283652f, 0.213083f, 0.170498f, 0.149754f, // 2100
0.020821f, 0.003532f, 0.003231f, 0.111172f, 0.154410f, 0.177076f, 0.209420f, // 2107
0.216046f, 0.210394f, 0.217013f, 0.295864f, 0.299013f, 0.263345f, 0.184105f, // 2114
0.119748f, 0.150799f, 0.224299f, 0.204513f, 0.149952f, 0.178544f, 0.179470f, // 2121
0.163335f, 0.150342f, 0.020393f, 0.039888f, 0.088003f, 0.109997f, 0.157673f, // 2128
0.262734f, 0.290649f, 0.211265f, 0.181909f, 0.252908f, 0.338750f, 0.347723f, // 2135
0.349060f, 0.314662f, 0.288612f, 0.258172f, 0.290625f, 0.280393f, 0.229062f, // 2142
0.202864f, 0.231375f, 0.264100f, 0.270690f, 0.143310f, 0.136918f, 0.145697f, // 2149
0.174186f, 0.192687f, 0.364949f, 0.348774f, 0.215807f, 0.178168f, 0.229702f, // 2156
0.362279f, 0.470333f, 0.463981f, 0.424183f, 0.314745f, 0.293940f, 0.278256f, // 2163
0.270770f, 0.207351f, 0.188076f, 0.195365f, 0.349697f, 0.341203f, 0.235811f, // 2170
0.204571f, 0.261352f, 0.231196f, 0.253680f, 0.288101f, 0.291522f, 0.249600f, // 2177
0.160475f, 0.208970f, 0.417598f, 0.478949f, 0.515625f, 0.432451f, 0.341173f, // 2184
0.280338f, 0.328822f, 0.322461f, 0.230304f, 0.198335f, 0.179636f, 0.252946f, // 2191
0.293124f, 0.205450f, 0.212526f, 0.300789f, 0.286095f, 0.316160f, 0.377643f, // 2198
0.312992f, 0.218802f, 0.149153f, 0.226919f, 0.380978f, 0.459646f, 0.469121f, // 2205
0.372922f, 0.235972f, 0.220041f, 0.245871f, 0.272674f, 0.271700f, 0.231085f, // 2212
0.216845f, 0.242687f, 0.206954f, 0.202535f, 0.163078f, 0.211895f, 0.241670f, // 2219
0.329566f, 0.398991f, 0.356196f, 0.322104f, 0.192358f, 0.240994f, 0.267539f, // 2226
0.326540f, 0.278926f, 0.214898f, 0.202313f, 0.200417f, 0.185766f, 0.183689f, // 2233
0.186648f, 0.201236f, 0.177350f, 0.203436f, 0.221901f, 0.212690f, 0.248312f, // 2240
0.254036f, 0.238009f, 0.312868f, 0.379792f, 0.340208f, 0.297162f, 0.214939f, // 2247
0.168988f, 0.075483f, 0.137491f, -0.013323f, 0.027066f, 0.046307f, 0.027557f, // 2254
0.046435f, 0.006914f, 0.027060f, -0.032590f, -0.051559f, -0.042861f, 0.038779f, // 2261
0.077656f, 0.088528f, 0.103835f, 0.044518f, 0.144122f, 0.134978f, 0.124576f, // 2268
0.136028f, 0.182486f, 0.058421f, 0.103736f, 0.100331f, 0.007617f, 0.002944f, // 2275
-0.003940f, -0.137155f, -0.054706f, -0.116403f, -0.096245f, -0.112314f, -0.137810f, // 2282
-0.169771f, -0.168262f, -0.072157f, 0.006619f, 0.033578f, 0.005207f, -0.031467f, // 2289
-0.039413f, 0.075499f, 0.099356f, 0.185701f, 0.054096f, 0.122285f, 0.001929f, // 2296
-0.041648f, -0.015983f, 0.056005f, -0.082585f, 0.036579f, 0.053212f, -0.071947f, // 2303
-0.135256f, -0.130155f, -0.220498f, -0.090348f, -0.112699f, -0.080230f, -0.043370f, // 2310
-0.094595f, -0.116057f, -0.089630f, -0.016801f, 0.117467f, 0.124437f, 0.072151f, // 2317
0.193955f, 0.098700f, 0.064950f, -0.003357f, 0.069806f, -0.109150f, -0.025573f, // 2324
-0.092556f, -0.085319f, -0.033452f, -0.039952f, -0.132309f, -0.036938f, -0.139527f, // 2331
-0.143289f, -0.002869f, -0.039984f, 0.008921f, 0.005922f, 0.045306f, 0.152522f, // 2338
0.197067f, 0.050339f, 0.148841f, 0.095803f, 0.130483f, 0.147903f, 0.232958f, // 2345
0.181048f, 0.134383f, 0.218372f, 0.087328f, 0.187677f, 0.078966f, 0.049936f, // 2352
0.106049f, 0.062633f, 0.120823f, 0.199561f, 0.216846f, 0.214755f, 0.141739f, // 2359
0.135044f, 0.187510f, 0.184381f, 0.038957f, 0.168689f, 0.149776f, 0.111993f, // 2366
0.158568f, 0.220735f, 0.188137f, 0.235439f, 0.281723f, 0.197196f, 0.184571f, // 2373
0.102708f, 0.163074f, 0.173436f, 0.166741f, 0.184133f, 0.228761f, 0.244548f, // 2380
0.210882f, 0.200125f, 0.200838f, 0.143378f, 0.173979f, 0.093603f, 0.226595f, // 2387
0.216626f, 0.133445f, 0.183862f, 0.290135f, 0.279982f, 0.324568f, 0.397417f, // 2394
0.364083f, 0.351836f, 0.327856f, 0.366158f, 0.349838f, 0.330250f, 0.424361f, // 2401
0.370749f, 0.326996f, 0.268146f, 0.271745f, 0.266228f, 0.179449f, 0.145582f, // 2408
0.102467f, 0.177866f, 0.211526f, 0.185547f, 0.254440f, 0.272250f, 0.294443f, // 2415
0.320825f, 0.291126f, 0.317356f, 0.226969f, 0.275155f, 0.298985f, 0.304054f, // 2422
0.381104f, 0.352196f, 0.323959f, 0.290877f, 0.242711f, 0.224428f, 0.243956f, // 2429
0.194240f, 0.181582f, 0.079074f, 0.077949f, 0.140363f, 0.112901f, 0.207900f, // 2436
0.313306f, 0.271744f, 0.261829f, 0.241715f, 0.210132f, 0.236269f, 0.242135f, // 2443
0.296553f, 0.230798f, 0.209570f, 0.179743f, 0.250123f, 0.236024f, 0.227046f, // 2450
0.213157f, 0.209485f, 0.209745f, 0.230979f, 0.058679f, -0.029220f, 0.131723f, // 2457
0.117561f, 0.195793f, 0.145148f, 0.174032f, 0.197321f, 0.236648f, 0.186005f, // 2464
0.241231f, 0.180437f, 0.259089f, 0.260738f, 0.233661f, 0.165026f, 0.163594f, // 2471
0.182819f, 0.223444f, 0.246953f, 0.277081f, 0.216533f, 0.270458f, 0.027309f, // 2478
0.015617f, 0.012773f, -0.051878f, 0.046572f, 0.037660f, 0.137519f, 0.011847f, // 2485
0.109705f, 0.023098f, 0.127948f, 0.084110f, 0.102523f, 0.068573f, 0.215375f, // 2492
0.185426f, 0.140182f, 0.145173f, 0.227987f, 0.232163f, 0.229962f, 0.166218f, // 2499
0.181050f, -0.032786f, 0.032529f, -0.158210f, -0.058670f, -0.011325f, 0.071807f, // 2506
0.076573f, 0.043177f, 0.121752f, -0.003731f, 0.007584f, 0.071916f, 0.064050f, // 2513
0.082794f, 0.091729f, 0.145773f, 0.158357f, 0.201711f, 0.192817f, 0.015928f, // 2520
0.222231f, 0.067342f, 0.165118f, -0.135748f, 0.007793f, -0.401776f, -0.364071f, // 2527
-0.277087f, -0.046857f, 0.047448f, 0.033099f, 0.021888f, -0.006186f, 0.015907f, // 2534
0.024357f, 0.077199f, 0.026185f, -0.005116f, 0.011366f, 0.112751f, 0.137686f, // 2541
0.055317f, -0.003093f, 0.104289f, 0.046044f, 0.155585f, -0.084790f, 0.034275f, // 2548
-0.032073f, -0.020377f, 0.023344f, 0.141420f, 0.087680f, 0.046022f, 0.006404f, // 2555
0.035936f, 0.032827f, 0.057920f, 0.113860f, 0.112517f, 0.072537f, 0.102991f, // 2562
0.068501f, 0.077130f, 0.005264f, -0.068067f, 0.051766f, -0.011582f, 0.139526f, // 2569
0.002822f, 0.011972f, 0.024218f, 0.008080f, 0.011003f, 0.006771f, -0.002085f, // 2576
-0.004606f, 0.002329f, 0.006908f, 0.000618f, -0.000992f, -0.003687f, 0.000135f, // 2583
-0.004835f, -0.002220f, -0.005093f, 0.001404f, -0.001982f, -0.002363f, 0.003339f, // 2590
-0.005351f, 0.002403f, -0.000942f, 0.017111f, 0.034521f, 0.014174f, 0.019100f, // 2597
0.034299f, 0.012059f, 0.003887f, -0.002053f, 0.007250f, 0.007531f, 0.012015f, // 2604
0.009481f, 0.011690f, 0.023204f, 0.007264f, -0.001776f, -0.004733f, -0.014367f, // 2611
-0.013991f, 0.003022f, 0.004641f, -0.001126f, -0.005676f, 0.016540f, 0.039741f, // 2618
0.016092f, 0.019438f, 0.041153f, 0.013521f, 0.013440f, 0.011387f, 0.002629f, // 2625
0.006321f, 0.012109f, 0.011004f, 0.022735f, 0.020102f, 0.012356f, 0.001887f, // 2632
0.003495f, -0.000976f, -0.002485f, -0.001101f, -0.005917f, -0.009240f, -0.003618f, // 2639
0.014635f, 0.030081f, 0.015922f, 0.020008f, 0.010871f, 0.015689f, 0.014985f, // 2646
0.016246f, 0.007609f, 0.008106f, 0.013674f, 0.012618f, 0.007103f, 0.006881f, // 2653
0.010042f, 0.004851f, 0.002601f, -0.002222f, -0.001085f, -0.008182f, -0.009828f, // 2660
0.002413f, -0.002715f, 0.009320f, 0.025811f, 0.013960f, 0.020098f, 0.013074f, // 2667
0.014843f, 0.015989f, 0.019222f, 0.004184f, 0.009977f, 0.017392f, 0.019421f, // 2674
0.003342f, 0.006897f, 0.005693f, 0.001780f, -0.002166f, 0.000416f, -0.001669f, // 2681
-0.001878f, -0.002559f, -0.012925f, -0.002119f, 0.011083f, 0.030347f, 0.018095f, // 2688
0.024156f, 0.021654f, 0.013349f, 0.017280f, 0.008996f, 0.002862f, 0.013207f, // 2695
0.011954f, 0.008609f, 0.010730f, 0.011958f, 0.011682f, 0.006014f, 0.001062f, // 2702
-0.001207f, -0.010114f, -0.007638f, 0.002474f, -0.014887f, 0.009907f, 0.017143f, // 2709
0.019452f, 0.016717f, 0.018685f, 0.024499f, 0.014535f, 0.013731f, 0.020021f, // 2716
0.005154f, 0.011891f, 0.010367f, 0.002067f, 0.003820f, 0.012534f, 0.014007f, // 2723
-0.013467f, -0.003576f, -0.006550f, -0.016433f, -0.009590f, -0.000980f, -0.014643f, // 2730
0.012131f, 0.020247f, 0.020300f, 0.022583f, 0.022708f, 0.032465f, 0.026466f, // 2737
0.016041f, 0.012956f, 0.010740f, 0.011706f, 0.009725f, 0.004785f, 0.008323f, // 2744
0.015633f, 0.004689f, -0.015205f, -0.003509f, -0.020792f, -0.021087f, -0.016453f, // 2751
0.000478f, -0.007731f, 0.010905f, 0.020543f, 0.022810f, 0.017557f, 0.013039f, // 2758
0.027331f, 0.028090f, 0.015165f, 0.010528f, 0.008765f, 0.010347f, 0.014413f, // 2765
0.013129f, 0.015399f, 0.010046f, 0.000875f, -0.021661f, -0.006762f, -0.011236f, // 2772
-0.012999f, -0.020136f, -0.022595f, -0.015086f, 0.002820f, 0.011853f, 0.021986f, // 2779
0.013058f, 0.009882f, 0.023303f, 0.015659f, 0.007591f, 0.003154f, 0.003895f, // 2786
0.008133f, 0.013473f, 0.014047f, 0.015394f, 0.003573f, -0.011506f, -0.023814f, // 2793
-0.007280f, -0.012854f, -0.012695f, -0.022016f, -0.022857f, -0.018257f, 0.009351f, // 2800
0.010997f, 0.016316f, 0.010864f, 0.008676f, 0.013524f, 0.004054f, 0.002415f, // 2807
-0.003902f, -0.005367f, 0.001309f, 0.003855f, 0.004459f, 0.007952f, -0.001455f, // 2814
-0.020551f, -0.023346f, 0.001797f, 0.000378f, -0.005820f, -0.022522f, -0.022606f, // 2821
-0.016123f, 0.007945f, 0.012484f, 0.019555f, -0.001199f, 0.009670f, 0.011290f, // 2828
0.006245f, -0.006456f, -0.005674f, -0.004958f, -0.005367f, -0.007662f, -0.007844f, // 2835
-0.004134f, -0.006205f, -0.025990f, -0.029700f, -0.004226f, -0.013172f, -0.020080f, // 2842
-0.029711f, -0.015673f, -0.020170f, 0.024104f, 0.003819f, 0.021457f, 0.010357f, // 2849
0.013991f, 0.020734f, -0.005748f, -0.009922f, -0.007390f, -0.007838f, -0.001615f, // 2856
-0.008779f, -0.014847f, -0.016337f, -0.013519f, -0.030606f, -0.033341f, -0.013263f, // 2863
-0.005256f, -0.011326f, -0.027207f, -0.004904f, -0.013872f, 0.028216f, 0.011627f, // 2870
0.018872f, 0.016074f, 0.014523f, 0.018149f, 0.010932f, 0.002211f, 0.003726f, // 2877
0.005155f, 0.008039f, 0.007343f, -0.000874f, 0.002294f, 0.003610f, -0.007051f, // 2884
-0.021447f, -0.014224f, -0.004341f, -0.007222f, -0.002262f, 0.006502f, -0.002201f, // 2891
0.039733f, 0.042427f, 0.047390f, 0.060365f, 0.069887f, 0.084997f, 0.082978f, // 2898
0.088060f, 0.068982f, 0.065751f, 0.063736f, 0.066327f, 0.058659f, 0.066179f, // 2905
0.042328f, 0.032852f, 0.053637f, 0.076814f, 0.070958f, 0.070494f, 0.054000f, // 2912
0.029927f, 0.033871f, 0.009655f, 0.013499f, 0.019124f, 0.039397f, 0.049637f, // 2919
0.105702f, 0.067744f, 0.068712f, 0.067453f, 0.073604f, 0.065911f, 0.057991f, // 2926
0.097669f, 0.116460f, 0.102196f, 0.075410f, 0.073794f, 0.085003f, 0.087272f, // 2933
0.074692f, 0.055074f, 0.006075f, 0.009025f, 0.013101f, 0.023109f, 0.054618f, // 2940
0.051496f, 0.096151f, 0.144047f, 0.114857f, 0.073085f, 0.063913f, 0.071050f, // 2947
0.051349f, 0.056873f, 0.098454f, 0.102405f, 0.105855f, 0.120059f, 0.119323f, // 2954
0.116392f, 0.085445f, 0.094110f, 0.086348f, 0.024266f, 0.040555f, 0.028607f, // 2961
0.030826f, 0.047375f, 0.053274f, 0.084990f, 0.090403f, 0.118718f, 0.103650f, // 2968
0.069808f, 0.069789f, 0.056989f, 0.084194f, 0.096246f, 0.088510f, 0.115625f, // 2975
0.090641f, 0.058930f, 0.071147f, 0.069601f, 0.087492f, 0.069734f, 0.040771f, // 2982
0.035694f, 0.023428f, 0.028568f, 0.041798f, 0.023255f, 0.020312f, 0.033196f, // 2989
0.043043f, 0.015438f, 0.026800f, 0.047021f, 0.029804f, 0.031959f, 0.039248f, // 2996
0.042458f, 0.065109f, 0.033647f, 0.036129f, 0.042083f, 0.039980f, 0.071016f, // 3003
0.074652f, 0.034652f, 0.033865f, 0.009475f, 0.017826f, 0.023258f, 0.015825f, // 3010
0.005028f, 0.022996f, 0.014911f, -0.020739f, -0.031007f, 0.011727f, 0.017130f, // 3017
0.020006f, 0.005976f, 0.004584f, 0.023757f, 0.030810f, 0.028339f, 0.032423f, // 3024
0.051293f, 0.066585f, 0.071716f, 0.045519f, 0.046962f, -0.017847f, -0.000337f, // 3031
0.010268f, 0.000310f, 0.006902f, -0.002860f, -0.010155f, -0.037797f, -0.056937f, // 3038
-0.035047f, -0.033442f, -0.037389f, -0.061948f, -0.039956f, -0.032169f, -0.030401f, // 3045
0.013615f, 0.008578f, 0.027782f, 0.042452f, 0.051049f, 0.050166f, 0.052389f, // 3052
-0.015026f, 0.008960f, 0.015770f, 0.014185f, 0.002877f, -0.011470f, -0.020162f, // 3059
-0.044136f, -0.048159f, -0.030836f, -0.008373f, -0.019923f, -0.039367f, -0.048234f, // 3066
-0.032612f, -0.017321f, 0.018715f, 0.002839f, 0.022975f, 0.037508f, 0.066883f, // 3073
0.079388f, 0.065567f, -0.007894f, 0.002225f, 0.011949f, 0.008424f, -0.002344f, // 3080
-0.019864f, -0.022848f, -0.032826f, -0.038039f, -0.019157f, -0.006446f, -0.013423f, // 3087
-0.035719f, -0.040740f, -0.038951f, -0.023380f, 0.004077f, 0.006531f, 0.019328f, // 3094
0.041495f, 0.062148f, 0.057392f, 0.054150f, -0.012495f, 0.012249f, 0.006212f, // 3101
-0.040332f, -0.039139f, -0.012939f, -0.006079f, -0.000444f, -0.002877f, -0.004120f, // 3108
-0.004851f, -0.021016f, -0.032159f, -0.046799f, -0.050207f, -0.024352f, 0.005713f, // 3115
0.001358f, 0.024413f, 0.056109f, 0.077478f, 0.048099f, 0.047190f, -0.026441f, // 3122
-0.036199f, -0.087966f, -0.154669f, -0.111883f, -0.045959f, -0.007553f, -0.002951f, // 3129
-0.021660f, -0.053575f, -0.036414f, -0.032560f, -0.057548f, -0.076442f, -0.084221f, // 3136
-0.030275f, -0.008607f, -0.005508f, 0.001616f, 0.008187f, -0.024009f, 0.005582f, // 3143
0.018375f, -0.026358f, -0.069976f, -0.076044f, -0.170597f, -0.114789f, -0.061217f, // 3150
-0.036887f, -0.050787f, -0.067032f, -0.074624f, -0.052935f, -0.057416f, -0.059174f, // 3157
-0.072636f, -0.074192f, -0.045519f, -0.028995f, -0.010238f, -0.043386f, -0.042052f, // 3164
-0.026283f, -0.010485f, 0.011098f, 0.022175f, -0.018130f, 0.008236f, -0.028234f, // 3171
-0.005514f, 0.021937f, 0.002810f, 0.007816f, 0.010973f, 0.018400f, 0.027272f, // 3178
0.016529f, 0.010552f, -0.003928f, -0.009412f, 0.015868f, 0.020892f, 0.018947f, // 3185
-0.006970f, 0.006552f, -0.011270f, -0.004614f, 0.026715f, 0.054163f, -0.004951f, // 3192
0.002645f, 0.009919f, 0.011338f, -0.016686f, -0.024227f, 0.003366f, 0.012734f, // 3199
0.006705f, 0.005506f, -0.003990f, 0.003559f, -0.005788f, -0.029526f, -0.027136f, // 3206
-0.029656f, -0.020004f, -0.024753f, -0.011806f, -0.006911f, -0.002998f, 0.021219f, // 3213
0.109005f, 0.106865f, 0.091978f, 0.120566f, 0.117052f, 0.141935f, 0.149409f, // 3220
0.186340f, 0.189079f, 0.176395f, 0.180904f, 0.208529f, 0.204504f, 0.156092f, // 3227
0.160398f, 0.160951f, 0.173664f, 0.153565f, 0.120708f, 0.115699f, 0.136442f, // 3234
0.148456f, 0.119530f, 0.144742f, 0.092920f, 0.135775f, 0.110256f, 0.094273f, // 3241
0.186666f, 0.173663f, 0.144846f, 0.147189f, 0.150508f, 0.176634f, 0.206996f, // 3248
0.208211f, 0.177411f, 0.186818f, 0.137039f, 0.131845f, 0.131928f, 0.153660f, // 3255
0.183466f, 0.145293f, 0.141161f, 0.126341f, 0.227973f, 0.133603f, 0.186364f, // 3262
0.082640f, 0.053256f, 0.095490f, 0.084728f, 0.078202f, 0.098662f, 0.084628f, // 3269
0.113506f, 0.114723f, 0.102363f, 0.112965f, 0.107500f, 0.147786f, 0.130345f, // 3276
0.147842f, 0.134471f, 0.091598f, 0.123216f, 0.099278f, 0.097915f, 0.234070f, // 3283
0.163395f, 0.149218f, 0.079320f, 0.057774f, 0.099048f, 0.060600f, 0.018848f, // 3290
-0.019622f, -0.012247f, -0.024586f, -0.033790f, 0.008236f, -0.004459f, 0.041825f, // 3297
0.132953f, 0.144734f, 0.142937f, 0.130808f, 0.117590f, 0.180985f, 0.113737f, // 3304
0.116645f, 0.249856f, 0.199283f, 0.181427f, 0.168637f, 0.135684f, 0.102652f, // 3311
0.037856f, 0.032904f, 0.078855f, 0.102629f, 0.017953f, 0.057880f, 0.032984f, // 3318
0.064285f, 0.072805f, 0.132344f, 0.193039f, 0.173977f, 0.149985f, 0.130792f, // 3325
0.179156f, 0.113826f, 0.130744f, 0.261207f, 0.234966f, 0.205940f, 0.179212f, // 3332
0.102046f, 0.090793f, -0.007453f, 0.028337f, 0.032225f, 0.120294f, 0.062525f, // 3339
0.118488f, 0.098317f, 0.091824f, 0.160686f, 0.136047f, 0.169434f, 0.149866f, // 3346
0.175720f, 0.144359f, 0.169720f, 0.122157f, 0.134744f, 0.231920f, 0.213865f, // 3353
0.177875f, 0.135137f, 0.132891f, 0.077558f, 0.035193f, 0.076003f, 0.110773f, // 3360
0.126510f, 0.143603f, 0.156597f, 0.156578f, 0.084253f, 0.100464f, 0.074625f, // 3367
0.165584f, 0.105165f, 0.145461f, 0.132076f, 0.133954f, 0.123083f, 0.118163f, // 3374
0.188630f, 0.232303f, 0.179004f, 0.129105f, 0.109488f, 0.066113f, -0.013415f, // 3381
-0.005128f, 0.058006f, 0.106562f, 0.108173f, 0.118587f, 0.145212f, 0.121442f, // 3388
0.096703f, 0.152205f, 0.167378f, 0.125127f, 0.115078f, 0.105583f, 0.081856f, // 3395
0.095146f, 0.108988f, 0.213368f, 0.237138f, 0.172423f, 0.111151f, 0.088443f, // 3402
0.056528f, 0.015418f, -0.014268f, 0.026113f, 0.031659f, 0.019632f, 0.028697f, // 3409
0.121086f, 0.121853f, 0.106029f, 0.141212f, 0.178101f, 0.092004f, 0.113862f, // 3416
0.110405f, 0.074929f, 0.089216f, 0.066010f, 0.251685f, 0.249558f, 0.214431f, // 3423
0.160381f, 0.108447f, 0.096394f, 0.023006f, -0.032251f, 0.013392f, 0.031796f, // 3430
0.055117f, 0.084327f, 0.089998f, 0.068383f, 0.115409f, 0.140678f, 0.154284f, // 3437
0.072998f, 0.114975f, 0.142331f, 0.130279f, 0.076557f, 0.057496f, 0.305573f, // 3444
0.278785f, 0.247414f, 0.271168f, 0.176776f, 0.101552f, 0.025238f, 0.021185f, // 3451
0.023215f, 0.031566f, 0.034549f, 0.026407f, 0.046114f, 0.032349f, 0.098089f, // 3458
0.119092f, 0.121067f, 0.059530f, 0.086432f, 0.133839f, 0.155893f, 0.135571f, // 3465
0.091584f, 0.274997f, 0.187996f, 0.243714f, 0.217891f, 0.153973f, 0.056406f, // 3472
0.012954f, 0.060549f, 0.065393f, 0.025186f, 0.068086f, 0.060029f, 0.062248f, // 3479
0.050514f, 0.082166f, 0.100209f, 0.100110f, 0.071024f, 0.096730f, 0.166405f, // 3486
0.177301f, 0.125234f, 0.097774f, 0.242389f, 0.127648f, 0.238199f, 0.198376f, // 3493
0.111494f, 0.046898f, -0.004256f, 0.029662f, 0.003917f, -0.000846f, -0.009887f, // 3500
0.000699f, 0.012580f, -0.000125f, 0.039484f, 0.064069f, 0.049031f, 0.084714f, // 3507
0.118342f, 0.138608f, 0.162275f, 0.160589f, 0.136281f, 0.151379f, 0.032640f, // 3514
0.066267f, 0.078087f, 0.043641f, -0.005397f, -0.041410f, -0.021724f, -0.011584f, // 3521
-0.027137f, -0.027561f, -0.027771f, -0.007828f, -0.023383f, 0.024445f, 0.049548f, // 3528
0.072715f, 0.078826f, 0.086087f, 0.099180f, 0.063818f, 0.069459f, 0.058547f, // 3535
0.245152f, 0.158754f, 0.217333f, 0.218660f, 0.267419f, 0.228339f, 0.195091f, // 3542
0.193957f, 0.184253f, 0.138375f, 0.123930f, 0.154431f, 0.181967f, 0.218473f, // 3549
0.192653f, 0.273213f, 0.317503f, 0.266587f, 0.225559f, 0.226010f, 0.182112f, // 3556
0.225721f, 0.284060f, 0.178790f, 0.177889f, 0.240024f, 0.180659f, 0.143747f, // 3563
0.164681f, 0.119379f, 0.073173f, 0.057369f, 0.110027f, 0.129450f, 0.150763f, // 3570
0.150070f, 0.103139f, 0.166911f, 0.138369f, 0.138695f, 0.124973f, 0.105105f, // 3577
0.118166f, 0.167145f, 0.273487f, 0.209847f, 0.271785f, 0.201331f, 0.219201f, // 3584
0.054209f, 0.021508f, -0.035713f, -0.137640f, -0.057625f, 0.008274f, -0.006950f, // 3591
-0.034098f, -0.013427f, -0.045169f, 0.034352f, -0.029682f, -0.040122f, 0.151291f, // 3598
0.235306f, 0.105740f, -0.033169f, 0.083844f, 0.204328f, 0.085156f, 0.254591f, // 3605
0.236529f, 0.215594f, 0.139761f, 0.136618f, 0.083496f, -0.152864f, -0.185588f, // 3612
-0.228211f, -0.150053f, -0.151032f, -0.171323f, -0.210993f, -0.172013f, -0.240273f, // 3619
-0.050606f, 0.190171f, 0.203287f, 0.187481f, 0.112481f, 0.215825f, 0.300873f, // 3626
0.241803f, 0.237235f, 0.246005f, 0.232519f, 0.259176f, 0.293419f, 0.197147f, // 3633
0.083853f, 0.020454f, 0.056778f, 0.018090f, -0.006428f, 0.010953f, -0.004926f, // 3640
0.051211f, -0.043188f, 0.189163f, 0.325156f, 0.368504f, 0.311948f, 0.193230f, // 3647
0.250035f, 0.246238f, 0.259305f, 0.312786f, 0.310996f, 0.322413f, 0.300052f, // 3654
0.230338f, 0.209959f, 0.153254f, 0.159151f, 0.133873f, 0.175019f, 0.105930f, // 3661
0.186737f, 0.173535f, 0.217648f, 0.252636f, 0.290355f, 0.321177f, 0.318479f, // 3668
0.344888f, 0.228567f, 0.270415f, 0.215148f, 0.270847f, 0.305141f, 0.365900f, // 3675
0.308112f, 0.227040f, 0.228101f, 0.223394f, 0.203788f, 0.207201f, 0.291987f, // 3682
0.274024f, 0.270051f, 0.304859f, 0.347503f, 0.292374f, 0.286313f, 0.267217f, // 3689
0.310676f, 0.247311f, 0.309889f, 0.237060f, 0.262047f, 0.242063f, 0.223889f, // 3696
0.291870f, 0.395437f, 0.297918f, 0.204456f, 0.203400f, 0.192781f, 0.144161f, // 3703
0.121551f, 0.208826f, 0.227804f, 0.201439f, 0.259836f, 0.320152f, 0.310671f, // 3710
0.283652f, 0.333463f, 0.269915f, 0.244959f, 0.239070f, 0.210885f, 0.171036f, // 3717
0.173389f, 0.188831f, 0.324955f, 0.315620f, 0.236420f, 0.190612f, 0.213808f, // 3724
0.214450f, 0.196386f, 0.119472f, 0.165946f, 0.095399f, 0.051239f, 0.057450f, // 3731
0.235915f, 0.252979f, 0.258681f, 0.259274f, 0.271642f, 0.175887f, 0.211933f, // 3738
0.180851f, 0.123151f, 0.146979f, 0.163261f, 0.333212f, 0.323261f, 0.297288f, // 3745
0.124802f, 0.107332f, 0.181706f, 0.130436f, 0.055886f, 0.137429f, 0.103173f, // 3752
0.110160f, 0.076455f, 0.187446f, 0.152868f, 0.221770f, 0.188366f, 0.201639f, // 3759
0.145076f, 0.192908f, 0.143999f, 0.053816f, 0.123592f, 0.192842f, 0.385143f, // 3766
0.286726f, -0.003954f, -0.135338f, -0.031372f, 0.096423f, 0.086575f, 0.009308f, // 3773
0.011394f, -0.058211f, -0.016067f, -0.024576f, 0.030963f, -0.080570f, 0.107949f, // 3780
0.169365f, 0.169222f, 0.119048f, 0.164285f, 0.165260f, -0.014056f, 0.083290f, // 3787
0.172598f, 0.305063f, 0.039427f, 0.043245f, -0.132040f, -0.140885f, -0.073031f, // 3794
0.008946f, 0.019818f, -0.021927f, -0.214720f, -0.145657f, -0.104600f, -0.105561f, // 3801
-0.118268f, -0.064883f, 0.048887f, 0.084032f, 0.149059f, 0.089763f, 0.018107f, // 3808
-0.036151f, -0.033204f, 0.144187f, 0.241055f, 0.028045f, 0.066403f, -0.098549f, // 3815
-0.025877f, 0.085052f, 0.027677f, 0.040894f, 0.007636f, -0.029335f, -0.027705f, // 3822
0.004384f, 0.053774f, -0.044745f, -0.014069f, 0.053364f, 0.089695f, 0.172724f, // 3829
0.132166f, -0.028183f, -0.001225f, 0.020515f, 0.197632f, 0.120091f, 0.055275f, // 3836
0.042666f, 0.086284f, 0.052052f, 0.062404f, 0.059801f, 0.107340f, 0.129334f, // 3843
0.066387f, 0.061865f, 0.026709f, 0.066980f, 0.102115f, 0.107088f, 0.112706f, // 3850
0.073490f, 0.103950f, 0.071484f, 0.013227f, 0.072680f, 0.042213f, 0.077444f, // 3857
-0.013196f, 0.071211f, 0.088418f, 0.046324f, 0.039306f, -0.020308f, -0.033731f, // 3864
-0.024333f, 0.003010f, 0.012418f, 0.001275f, -0.021599f, -0.025403f, 0.010886f, // 3871
-0.009997f, -0.013837f, -0.026115f, -0.024082f, -0.056683f, -0.057119f, -0.036591f, // 3878
0.011927f, 0.004780f, -0.052508f, 0.061259f, 0.086196f, 0.064343f, 0.060228f, // 3885
-0.063059f, -0.062821f, -0.076759f, -0.022234f, -0.003869f, -0.011511f, -0.028718f, // 3892
-0.037983f, -0.010889f, -0.032479f, -0.019812f, -0.044535f, -0.079195f, -0.134381f, // 3899
-0.119370f, -0.036190f, 0.045518f, 0.057585f, -0.046809f, 0.087504f, 0.134680f, // 3906
0.098924f, 0.088500f, -0.012968f, -0.027574f, -0.013046f, 0.030041f, 0.004851f, // 3913
0.021522f, 0.009811f, 0.001189f, 0.024244f, 0.017766f, 0.034502f, -0.003768f, // 3920
-0.028825f, -0.076913f, -0.081384f, -0.058385f, -0.007303f, 0.029144f, -0.015440f, // 3927
0.123859f, 0.108570f, 0.116954f, 0.064679f, -0.026957f, -0.027024f, -0.000627f, // 3934
0.026897f, 0.005726f, -0.011875f, -0.029213f, 0.013093f, 0.049850f, 0.037695f, // 3941
0.027974f, -0.010269f, -0.026184f, -0.089410f, -0.055347f, -0.080554f, -0.033341f, // 3948
0.081535f, 0.022442f, 0.105252f, 0.097687f, 0.117000f, 0.058179f, -0.028466f, // 3955
-0.002247f, -0.008668f, 0.051392f, 0.016274f, 0.002234f, 0.010555f, 0.047155f, // 3962
0.040628f, 0.033401f, 0.018561f, -0.018837f, -0.037567f, -0.038422f, -0.082793f, // 3969
-0.076815f, -0.026117f, 0.061603f, 0.104156f, 0.140960f, 0.123040f, 0.114148f, // 3976
0.085699f, 0.007815f, -0.016775f, 0.025368f, 0.023934f, -0.002437f, -0.007711f, // 3983
0.005735f, 0.040551f, 0.045978f, 0.046553f, 0.041841f, -0.016487f, -0.045963f, // 3990
-0.061826f, -0.080042f, -0.093952f, -0.014883f, 0.067436f, 0.123399f, 0.124319f, // 3997
0.108413f, 0.110394f, 0.083309f, 0.033784f, 0.012331f, 0.027375f, 0.062850f, // 4004
0.021861f, 0.021307f, 0.002332f, 0.040276f, 0.070682f, 0.070118f, 0.063651f, // 4011
-0.011893f, -0.017206f, -0.042379f, -0.053677f, -0.052381f, -0.031423f, 0.038747f, // 4018
0.107633f, 0.118501f, 0.078895f, 0.094164f, 0.110061f, 0.070042f, 0.028005f, // 4025
0.027527f, 0.055692f, 0.034314f, 0.010030f, -0.009401f, 0.042752f, 0.076638f, // 4032
0.074039f, 0.047267f, -0.019194f, -0.031083f, -0.060682f, -0.073952f, -0.068831f, // 4039
-0.028345f, 0.025055f, 0.111217f, 0.100653f, 0.068817f, 0.082910f, 0.096752f, // 4046
0.075580f, 0.021669f, 0.016332f, 0.022710f, 0.003053f, 0.009672f, 0.006151f, // 4053
0.032027f, 0.045495f, 0.042376f, 0.010884f, 0.001338f, -0.027065f, -0.070130f, // 4060
-0.066375f, -0.038097f, -0.052759f, -0.020574f, 0.096854f, 0.113824f, 0.100833f, // 4067
0.114808f, 0.116691f, 0.055274f, 0.010146f, 0.013596f, 0.014066f, 0.019977f, // 4074
0.012048f, 0.004515f, 0.025684f, 0.031616f, 0.012977f, -0.000633f, -0.014056f, // 4081
-0.039954f, -0.092785f, -0.064513f, -0.031525f, -0.036574f, -0.036965f, 0.125877f, // 4088
0.124043f, 0.128851f, 0.202592f, 0.127939f, 0.052806f, 0.020274f, 0.023160f, // 4095
0.001886f, 0.020897f, 0.018069f, 0.018394f, 0.019801f, 0.010047f, 0.010486f, // 4102
-0.001198f, -0.023640f, -0.048916f, -0.095078f, -0.064142f, -0.056401f, -0.009825f, // 4109
-0.042816f, 0.075914f, 0.140360f, 0.147812f, 0.123192f, 0.108288f, 0.052336f, // 4116
0.055015f, 0.052927f, 0.041298f, 0.041947f, 0.043598f, 0.031794f, 0.053025f, // 4123
0.015259f, 0.016531f, -0.011485f, -0.028226f, -0.065811f, -0.072655f, -0.015002f, // 4130
-0.009469f, 0.004236f, 0.016874f, 0.133059f, 0.086358f, 0.185387f, 0.139410f, // 4137
0.089497f, 0.045703f, 0.023240f, 0.033923f, 0.034082f, 0.047865f, 0.071068f, // 4144
0.039024f, 0.042343f, 0.028831f, 0.036320f, 0.008849f, -0.036757f, -0.054987f, // 4151
-0.048057f, -0.010724f, -0.043957f, 0.012874f, 0.000610f, 0.164779f, 0.105306f, // 4158
0.182411f, 0.124568f, 0.074729f, 0.025734f, 0.010279f, 0.022030f, 0.007515f, // 4165
0.023251f, 0.033673f, 0.010668f, 0.013216f, 0.038886f, 0.066299f, 0.044602f, // 4172
-0.024302f, -0.060876f, -0.041552f, 0.011686f, -0.046179f, -0.002052f, 0.030071f, // 4179
-0.018222f, -0.034009f, -0.004662f, 0.088741f, 0.077584f, 0.077745f, 0.019861f, // 4186
-0.012980f, -0.039168f, -0.031228f, -0.030600f, 0.016812f, 0.044157f, 0.054708f, // 4193
0.051392f, 0.031700f, 0.097050f, 0.070367f, 0.040634f, -0.059964f, -0.131415f, // 4200
-0.115891f, -0.013032f, 0.024455f, -0.021481f, -0.053608f, 0.051757f, 0.073870f, // 4207
0.073317f, 0.141913f, 0.142177f, 0.093493f, 0.062256f, 0.077898f, 0.060572f, // 4214
0.095791f, 0.125374f, 0.127920f, 0.153033f, 0.087968f, 0.105989f, 0.102844f, // 4221
0.028965f, -0.060578f, -0.032303f, -0.038766f, 0.054448f, 0.022112f, -0.020742f, // 4228
-0.007774f, -0.067146f, 0.022540f, 0.081255f, 0.064947f, 0.094013f, 0.105422f, // 4235
0.074988f, 0.057101f, 0.028554f, 0.061919f, 0.098465f, 0.093192f, 0.011419f, // 4242
0.027039f, 0.001961f, -0.020454f, -0.049269f, -0.042149f, -0.025145f, 0.050203f, // 4249
0.005588f, -0.128685f, -0.001266f, -0.023086f, 0.022580f, 0.017870f, -0.025939f, // 4256
0.075942f, 0.087735f, 0.094248f, 0.096261f, 0.042137f, 0.029763f, 0.046340f, // 4263
0.033907f, -0.007190f, 0.005281f, -0.052745f, -0.029368f, 0.052577f, 0.001402f, // 4270
0.023940f, 0.043190f, -0.095991f, -0.093480f, 0.033966f, -0.013299f, -0.016333f, // 4277
-0.000408f, 0.016641f, 0.064085f, 0.099431f, 0.110865f, 0.096945f, 0.069632f, // 4284
0.038842f, 0.032886f, 0.047826f, 0.020695f, 0.026459f, -0.025098f, -0.049959f, // 4291
0.002826f, 0.021599f, 0.032628f, -0.002378f, -0.096354f, -0.014503f, -0.021835f, // 4298
-0.011347f, -0.081692f, -0.066990f, -0.083465f, 0.015910f, 0.029776f, 0.017986f, // 4305
0.018715f, 0.015734f, -0.047326f, -0.053847f, -0.062035f, -0.005750f, -0.012490f, // 4312
0.008250f, -0.013552f, -0.052082f, -0.039094f, -0.012807f, -0.081777f, -0.091245f, // 4319
-0.104900f, -0.038937f, -0.062160f, -0.103877f, -0.142806f, -0.182716f, -0.114536f, // 4326
-0.138005f, -0.170535f, -0.171839f, -0.143475f, -0.163470f, -0.171103f, -0.178215f, // 4333
-0.088913f, -0.060935f, 0.031358f, -0.028340f, -0.023951f, -0.001817f, -0.031800f, // 4340
-0.046919f, -0.045985f, -0.093957f, -0.058427f, -0.125675f, -0.158498f, -0.151690f, // 4347
-0.110215f, -0.122205f, -0.157287f, -0.122630f, -0.142421f, -0.150028f, -0.119723f, // 4354
-0.108074f, -0.069793f, -0.086036f, -0.062803f, 0.001208f, -0.009926f, -0.023650f, // 4361
0.003880f, -0.019413f, -0.035685f, -0.054033f, -0.098329f, -0.075568f, -0.114890f, // 4368
-0.198755f, -0.170537f, -0.054583f, -0.118324f, -0.125188f, -0.137407f, -0.132111f, // 4375
-0.149358f, -0.147152f, -0.100812f, -0.078253f, -0.060806f, -0.043355f, -0.054714f, // 4382
-0.038556f, -0.018188f, -0.014915f, -0.041366f, -0.042992f, -0.089796f, -0.103089f, // 4389
-0.076344f, -0.110200f, -0.137425f, -0.113555f, -0.071614f, -0.073460f, -0.127385f, // 4396
-0.114007f, -0.080129f, -0.083308f, -0.090714f, -0.014459f, -0.025001f, -0.043347f, // 4403
-0.057345f, -0.110972f, -0.134339f, -0.086356f, -0.009919f, -0.027179f, -0.070673f, // 4410
-0.132367f, -0.027258f, 0.012775f, -0.007471f, -0.061312f, -0.075418f, -0.130643f, // 4417
-0.125561f, -0.180251f, -0.169908f, -0.214465f, -0.215877f, -0.220637f, -0.075005f, // 4424
-0.045128f, -0.095562f, -0.092426f, -0.175550f, -0.065573f, -0.056317f, 0.024097f, // 4431
-0.003570f, 0.013440f, -0.118449f, -0.088299f, -0.047672f, -0.016469f, -0.069896f, // 4438
-0.133652f, -0.180574f, -0.243215f, -0.271292f, -0.253060f, -0.305653f, -0.311160f, // 4445
-0.272404f, -0.171809f, -0.151158f, -0.217052f, -0.208193f, -0.205144f, -0.045808f, // 4452
-0.038292f, -0.034411f, 0.022147f, -0.041026f, -0.119021f, -0.133269f, -0.053299f, // 4459
-0.013123f, -0.056966f, -0.100169f, -0.139498f, -0.179840f, -0.220100f, -0.236117f, // 4466
-0.237743f, -0.216461f, -0.131404f, -0.112534f, -0.072178f, -0.143458f, -0.157822f, // 4473
-0.201688f, -0.140555f, -0.145706f, -0.116600f, -0.061314f, -0.024727f, -0.017949f, // 4480
-0.101787f, -0.105706f, -0.078469f, -0.079238f, -0.028296f, -0.008727f, -0.019683f, // 4487
-0.061465f, -0.084784f, -0.086852f, -0.087909f, -0.081706f, -0.069121f, -0.103977f, // 4494
-0.160055f, -0.168194f, -0.147392f, -0.065777f, -0.117433f, -0.059285f, -0.041611f, // 4501
-0.170122f, 0.007985f, -0.095168f, 0.029469f, 0.025790f, -0.018319f, -0.064047f, // 4508
-0.179770f, -0.010855f, -0.008762f, -0.032822f, -0.014376f, -0.005441f, -0.018489f, // 4515
-0.040108f, 0.006407f, -0.003962f, 0.006569f, -0.031340f, -0.038363f, 0.013861f, // 4522
-0.033652f, -0.142910f, -0.355486f, 0.035888f, 0.029072f, 0.066399f, -0.048679f, // 4529
-0.038706f, -0.216955f, -0.290337f, -0.234182f, -0.164641f, -0.114693f, -0.142324f, // 4536
-0.134775f, -0.169400f, -0.160136f, -0.132858f, -0.018982f, -0.052041f, -0.230990f, // 4543
-0.302047f, -0.176969f, -0.115206f, -0.148968f, -0.313140f, 0.004643f, -0.054752f, // 4550
0.148337f, 0.040642f, 0.088635f, -0.048794f, -0.067457f, -0.102704f, -0.107132f, // 4557
-0.156387f, -0.178614f, -0.111367f, -0.119142f, -0.149630f, -0.038706f, 0.105893f, // 4564
0.106018f, -0.132623f, -0.038561f, -0.054500f, 0.013022f, -0.155196f, -0.198989f, // 4571
0.094775f, -0.124820f, 0.200733f, 0.171377f, 0.096921f, 0.042176f, 0.149177f, // 4578
0.155695f, 0.178186f, 0.091330f, 0.123201f, 0.073265f, 0.040992f, 0.026333f, // 4585
0.134375f, 0.206834f, 0.201175f, -0.120042f, -0.172040f, -0.190490f, -0.048315f, // 4592
-0.244978f, -0.169098f, 0.109396f, -0.113943f, 0.118526f, 0.247938f, 0.254108f, // 4599
0.155534f, 0.093148f, 0.272805f, 0.274183f, 0.071851f, 0.133767f, 0.216517f, // 4606
0.226959f, 0.110554f, 0.111605f, 0.162558f, 0.117587f, -0.123351f, -0.084867f, // 4613
-0.161403f, 0.007337f, -0.149069f, -0.059513f, 0.199231f, -0.132660f, 0.112100f, // 4620
0.133701f, 0.275897f, 0.312985f, 0.198682f, 0.282573f, 0.209712f, 0.022527f, // 4627
0.061505f, 0.193054f, 0.373380f, 0.237405f, 0.234549f, 0.260508f, 0.130987f, // 4634
-0.114551f, -0.129592f, -0.240430f, -0.046217f, -0.235320f, 0.016770f, 0.059646f, // 4641
-0.165470f, 0.085997f, 0.167502f, 0.272709f, 0.313971f, 0.117660f, 0.209376f, // 4648
0.191878f, 0.123953f, 0.193272f, 0.260819f, 0.348341f, 0.257205f, 0.270263f, // 4655
0.291415f, 0.101049f, -0.046242f, -0.075742f, -0.333579f, -0.154642f, -0.206415f, // 4662
-0.075546f, 0.021311f, -0.184851f, -0.050420f, 0.116834f, 0.209211f, 0.305481f, // 4669
0.079627f, 0.128118f, 0.186484f, 0.093881f, 0.218762f, 0.227672f, 0.155047f, // 4676
0.270914f, 0.230653f, 0.203995f, 0.051743f, -0.153157f, -0.232901f, -0.408602f, // 4683
-0.367302f, -0.248406f, -0.114655f, 0.042771f, -0.233386f, -0.068088f, 0.084185f, // 4690
0.234277f, 0.209583f, 0.039869f, 0.135418f, 0.172558f, 0.120805f, 0.113509f, // 4697
0.187752f, 0.196981f, 0.221242f, 0.173494f, 0.043325f, -0.022031f, -0.084671f, // 4704
-0.207964f, -0.346303f, -0.350785f, -0.257209f, -0.046840f, 0.056486f, -0.294476f, // 4711
-0.267837f, -0.121378f, 0.102023f, 0.063286f, -0.022559f, 0.034644f, 0.127771f, // 4718
0.089317f, 0.096937f, 0.167977f, 0.209137f, 0.172430f, 0.108836f, 0.083401f, // 4725
-0.018003f, -0.013879f, -0.107670f, -0.212053f, -0.187968f, -0.172604f, -0.058516f, // 4732
-0.009668f, -0.517551f, -0.507427f, -0.091069f, 0.087085f, -0.008425f, -0.030972f, // 4739
0.053358f, 0.082371f, 0.110592f, 0.101672f, 0.194332f, 0.197065f, 0.256408f, // 4746
0.182800f, 0.098799f, -0.007414f, 0.045643f, -0.094954f, -0.196668f, -0.213799f, // 4753
-0.146514f, -0.162733f, -0.074583f, -0.458939f, -0.243044f, -0.146643f, -0.021137f, // 4760
-0.074378f, -0.186210f, -0.066984f, 0.035613f, -0.025549f, -0.018002f, -0.136263f, // 4767
-0.021755f, 0.135872f, 0.147982f, 0.084828f, 0.028864f, 0.053397f, -0.178711f, // 4774
-0.269503f, -0.214741f, -0.120472f, 0.111054f, -0.102987f, -0.112176f, -0.163236f, // 4781
-0.086145f, -0.036932f, -0.070289f, -0.148572f, -0.175168f, -0.153084f, -0.151799f, // 4788
-0.191611f, -0.234693f, -0.166828f, -0.041263f, -0.061066f, -0.031544f, -0.091828f, // 4795
-0.101152f, -0.333136f, -0.266736f, -0.186979f, -0.117069f, 0.136858f, 0.044593f, // 4802
0.106826f, 0.100575f, 0.042227f, 0.174810f, 0.098130f, -0.016806f, -0.050052f, // 4809
0.029794f, 0.000444f, -0.005148f, 0.016614f, 0.097965f, 0.079456f, 0.085180f, // 4816
0.094990f, 0.060489f, 0.028042f, -0.025245f, -0.148451f, -0.136661f, -0.154726f, // 4823
-0.374904f, -0.441477f, -0.397928f, -0.517183f, -0.496149f, -0.522311f, -0.471328f, // 4830
-0.658810f, -0.393254f, -0.427345f, -0.496515f, -0.527233f, -0.472551f, -0.372864f, // 4837
-0.463333f, -0.256014f, -0.182381f, -0.305724f, -0.241366f, -0.337099f, -0.230762f, // 4844
-0.285776f, -0.355367f, -0.822972f, -0.520799f, -0.508983f, -0.419817f, -0.458590f, // 4851
-0.492042f, -0.816299f, -0.718734f, -0.612865f, -0.495340f, -0.485783f, -0.548865f, // 4858
-0.512653f, -0.444587f, -0.582279f, -0.428449f, -0.333986f, -0.393304f, -0.587076f, // 4865
-0.668954f, -0.497982f, -0.376645f, -0.513508f, -0.619772f, -0.302190f, -0.413375f, // 4872
-0.161493f, -0.345462f, -0.300706f, -0.422321f, -0.363804f, -0.273018f, -0.291667f, // 4879
-0.417512f, -0.482290f, -0.532120f, -0.411074f, -0.536843f, -0.409998f, -0.120627f, // 4886
-0.135602f, -0.489434f, -0.292863f, -0.301106f, -0.055664f, -0.263597f, -0.429298f, // 4893
-0.173961f, -0.488485f, 0.116573f, 0.020871f, -0.125462f, -0.289361f, -0.080647f, // 4900
0.121019f, 0.219568f, 0.113641f, 0.231689f, 0.055578f, -0.085086f, -0.330054f, // 4907
0.026841f, 0.148456f, 0.039639f, -0.330227f, -0.457519f, -0.472191f, -0.220500f, // 4914
-0.383359f, -0.332457f, -0.043079f, -0.292388f, 0.191819f, 0.340532f, 0.159725f, // 4921
-0.069000f, -0.142970f, 0.313856f, 0.379550f, 0.238327f, 0.285777f, 0.383694f, // 4928
0.162451f, 0.094082f, 0.122422f, 0.161398f, 0.112042f, -0.168362f, -0.310049f, // 4935
-0.481527f, -0.290208f, -0.314742f, -0.092200f, 0.189864f, -0.096162f, 0.260535f, // 4942
0.270276f, 0.305651f, 0.222119f, 0.031403f, 0.266354f, 0.294915f, 0.052142f, // 4949
-0.000469f, 0.167230f, 0.350950f, 0.173731f, 0.339218f, 0.386066f, 0.153872f, // 4956
-0.099413f, -0.347430f, -0.594031f, -0.356489f, -0.526658f, -0.063377f, -0.211861f, // 4963
-0.257397f, 0.044686f, 0.224235f, 0.261211f, 0.182130f, -0.141311f, 0.187231f, // 4970
0.301411f, 0.293105f, 0.349226f, 0.376574f, 0.370491f, 0.228309f, 0.278012f, // 4977
0.241715f, 0.059785f, -0.109622f, -0.356516f, -0.797251f, -0.469878f, -0.549657f, // 4984
-0.372317f, -0.396042f, -0.487968f, -0.234995f, -0.003624f, 0.033380f, 0.148263f, // 4991
-0.300245f, -0.142739f, 0.011196f, -0.153578f, -0.070701f, 0.105409f, 0.062301f, // 4998
0.234845f, 0.256157f, 0.176121f, 0.027329f, -0.244540f, -0.455376f, -0.726353f, // 5005
-0.669060f, -0.470584f, -0.364640f, -0.415609f, -0.629849f, -0.568458f, -0.344921f, // 5012
-0.199757f, -0.113277f, -0.489914f, -0.213199f, -0.055691f, -0.195010f, -0.219353f, // 5019
0.003635f, 0.021198f, -0.024821f, 0.006838f, -0.149754f, -0.180554f, -0.177996f, // 5026
-0.378158f, -0.547444f, -0.457251f, -0.302262f, -0.341288f, -0.713243f, -1.002238f, // 5033
-0.936436f, -0.746359f, -0.638711f, -0.537797f, -0.814119f, -0.830090f, -0.577924f, // 5040
-0.457699f, -0.394802f, -0.427480f, -0.289184f, -0.283688f, -0.269004f, -0.272134f, // 5047
-0.230856f, -0.169508f, -0.202594f, -0.326651f, -0.366060f, -0.168386f, -0.495671f, // 5054
-0.840995f, -1.154487f, -1.191098f, -0.819207f, -0.579164f, -0.599713f, -0.839109f, // 5061
-0.707012f, -0.848463f, -0.730340f, -0.750586f, -0.653276f, -0.608433f, -0.311255f, // 5068
-0.219011f, -0.265889f, -0.329087f, -0.094804f, -0.409028f, -0.619617f, -0.543646f, // 5075
-0.197749f, -0.817675f, -1.029987f, -1.575054f, -1.372188f, -1.013811f, -0.658975f, // 5082
-0.719951f, -0.953455f, -0.709338f, -0.797666f, -0.868001f, -0.862035f, -1.080393f, // 5089
-0.722574f, -0.425073f, -0.316427f, -0.412313f, -0.435964f, -0.341051f, -0.764378f, // 5096
-1.047155f, -0.775018f, -0.355269f, -0.513154f, -1.030786f, -1.227013f, -1.246017f, // 5103
-1.017105f, -0.714670f, -0.711657f, -0.889299f, -0.965398f, -1.152540f, -1.161716f, // 5110
-1.175672f, -1.148868f, -1.001017f, -0.856156f, -0.743880f, -0.667450f, -0.710158f, // 5117
-0.750451f, -1.225215f, -0.971548f, -0.799005f, -0.388574f, -0.409360f, -0.691743f, // 5124
-0.627573f, -0.582027f, -0.604477f, -0.300822f, -0.441215f, -0.612273f, -0.729907f, // 5131
-0.596494f, -0.779330f, -0.750346f, -0.631440f, -0.510606f, -0.424836f, -0.306116f, // 5138
-0.278460f, -0.302654f, -0.542973f, -0.876323f, -0.898666f, -0.875520f, -0.540533f, // 5145
-0.005455f, 0.009046f, 0.026390f, 0.009170f, -0.005569f, 0.010432f, -0.004093f, // 5152
-0.003778f, 0.000028f, -0.013677f, 0.009757f, 0.009592f, 0.004268f, 0.002705f, // 5159
0.004977f, 0.010518f, -0.012157f, -0.018578f, -0.026891f, -0.016155f, -0.009806f, // 5166
-0.014796f, -0.009428f, 0.012126f, 0.015580f, 0.049555f, 0.014134f, 0.027700f, // 5173
0.051765f, 0.021724f, 0.004421f, -0.010341f, -0.023678f, 0.001446f, 0.015263f, // 5180
-0.016211f, -0.002146f, 0.015286f, 0.006351f, -0.024520f, -0.031388f, -0.042556f, // 5187
-0.035276f, -0.009882f, -0.011992f, -0.001444f, 0.007456f, 0.024388f, 0.046684f, // 5194
0.023681f, 0.041820f, 0.028274f, -0.001012f, -0.003823f, -0.021559f, -0.028582f, // 5201
-0.012392f, 0.008263f, 0.002062f, -0.003908f, 0.009703f, -0.013871f, -0.019452f, // 5208
-0.027010f, -0.040650f, -0.045055f, -0.019461f, -0.028861f, -0.010161f, 0.015110f, // 5215
0.030014f, 0.052593f, 0.038802f, 0.062535f, 0.035512f, -0.001231f, -0.009923f, // 5222
-0.014463f, -0.026871f, -0.019059f, -0.004243f, -0.003030f, -0.015353f, -0.010765f, // 5229
-0.011324f, -0.017474f, -0.024587f, -0.050025f, -0.053443f, -0.053283f, -0.048581f, // 5236
-0.008451f, 0.024610f, 0.021039f, 0.048518f, 0.042908f, 0.054187f, 0.036684f, // 5243
0.019429f, 0.006428f, -0.002792f, -0.021871f, -0.002089f, 0.010981f, 0.016879f, // 5250
-0.019605f, -0.005816f, -0.007874f, -0.025337f, -0.026934f, -0.045409f, -0.033882f, // 5257
-0.036758f, -0.031438f, -0.004036f, 0.031921f, 0.041632f, 0.076228f, 0.065770f, // 5264
0.072619f, 0.044867f, -0.001491f, -0.006800f, -0.005658f, -0.012865f, 0.003818f, // 5271
0.020898f, 0.024000f, 0.003425f, 0.002459f, -0.001640f, -0.016612f, -0.024187f, // 5278
-0.054967f, -0.066994f, -0.072983f, -0.023939f, -0.000747f, 0.030020f, 0.041067f, // 5285
0.069137f, 0.058290f, 0.064936f, 0.053627f, 0.005709f, -0.009894f, 0.006366f, // 5292
-0.023602f, 0.017408f, 0.026801f, 0.013461f, -0.001609f, 0.004109f, 0.008848f, // 5299
-0.054557f, -0.029950f, -0.056604f, -0.080115f, -0.062230f, -0.030252f, -0.004703f, // 5306
0.025449f, 0.035022f, 0.061516f, 0.049739f, 0.070348f, 0.090882f, 0.032011f, // 5313
-0.009571f, -0.006028f, -0.013510f, 0.007383f, 0.012463f, 0.011704f, 0.017729f, // 5320
0.020421f, 0.002960f, -0.040080f, -0.029067f, -0.075191f, -0.075274f, -0.063095f, // 5327
-0.032633f, -0.012698f, 0.029197f, 0.030461f, 0.064017f, 0.043232f, 0.048297f, // 5334
0.078302f, 0.039338f, -0.007630f, -0.012659f, -0.012098f, -0.005620f, 0.002883f, // 5341
0.008421f, 0.023524f, 0.018508f, 0.009443f, -0.046510f, -0.030581f, -0.061277f, // 5348
-0.059990f, -0.052188f, -0.045841f, 0.001363f, 0.028481f, 0.002449f, 0.054659f, // 5355
0.030728f, 0.027945f, 0.042327f, 0.022791f, -0.004135f, -0.021154f, -0.022882f, // 5362
-0.009032f, 0.006732f, 0.008760f, 0.006110f, 0.002090f, -0.020878f, -0.056064f, // 5369
-0.036068f, -0.083929f, -0.067396f, -0.056304f, -0.045982f, -0.005549f, 0.029814f, // 5376
0.014496f, 0.052339f, 0.057047f, 0.035298f, 0.029648f, 0.009363f, -0.015498f, // 5383
-0.042830f, -0.045954f, -0.029122f, -0.028490f, -0.028520f, -0.031333f, -0.022440f, // 5390
-0.041849f, -0.058803f, -0.024644f, -0.036356f, -0.031702f, -0.040241f, -0.061697f, // 5397
0.000606f, 0.022938f, 0.013251f, 0.026628f, 0.028634f, 0.041575f, 0.043484f, // 5404
0.003416f, -0.020419f, -0.026037f, -0.026000f, -0.017344f, -0.027858f, -0.040316f, // 5411
-0.045248f, -0.025589f, -0.055304f, -0.069981f, -0.047457f, -0.062511f, -0.058944f, // 5418
-0.063615f, -0.042742f, -0.004927f, 0.022677f, -0.013491f, 0.040037f, 0.052363f, // 5425
0.059131f, 0.054686f, -0.004816f, -0.009790f, -0.010622f, -0.013188f, -0.006650f, // 5432
-0.014890f, -0.028696f, -0.025506f, -0.019325f, -0.045621f, -0.052481f, -0.029015f, // 5439
-0.037207f, -0.050249f, -0.049510f, -0.030108f, 0.005372f, 0.014524f, 0.003366f, // 5446
0.025573f, 0.038551f, 0.039375f, 0.036497f, 0.001619f, -0.008828f, -0.006232f, // 5453
-0.013002f, -0.005522f, -0.003823f, -0.005542f, -0.010826f, 0.001162f, -0.003383f, // 5460
-0.042887f, -0.037765f, -0.015078f, -0.006346f, -0.000146f, 0.016639f, 0.012449f, // 5467
-0.034059f, -0.028515f, -0.008501f, 0.011915f, 0.015494f, 0.024641f, 0.016803f, // 5474
0.007418f, 0.001906f, -0.002429f, 0.014602f, 0.035383f, 0.037588f, 0.032569f, // 5481
0.023702f, 0.004153f, 0.024302f, 0.010116f, -0.015105f, -0.024871f, -0.007077f, // 5488
-0.015801f, -0.026388f, -0.004278f, 0.000604f, 0.030646f, 0.044760f, 0.049973f, // 5495
0.093118f, 0.047353f, 0.046626f, 0.039692f, 0.046053f, 0.046839f, 0.042388f, // 5502
0.068591f, 0.095931f, 0.064476f, 0.058685f, 0.067292f, 0.071526f, 0.083275f, // 5509
0.057257f, 0.026656f, -0.005053f, -0.001320f, 0.010698f, 0.022643f, 0.098831f, // 5516
0.062668f, 0.079841f, 0.133466f, 0.126233f, 0.091107f, 0.086811f, 0.113426f, // 5523
0.127886f, 0.127673f, 0.118398f, 0.121376f, 0.123210f, 0.109394f, 0.120086f, // 5530
0.110408f, 0.107717f, 0.086755f, 0.079833f, 0.036723f, 0.022383f, 0.011145f, // 5537
0.033038f, 0.100561f, 0.066204f, 0.078003f, 0.072522f, 0.123412f, 0.094342f, // 5544
0.099311f, 0.119577f, 0.112708f, 0.128652f, 0.121492f, 0.135352f, 0.121357f, // 5551
0.108755f, 0.069284f, 0.071360f, 0.083955f, 0.083964f, 0.081158f, 0.048563f, // 5558
0.028648f, 0.003912f, 0.021056f, 0.054385f, 0.016435f, 0.016948f, 0.004933f, // 5565
0.007819f, 0.001257f, 0.049042f, 0.058324f, 0.046821f, 0.047759f, 0.039719f, // 5572
0.040162f, 0.080423f, 0.029295f, 0.010724f, 0.023310f, 0.061283f, 0.075344f, // 5579
0.070840f, 0.032032f, 0.013927f, 0.004464f, -0.011821f, 0.003815f, -0.018419f, // 5586
-0.007790f, -0.006941f, 0.001058f, -0.026042f, -0.017619f, 0.010338f, 0.012467f, // 5593
0.003525f, -0.013279f, -0.000832f, 0.027636f, 0.003908f, 0.019730f, 0.018362f, // 5600
0.059299f, 0.059195f, 0.059842f, 0.024205f, 0.017591f, -0.023986f, -0.058262f, // 5607
-0.052373f, -0.043418f, -0.016479f, -0.021106f, -0.015294f, -0.051490f, -0.059331f, // 5614
-0.051107f, -0.063818f, -0.058920f, -0.053621f, -0.032660f, -0.006539f, -0.011136f, // 5621
-0.012224f, -0.012893f, 0.009920f, 0.023535f, 0.041043f, 0.027848f, 0.008066f, // 5628
-0.018920f, -0.047692f, -0.058331f, -0.047085f, -0.049414f, -0.057062f, -0.048360f, // 5635
-0.058857f, -0.066464f, -0.054083f, -0.037210f, -0.034430f, -0.043901f, -0.037163f, // 5642
-0.022276f, 0.003288f, -0.023542f, -0.032652f, -0.015031f, 0.015486f, 0.035946f, // 5649
0.034074f, 0.023284f, -0.014304f, -0.058503f, -0.061012f, -0.055410f, -0.064788f, // 5656
-0.092587f, -0.085139f, -0.085259f, -0.075679f, -0.060835f, -0.052571f, -0.043722f, // 5663
-0.055217f, -0.077912f, -0.077020f, -0.064456f, -0.050166f, -0.028907f, -0.013333f, // 5670
-0.005941f, 0.027590f, 0.024447f, 0.015941f, -0.024972f, -0.066113f, -0.087568f, // 5677
-0.101902f, -0.107941f, -0.086272f, -0.080915f, -0.081642f, -0.061754f, -0.087599f, // 5684
-0.068504f, -0.071608f, -0.084473f, -0.113008f, -0.089479f, -0.078457f, -0.045630f, // 5691
-0.032715f, -0.038595f, -0.019409f, 0.007622f, 0.016990f, 0.011923f, -0.048288f, // 5698
-0.129920f, -0.147365f, -0.178488f, -0.131960f, -0.095933f, -0.075910f, -0.077458f, // 5705
-0.089657f, -0.107374f, -0.099521f, -0.118532f, -0.151536f, -0.154874f, -0.103710f, // 5712
-0.058666f, -0.046916f, -0.033144f, -0.058951f, -0.067293f, -0.059572f, -0.025947f, // 5719
-0.006234f, -0.032038f, -0.095829f, -0.087932f, -0.088878f, -0.045902f, -0.062097f, // 5726
-0.040182f, -0.069908f, -0.081261f, -0.083286f, -0.066032f, -0.082355f, -0.083531f, // 5733
-0.087097f, -0.070676f, -0.057076f, -0.047945f, -0.038728f, -0.070074f, -0.080079f, // 5740
-0.060810f, -0.039344f, -0.017575f, 0.040708f, -0.017578f, 0.005105f, 0.001796f, // 5747
0.010132f, -0.002151f, 0.007738f, 0.011375f, 0.010126f, 0.014093f, 0.014308f, // 5754
-0.002811f, -0.015339f, 0.005961f, 0.002627f, 0.003389f, -0.001007f, 0.002418f, // 5761
-0.016191f, 0.008240f, 0.006476f, -0.011050f, 0.000161f, 0.084211f, 0.049078f, // 5768
0.072760f, 0.033755f, 0.012389f, -0.014555f, -0.003184f, 0.008838f, 0.006273f, // 5775
0.007904f, 0.005290f, -0.016194f, -0.008835f, -0.002818f, 0.000703f, -0.010730f, // 5782
-0.028860f, -0.032634f, -0.005914f, 0.050132f, 0.034510f, 0.018248f, 0.003605f, // 5789
-0.006787f, 0.095372f, 0.068487f, 0.053674f, -0.011662f, 0.020571f, 0.044635f, // 5796
0.065439f, 0.072170f, 0.069655f, 0.004532f, 0.041761f, 0.046919f, 0.051351f, // 5803
0.037925f, 0.036136f, 0.016217f, 0.023341f, 0.052118f, 0.102709f, 0.065799f, // 5810
0.034149f, 0.062216f, -0.029410f, 0.098010f, 0.032816f, 0.054211f, -0.007630f, // 5817
-0.078864f, -0.014126f, 0.046251f, 0.017110f, -0.014904f, -0.005679f, 0.003770f, // 5824
-0.038044f, -0.065732f, -0.035404f, -0.006526f, -0.021059f, -0.015744f, -0.038639f, // 5831
0.027449f, 0.061078f, 0.080533f, 0.074671f, -0.021075f, 0.113787f, 0.002412f, // 5838
-0.047494f, -0.087176f, -0.097566f, -0.093711f, -0.005839f, 0.000664f, -0.030980f, // 5845
-0.072875f, -0.073885f, -0.091197f, -0.037691f, -0.063445f, -0.036199f, -0.106686f, // 5852
-0.115152f, -0.078103f, -0.029649f, -0.014659f, 0.004402f, 0.037941f, -0.016962f, // 5859
0.037561f, -0.048552f, -0.132777f, -0.220417f, -0.077682f, -0.018090f, 0.043441f, // 5866
-0.046207f, -0.035288f, -0.008896f, -0.022203f, -0.082978f, 0.002634f, -0.027582f, // 5873
-0.069871f, -0.086837f, -0.083632f, -0.076233f, -0.019121f, 0.013115f, 0.022796f, // 5880
0.081312f, -0.011826f, -0.014939f, -0.050362f, -0.116079f, -0.116785f, 0.026240f, // 5887
0.144436f, 0.160193f, 0.107517f, 0.052633f, 0.104547f, 0.074700f, 0.048446f, // 5894
0.104299f, 0.078696f, 0.054472f, -0.010744f, -0.032889f, -0.002356f, 0.033953f, // 5901
0.038206f, 0.064374f, 0.067275f, -0.003595f, -0.054586f, -0.070318f, -0.110118f, // 5908
-0.090724f, 0.006340f, 0.153601f, 0.167046f, 0.155259f, 0.149160f, 0.136583f, // 5915
0.099414f, 0.108503f, 0.149649f, 0.198000f, 0.082073f, -0.047781f, -0.060786f, // 5922
-0.042151f, 0.005542f, 0.047663f, 0.050129f, 0.061891f, 0.008054f, 0.015617f, // 5929
-0.043057f, -0.029477f, -0.091034f, 0.021811f, 0.175415f, 0.206168f, 0.205819f, // 5936
0.162986f, 0.148611f, 0.136661f, 0.112003f, 0.169995f, 0.198248f, 0.202682f, // 5943
0.021436f, 0.042290f, -0.012831f, 0.044632f, 0.134213f, 0.117046f, 0.084898f, // 5950
0.031104f, 0.032895f, -0.022283f, -0.003937f, -0.075686f, -0.051059f, 0.173540f, // 5957
0.192263f, 0.183342f, 0.179551f, 0.166529f, 0.139758f, 0.098282f, 0.155058f, // 5964
0.187025f, 0.134469f, -0.039363f, -0.048226f, -0.050697f, -0.025261f, 0.052878f, // 5971
0.067476f, 0.074660f, 0.013976f, 0.021675f, -0.027600f, 0.011863f, -0.054113f, // 5978
-0.046897f, 0.149031f, 0.171999f, 0.137492f, 0.136320f, 0.165168f, 0.168899f, // 5985
0.137769f, 0.127248f, 0.126220f, 0.059557f, -0.060595f, -0.023985f, -0.036902f, // 5992
0.023654f, 0.062991f, 0.041615f, 0.099750f, -0.007103f, 0.055949f, 0.001282f, // 5999
0.037767f, -0.010967f, -0.043749f, 0.128337f, 0.156066f, 0.158311f, 0.148207f, // 6006
0.122818f, 0.135126f, 0.170701f, 0.186330f, 0.194895f, 0.080087f, -0.019304f, // 6013
0.001941f, -0.022601f, 0.073530f, 0.127079f, 0.076023f, 0.100666f, -0.000950f, // 6020
0.042742f, 0.027274f, -0.017071f, -0.050582f, -0.054737f, 0.093751f, 0.092875f, // 6027
0.103301f, 0.085370f, 0.117124f, 0.152154f, 0.191594f, 0.169310f, 0.175546f, // 6034
0.076179f, -0.004844f, 0.012914f, 0.052159f, 0.106179f, 0.130856f, 0.059588f, // 6041
0.087733f, -0.004983f, 0.065657f, 0.010884f, 0.027284f, -0.027052f, -0.013535f, // 6048
0.091497f, 0.097125f, 0.113427f, 0.082640f, 0.096910f, 0.118376f, 0.092248f, // 6055
0.117790f, 0.103951f, 0.038780f, 0.003139f, 0.007866f, -0.000547f, 0.025987f, // 6062
0.132679f, 0.086551f, 0.111869f, 0.022548f, 0.097792f, 0.009395f, 0.009097f, // 6069
-0.006171f, 0.055820f, 0.112323f, 0.134486f, 0.133450f, 0.129568f, 0.120270f, // 6076
0.129708f, 0.132707f, 0.139802f, 0.137420f, 0.087162f, 0.070037f, 0.092928f, // 6083
0.046024f, 0.097827f, 0.142029f, 0.104153f, 0.078810f, 0.060923f, 0.131575f, // 6090
0.082059f, 0.066574f, 0.000053f, 0.009429f, 0.061667f, 0.062130f, 0.062506f, // 6097
0.064140f, 0.066406f, 0.065621f, 0.073458f, 0.099771f, 0.095493f, 0.071989f, // 6104
0.037030f, 0.054519f, 0.098226f, 0.117806f, 0.148723f, 0.095094f, 0.068108f, // 6111
0.072005f, 0.119598f, 0.108465f, 0.140168f, 0.105549f, 0.097148f, 0.058912f, // 6118
0.104549f, 0.063305f, 0.019505f, -0.039969f, -0.003053f, 0.017782f, 0.046970f, // 6125
0.054982f, 0.098258f, 0.099546f, 0.061213f, 0.071721f, 0.081180f, 0.044755f, // 6132
0.081285f, 0.150871f, 0.064856f, 0.121051f, 0.037964f, -0.005014f, -0.076973f, // 6139
-0.174030f, -0.172658f, -0.113332f, -0.147348f, -0.161094f, -0.133656f, -0.153188f, // 6146
-0.204374f, -0.266534f, -0.163831f, -0.086499f, -0.081720f, -0.067362f, -0.068400f, // 6153
-0.005617f, 0.028511f, 0.093925f, 0.138850f, 0.058422f, 0.083829f, -0.125085f, // 6160
-0.270516f, -0.294432f, -0.263468f, -0.311341f, -0.238856f, -0.188042f, -0.298724f, // 6167
-0.389499f, -0.376659f, -0.436340f, -0.348766f, -0.292907f, -0.268674f, -0.258319f, // 6174
-0.277024f, -0.261617f, -0.210496f, -0.132650f, -0.033335f, -0.032427f, 0.047362f, // 6181
0.112650f, -0.046258f, -0.237470f, -0.333663f, -0.178979f, -0.353223f, -0.379511f, // 6188
-0.393633f, -0.386476f, -0.322565f, -0.406510f, -0.491021f, -0.451279f, -0.384571f, // 6195
-0.378388f, -0.210560f, -0.202864f, -0.169570f, -0.141420f, -0.018576f, 0.054179f, // 6202
0.118906f, 0.050999f, 0.045058f, -0.042748f, -0.118264f, -0.161375f, 0.073122f, // 6209
0.093723f, 0.006292f, -0.010625f, -0.104363f, 0.004434f, -0.127626f, -0.196137f, // 6216
-0.098303f, -0.088140f, -0.040906f, 0.079335f, 0.042811f, 0.026090f, -0.034777f, // 6223
-0.000249f, 0.073400f, 0.134133f, 0.079061f, 0.042108f, 0.063253f, -0.074436f, // 6230
-0.061430f, 0.022780f, 0.038113f, 0.052439f, 0.077551f, 0.029425f, -0.012289f, // 6237
-0.131223f, -0.011197f, -0.006615f, 0.072879f, -0.013116f, -0.017121f, 0.011729f, // 6244
0.034046f, -0.004015f, 0.085835f, 0.093438f, 0.161601f, 0.091596f, 0.187613f, // 6251
0.146155f, 0.045241f, -0.007269f, 0.113779f, 0.174668f, 0.163532f, 0.299222f, // 6258
0.227143f, 0.191404f, 0.180638f, 0.209898f, 0.219225f, 0.261124f, 0.275633f, // 6265
0.221554f, 0.192496f, 0.139441f, 0.181698f, 0.258117f, 0.212372f, 0.180912f, // 6272
0.178774f, 0.244606f, 0.158107f, 0.088166f, 0.026414f, 0.015339f, 0.157426f, // 6279
0.093885f, 0.172865f, 0.185517f, 0.089604f, 0.075328f, 0.075372f, 0.156890f, // 6286
0.218064f, 0.165712f, 0.083893f, 0.088216f, 0.092863f, 0.102416f, 0.130867f, // 6293
0.125356f, 0.168662f, 0.149485f, 0.129010f, 0.069972f, 0.042155f, 0.019964f, // 6300
0.033715f, 0.155086f, 0.104598f, 0.083114f, 0.028057f, -0.020515f, -0.009939f, // 6307
-0.024512f, -0.060934f, -0.073023f, -0.092911f, 0.010266f, 0.020260f, 0.065560f, // 6314
0.093368f, 0.054280f, 0.088363f, 0.133978f, 0.154104f, 0.183863f, 0.146427f, // 6321
0.108622f, 0.070156f, 0.044254f, 0.118210f, 0.112121f, 0.119543f, 0.034052f, // 6328
-0.025385f, -0.039252f, 0.003566f, 0.026737f, 0.072553f, 0.018976f, 0.010971f, // 6335
0.048487f, 0.123836f, 0.094727f, 0.090031f, 0.100787f, 0.150685f, 0.164189f, // 6342
0.126827f, -0.000534f, -0.055102f, -0.003026f, -0.010073f, 0.052258f, -0.087415f, // 6349
-0.082321f, -0.223893f, -0.180551f, -0.247603f, -0.162011f, -0.134862f, 0.092271f, // 6356
0.040014f, -0.023634f, 0.000671f, 0.083395f, 0.123636f, 0.067344f, 0.113741f, // 6363
0.136580f, 0.104747f, 0.079377f, 0.006073f, 0.054984f, 0.052641f, 0.046672f, // 6370
-0.033803f, -0.103985f, -0.079641f, -0.162306f, -0.178989f, -0.162479f, -0.133620f, // 6377
-0.116406f, -0.085903f, 0.008496f, 0.036077f, 0.094829f, 0.049129f, -0.047696f, // 6384
0.121663f, 0.056625f, 0.189643f, 0.138245f, 0.201158f, -0.009366f, 0.032690f, // 6391
0.037092f, 0.135905f, 0.133706f, 0.175293f, 0.181846f, 0.202408f, 0.151558f, // 6398
0.091580f, 0.115190f, 0.082330f, 0.084383f, 0.060458f, 0.119017f, 0.155404f, // 6405
0.118612f, 0.157316f, 0.211882f, 0.152001f, 0.171155f, 0.112846f, 0.193223f, // 6412
0.179470f, 0.139762f, 0.055563f, 0.058566f, 0.065217f, 0.107675f, 0.105482f, // 6419
0.101032f, 0.083005f, 0.019337f, 0.090011f, 0.145320f, 0.149400f, 0.098831f, // 6426
0.005862f, 0.027049f, 0.063347f, 0.137694f, 0.226066f, 0.131005f, 0.127823f, // 6433
-0.017933f, -0.007553f, 0.020069f, 0.003300f, -0.007015f, 0.002064f, -0.018735f, // 6440
-0.027706f, -0.026144f, -0.036763f, -0.015984f, -0.007550f, -0.005152f, -0.016300f, // 6447
-0.016405f, -0.014471f, -0.029339f, -0.029703f, -0.027049f, -0.014025f, -0.023195f, // 6454
-0.023012f, -0.020745f, 0.018864f, 0.023239f, 0.056311f, 0.018823f, 0.026790f, // 6461
0.051762f, 0.020768f, -0.004668f, -0.009795f, -0.022342f, -0.000198f, 0.011574f, // 6468
-0.016645f, -0.007384f, 0.007385f, 0.005354f, -0.024706f, -0.039534f, -0.065604f, // 6475
-0.066568f, -0.026735f, -0.009192f, -0.012097f, 0.035105f, 0.028955f, 0.054096f, // 6482
0.022147f, 0.028381f, 0.048524f, 0.004303f, 0.006801f, -0.004566f, -0.012481f, // 6489
-0.004885f, 0.004987f, 0.009565f, 0.009656f, 0.028626f, -0.004582f, -0.013730f, // 6496
-0.018152f, -0.046397f, -0.057548f, -0.032964f, -0.024190f, -0.034013f, 0.048520f, // 6503
0.044994f, 0.076967f, 0.032141f, 0.048062f, 0.037824f, 0.018852f, 0.013279f, // 6510
-0.000407f, -0.011988f, -0.009690f, 0.014172f, 0.007435f, -0.001831f, 0.006298f, // 6517
0.003030f, -0.014785f, -0.022415f, -0.054280f, -0.064014f, -0.056232f, -0.046491f, // 6524
-0.026887f, 0.051900f, 0.048601f, 0.069472f, 0.031490f, 0.031675f, 0.017417f, // 6531
0.023914f, 0.009005f, -0.004905f, -0.031091f, -0.006414f, 0.013154f, 0.014733f, // 6538
-0.017170f, -0.006546f, -0.003933f, -0.041391f, -0.037789f, -0.059699f, -0.050089f, // 6545
-0.043863f, -0.030876f, -0.037152f, 0.065037f, 0.072972f, 0.092267f, 0.052733f, // 6552
0.050028f, 0.032779f, -0.002172f, -0.010191f, -0.014938f, -0.027860f, -0.000509f, // 6559
0.010513f, 0.007515f, -0.004815f, -0.006738f, -0.002518f, -0.034234f, -0.032551f, // 6566
-0.058978f, -0.075762f, -0.086284f, -0.033264f, -0.046762f, 0.062318f, 0.062980f, // 6573
0.075005f, 0.036856f, 0.044509f, 0.047228f, 0.005725f, -0.020353f, -0.005958f, // 6580
-0.031696f, 0.007108f, 0.024764f, 0.002612f, -0.010761f, 0.000909f, 0.006394f, // 6587
-0.075766f, -0.064440f, -0.078446f, -0.100976f, -0.102303f, -0.056500f, -0.049749f, // 6594
0.050113f, 0.050887f, 0.062285f, 0.038534f, 0.059452f, 0.082452f, 0.030386f, // 6601
-0.014325f, -0.026384f, -0.024074f, 0.007854f, 0.011226f, 0.004641f, 0.006252f, // 6608
0.015627f, -0.006123f, -0.062810f, -0.039302f, -0.088534f, -0.093099f, -0.086986f, // 6615
-0.043477f, -0.045478f, 0.063102f, 0.044618f, 0.060871f, 0.031376f, 0.038970f, // 6622
0.068432f, 0.035533f, -0.010940f, -0.022437f, -0.010202f, 0.000603f, 0.012732f, // 6629
0.019510f, 0.025016f, 0.011313f, -0.004359f, -0.059485f, -0.039728f, -0.069284f, // 6636
-0.076663f, -0.071415f, -0.058208f, -0.043655f, 0.053848f, 0.017144f, 0.060985f, // 6643
0.017672f, 0.017979f, 0.038743f, 0.017940f, -0.009714f, -0.024916f, -0.017744f, // 6650
0.002967f, 0.025134f, 0.025460f, 0.029188f, 0.008935f, -0.019006f, -0.058924f, // 6657
-0.041954f, -0.088238f, -0.078344f, -0.074070f, -0.065316f, -0.060584f, 0.055590f, // 6664
0.032445f, 0.062770f, 0.041952f, 0.017017f, 0.016359f, 0.002553f, -0.010470f, // 6671
-0.020623f, -0.019681f, -0.006213f, 0.004344f, 0.007950f, 0.006389f, 0.001695f, // 6678
-0.027326f, -0.042522f, -0.018359f, -0.043123f, -0.052064f, -0.051004f, -0.073834f, // 6685
-0.056663f, 0.059351f, 0.020259f, 0.046359f, 0.012658f, 0.018159f, 0.032867f, // 6692
0.009618f, -0.007523f, -0.000726f, 0.002822f, 0.002990f, -0.006690f, -0.010996f, // 6699
-0.006302f, 0.002099f, -0.029932f, -0.047010f, -0.034559f, -0.050897f, -0.049510f, // 6706
-0.061585f, -0.037923f, -0.041245f, 0.036713f, -0.000461f, 0.034612f, 0.021747f, // 6713
0.023987f, 0.039125f, -0.001740f, -0.007156f, -0.004462f, -0.008302f, -0.008187f, // 6720
-0.014274f, -0.017444f, -0.009506f, -0.004236f, -0.034319f, -0.039154f, -0.020495f, // 6727
-0.023156f, -0.052825f, -0.055474f, -0.027736f, -0.025444f, 0.037245f, 0.029453f, // 6734
0.051934f, 0.052156f, 0.038330f, 0.040832f, 0.017140f, 0.002088f, 0.010072f, // 6741
0.012627f, 0.014859f, 0.012338f, 0.006503f, 0.007490f, 0.012498f, 0.008524f, // 6748
-0.017104f, -0.015273f, 0.006229f, 0.017423f, 0.002498f, 0.024642f, -0.010235f, // 6755
-0.007358f, -0.007200f, 0.018829f, 0.022759f, 0.031984f, 0.035053f, 0.035536f, // 6762
0.033010f, 0.028842f, 0.022528f, 0.047726f, 0.053122f, 0.056512f, 0.045639f, // 6769
0.047341f, 0.043244f, 0.054872f, 0.033917f, -0.000873f, 0.007631f, 0.012960f, // 6776
-0.004933f, 0.002546f, 0.016797f, -0.002586f, 0.014645f, 0.027316f, 0.036055f, // 6783
0.054415f, 0.027911f, 0.043471f, 0.049296f, 0.038936f, 0.040301f, 0.046821f, // 6790
0.074116f, 0.078886f, 0.043279f, 0.036214f, 0.049908f, 0.054565f, 0.043973f, // 6797
0.034989f, 0.027562f, 0.000741f, 0.004502f, 0.024408f, 0.020383f, 0.068663f, // 6804
0.052498f, 0.072044f, 0.072082f, 0.067564f, 0.069100f, 0.063104f, 0.079753f, // 6811
0.091668f, 0.089098f, 0.093239f, 0.096338f, 0.063408f, 0.064746f, 0.081944f, // 6818
0.090103f, 0.056948f, 0.046112f, 0.046554f, 0.018743f, 0.008932f, 0.019375f, // 6825
0.019565f, 0.067775f, 0.041945f, 0.062699f, 0.054014f, 0.088407f, 0.089809f, // 6832
0.080903f, 0.079575f, 0.074328f, 0.088687f, 0.092590f, 0.094415f, 0.092464f, // 6839
0.085638f, 0.067586f, 0.064540f, 0.037324f, 0.051486f, 0.041728f, 0.021916f, // 6846
0.017667f, 0.020911f, 0.008028f, 0.048879f, 0.021979f, 0.017394f, 0.002697f, // 6853
0.003358f, 0.010646f, 0.024102f, 0.032726f, 0.023840f, 0.029975f, 0.034553f, // 6860
0.024511f, 0.054043f, 0.021809f, 0.016378f, 0.017841f, 0.020058f, 0.043721f, // 6867
0.049158f, 0.018801f, 0.006356f, 0.011947f, 0.008496f, 0.023307f, 0.002960f, // 6874
-0.000113f, -0.000186f, -0.002015f, -0.011588f, -0.017072f, 0.003204f, 0.011132f, // 6881
0.010782f, 0.001084f, 0.012231f, 0.018105f, 0.008019f, 0.011008f, 0.011998f, // 6888
0.015736f, 0.026865f, 0.030282f, 0.012402f, 0.012335f, 0.003016f, -0.009601f, // 6895
0.002167f, -0.006497f, 0.000665f, 0.003066f, 0.008930f, -0.007182f, -0.016393f, // 6902
-0.015906f, -0.009186f, -0.003744f, -0.006172f, -0.003587f, -0.000294f, 0.002293f, // 6909
0.000742f, 0.003847f, 0.001549f, 0.005593f, 0.022096f, 0.014510f, 0.010770f, // 6916
0.002993f, -0.013847f, -0.007555f, -0.006708f, -0.005574f, -0.005496f, -0.000295f, // 6923
-0.004304f, -0.018234f, -0.007009f, 0.010607f, 0.014436f, 0.003362f, -0.002455f, // 6930
-0.006709f, 0.006393f, -0.000293f, 0.007117f, -0.001944f, 0.001077f, 0.020721f, // 6937
0.027259f, 0.029757f, 0.009380f, -0.015698f, -0.010706f, -0.007970f, -0.009203f, // 6944
-0.008032f, -0.016962f, -0.014936f, -0.015584f, -0.006390f, 0.009128f, 0.006639f, // 6951
0.004286f, -0.014084f, -0.017995f, -0.006805f, 0.017554f, 0.012890f, 0.014430f, // 6958
0.006419f, 0.031907f, 0.015990f, 0.032789f, 0.004125f, -0.014585f, -0.014589f, // 6965
-0.022684f, -0.025604f, -0.010139f, -0.011302f, -0.001674f, 0.012994f, 0.003412f, // 6972
0.023426f, 0.010492f, 0.006950f, -0.009382f, -0.013046f, -0.001131f, 0.029499f, // 6979
0.025561f, 0.030382f, 0.042521f, 0.050447f, 0.028843f, 0.034988f, -0.001880f, // 6986
-0.040999f, -0.045546f, -0.078487f, -0.047207f, -0.019884f, -0.013747f, -0.007704f, // 6993
-0.010933f, -0.033214f, -0.011183f, 0.009933f, -0.014755f, -0.041707f, -0.032249f, // 7000
0.013593f, 0.027180f, 0.034352f, 0.034994f, 0.016163f, -0.008268f, -0.006355f, // 7007
0.012016f, 0.004434f, -0.040035f, -0.040604f, -0.072521f, -0.025202f, -0.005212f, // 7014
0.012767f, 0.005428f, -0.008567f, -0.041035f, -0.022482f, -0.014531f, -0.017723f, // 7021
-0.031828f, -0.026672f, -0.005989f, 0.010341f, 0.022144f, -0.000003f, -0.029495f, // 7028
-0.014193f, -0.018568f, -0.000126f, 0.010837f, -0.013901f, 0.001904f, -0.001539f, // 7035
0.017995f, 0.024518f, 0.015977f, 0.024066f, 0.027037f, 0.032353f, 0.033858f, // 7042
0.024911f, 0.019500f, 0.019950f, 0.014199f, 0.020796f, 0.023765f, 0.025395f, // 7049
0.008458f, -0.003076f, 0.015205f, -0.005890f, 0.020912f, 0.022220f, 0.013830f, // 7056
0.029091f, 0.019035f, 0.011201f, -0.008265f, -0.019367f, 0.002004f, 0.004230f, // 7063
-0.000142f, 0.004032f, -0.002045f, 0.000292f, -0.005280f, -0.019774f, -0.005596f, // 7070
-0.016013f, -0.007116f, 0.013610f, 0.030181f, 0.036734f, 0.019777f, 0.018811f, // 7077
0.034149f, 0.105072f, 0.040206f, -0.006196f, -0.075742f, -0.121995f, -0.050373f, // 7084
0.057492f, 0.139149f, 0.201062f, 0.099865f, 0.022142f, 0.043797f, 0.030011f, // 7091
-0.022256f, 0.018934f, -0.010686f, 0.031229f, 0.017199f, 0.026729f, -0.030769f, // 7098
-0.072036f, -0.139121f, -0.068283f, 0.047348f, 0.052016f, 0.095499f, 0.015522f, // 7105
-0.059427f, 0.030287f, 0.052788f, 0.148755f, 0.176790f, 0.105727f, 0.072284f, // 7112
0.079528f, 0.081678f, 0.010621f, -0.014278f, -0.020387f, 0.007866f, -0.113412f, // 7119
-0.051518f, 0.009220f, 0.009550f, -0.154752f, -0.085981f, 0.043980f, 0.090535f, // 7126
0.081964f, 0.048238f, -0.156391f, -0.133077f, 0.018747f, 0.133670f, 0.179202f, // 7133
0.124714f, 0.071614f, 0.112727f, 0.101767f, -0.042091f, 0.036179f, 0.007295f, // 7140
0.099658f, -0.044434f, -0.082025f, -0.026287f, -0.057787f, -0.140720f, -0.099036f, // 7147
-0.107523f, -0.073666f, -0.034250f, -0.056038f, -0.106959f, -0.118892f, 0.034000f, // 7154
0.023000f, 0.047979f, 0.055708f, -0.028236f, 0.010841f, -0.011384f, 0.002387f, // 7161
-0.011558f, -0.005087f, 0.030810f, -0.056526f, -0.056002f, -0.034670f, -0.033553f, // 7168
-0.204556f, -0.127344f, -0.200755f, -0.122541f, -0.004651f, -0.040565f, -0.235935f, // 7175
-0.022573f, 0.020330f, -0.010491f, -0.042793f, -0.001174f, 0.002869f, -0.031242f, // 7182
-0.063960f, -0.017056f, -0.011188f, -0.025207f, -0.029083f, -0.010294f, 0.047120f, // 7189
0.085557f, 0.001519f, -0.239049f, -0.142251f, -0.316768f, -0.225428f, -0.047977f, // 7196
-0.129241f, -0.172862f, -0.042359f, 0.052832f, -0.003885f, -0.045706f, 0.024900f, // 7203
0.019864f, -0.040582f, -0.027631f, -0.034386f, 0.013501f, -0.100957f, -0.123324f, // 7210
-0.065349f, -0.062754f, -0.050349f, -0.074124f, -0.214603f, -0.098984f, -0.245263f, // 7217
-0.141291f, -0.118696f, -0.189014f, -0.226884f, -0.104936f, 0.027504f, 0.016379f, // 7224
0.002186f, 0.040356f, 0.021548f, 0.010431f, 0.013235f, -0.070536f, -0.136033f, // 7231
-0.307281f, -0.179347f, -0.165205f, -0.166117f, -0.175574f, -0.140890f, -0.216559f, // 7238
-0.084373f, -0.182988f, -0.114226f, -0.104760f, -0.225241f, -0.250434f, -0.105185f, // 7245
0.004344f, 0.031943f, 0.006661f, 0.062549f, 0.044384f, 0.080974f, 0.069251f, // 7252
-0.162296f, -0.152566f, -0.212140f, -0.231873f, -0.193402f, -0.190774f, -0.130999f, // 7259
-0.116995f, -0.305503f, -0.064154f, -0.123990f, -0.056243f, -0.047095f, -0.158685f, // 7266
-0.258802f, -0.093147f, -0.002593f, -0.009670f, -0.033758f, -0.005662f, 0.010438f, // 7273
0.114772f, 0.054758f, -0.033090f, -0.012009f, -0.074822f, -0.117001f, -0.154313f, // 7280
-0.112508f, -0.058367f, -0.135187f, -0.246400f, -0.091707f, -0.102711f, -0.069454f, // 7287
0.007639f, -0.004676f, -0.057894f, -0.008755f, 0.013271f, 0.013660f, -0.031487f, // 7294
-0.021853f, 0.014882f, 0.112805f, 0.063932f, 0.004611f, -0.022474f, -0.081298f, // 7301
-0.103916f, -0.211078f, -0.077731f, -0.051233f, -0.098770f, -0.233756f, -0.133186f, // 7308
-0.067510f, 0.090623f, 0.174852f, 0.147775f, 0.034653f, 0.037943f, 0.008361f, // 7315
-0.005455f, 0.091686f, 0.046118f, 0.052407f, 0.128465f, 0.081904f, -0.004949f, // 7322
-0.070117f, -0.076791f, -0.066444f, -0.135294f, -0.106458f, -0.001456f, -0.069058f, // 7329
-0.165971f, -0.051622f, 0.073714f, 0.216287f, 0.219934f, 0.109633f, 0.020909f, // 7336
0.063601f, 0.112902f, 0.112778f, 0.084480f, 0.079652f, 0.071417f, 0.051523f, // 7343
0.128987f, 0.050337f, -0.052473f, -0.056162f, -0.114577f, -0.080978f, 0.009712f, // 7350
0.077458f, 0.085775f, -0.134047f, -0.002214f, 0.050496f, 0.238681f, 0.160837f, // 7357
0.038017f, -0.015716f, 0.031953f, 0.032684f, 0.031761f, 0.010134f, 0.027713f, // 7364
0.033664f, 0.046928f, 0.059031f, 0.104915f, 0.026441f, -0.039140f, 0.000523f, // 7371
-0.035080f, 0.137769f, 0.138668f, 0.102347f, -0.156476f, -0.006105f, 0.001374f, // 7378
-0.005701f, -0.002372f, 0.002971f, 0.019868f, 0.097023f, 0.064095f, 0.052098f, // 7385
0.030969f, 0.061396f, 0.065754f, 0.064857f, 0.070830f, 0.060881f, 0.042050f, // 7392
0.050936f, 0.038129f, 0.105745f, 0.153007f, 0.072166f, 0.052900f, -0.105906f, // 7399
0.123846f, 0.084314f, 0.068473f, 0.063839f, 0.085200f, 0.012222f, -0.002794f, // 7406
0.032019f, 0.023377f, 0.022205f, 0.003163f, -0.037874f, -0.016892f, -0.010509f, // 7413
-0.028871f, 0.048413f, 0.068226f, 0.090287f, 0.034711f, 0.026780f, 0.011199f, // 7420
0.005636f, 0.021763f, 0.163883f, 0.067188f, 0.107043f, 0.043560f, -0.011631f, // 7427
-0.019518f, -0.015785f, -0.104906f, -0.065195f, -0.016427f, -0.035499f, -0.074297f, // 7434
-0.037307f, -0.032767f, -0.009360f, -0.008284f, -0.010733f, -0.019693f, -0.015771f, // 7441
0.028467f, 0.033957f, 0.044963f, 0.040877f, 0.163243f, 0.038360f, 0.051499f, // 7448
-0.051783f, -0.077335f, -0.151575f, -0.142618f, -0.138267f, -0.116781f, -0.110576f, // 7455
-0.183260f, -0.171594f, -0.152474f, -0.163171f, -0.174012f, -0.126536f, -0.043053f, // 7462
0.011419f, -0.026674f, -0.077548f, 0.018485f, 0.040700f, -0.063794f, 0.149596f, // 7469
0.069866f, 0.003600f, 0.002136f, -0.009361f, -0.082668f, -0.234979f, -0.258532f, // 7476
-0.259715f, -0.273438f, -0.271013f, -0.346084f, -0.320282f, -0.354238f, -0.283903f, // 7483
-0.165193f, -0.020199f, -0.040575f, 0.038178f, 0.024395f, 0.146317f, 0.096129f, // 7490
0.002735f, 0.120731f, 0.055459f, 0.012804f, 0.096583f, 0.056682f, -0.044979f, // 7497
-0.067188f, -0.081279f, -0.128158f, -0.225579f, -0.179211f, -0.185116f, -0.182901f, // 7504
-0.164849f, -0.218026f, -0.064789f, 0.046431f, 0.053560f, 0.050130f, 0.044654f, // 7511
0.065610f, 0.071550f, 0.015179f, 0.122418f, 0.053591f, 0.091204f, 0.086458f, // 7518
0.004982f, -0.041534f, -0.053667f, -0.002359f, -0.121771f, -0.107185f, -0.131521f, // 7525
-0.120985f, -0.061285f, -0.067106f, -0.098506f, -0.000840f, 0.012166f, 0.008335f, // 7532
0.073618f, 0.061441f, 0.085747f, 0.078588f, 0.038560f, 0.097783f, 0.096615f, // 7539
0.125033f, 0.060234f, 0.027864f, -0.016478f, -0.008332f, 0.039626f, 0.087791f, // 7546
0.070286f, 0.102819f, 0.119508f, 0.151741f, 0.089009f, 0.019775f, -0.014972f, // 7553
-0.009154f, -0.017664f, 0.019401f, 0.011581f, 0.000611f, 0.033180f, 0.018647f, // 7560
0.106524f, 0.121120f, 0.118466f, 0.057164f, 0.031953f, 0.021565f, -0.034592f, // 7567
-0.009440f, 0.064814f, 0.065590f, 0.087348f, 0.083228f, 0.118282f, 0.099989f, // 7574
-0.002096f, -0.001253f, 0.002880f, 0.000516f, 0.041434f, 0.014997f, -0.014965f, // 7581
-0.014752f, -0.026167f, 0.150000f, 0.163627f, 0.130009f, 0.066599f, 0.057776f, // 7588
0.007984f, -0.014907f, 0.014618f, 0.046720f, -0.018254f, -0.079480f, -0.068196f, // 7595
0.021194f, -0.035361f, -0.092607f, -0.055179f, 0.041176f, -0.036474f, 0.025825f, // 7602
0.024014f, -0.051151f, 0.016051f, -0.013148f, 0.186117f, 0.193639f, 0.212186f, // 7609
0.150124f, 0.157471f, 0.121537f, 0.020369f, 0.017616f, 0.065980f, 0.019992f, // 7616
-0.001304f, -0.009120f, -0.008686f, -0.049824f, -0.093722f, -0.027585f, -0.019189f, // 7623
-0.038241f, -0.030609f, -0.092240f, -0.149572f, -0.033919f, -0.001820f, 0.198550f, // 7630
0.200487f, 0.075417f, 0.072278f, 0.209082f, 0.171866f, 0.032755f, -0.008195f, // 7637
-0.045682f, -0.129340f, -0.115868f, -0.120083f, -0.103275f, -0.195158f, -0.122215f, // 7644
-0.016298f, -0.005687f, -0.060491f, -0.079000f, -0.099592f, -0.208347f, -0.033763f, // 7651
0.004660f, 0.191669f, 0.108434f, 0.240850f, 0.185912f, 0.252013f, 0.160532f, // 7658
0.041621f, 0.028166f, -0.024482f, -0.189609f, -0.149402f, -0.171536f, -0.144606f, // 7665
-0.136487f, -0.120983f, -0.047898f, 0.034319f, 0.049800f, -0.046981f, -0.080015f, // 7672
-0.115811f, -0.045022f, 0.037108f, 0.265787f, 0.123765f, 0.218292f, 0.110734f, // 7679
0.156153f, 0.070814f, 0.009325f, 0.041895f, 0.051971f, 0.036064f, 0.024569f, // 7686
-0.012638f, 0.036800f, -0.027295f, -0.006400f, 0.020659f, 0.045980f, 0.067892f, // 7693
0.045893f, 0.073445f, 0.000473f, 0.004582f, 0.056205f, 0.229762f, 0.064378f, // 7700
0.134576f, 0.135741f, 0.159447f, 0.101468f, 0.033392f, 0.070345f, 0.089287f, // 7707
0.073110f, 0.074961f, 0.045569f, 0.084978f, 0.092903f, 0.080678f, 0.046050f, // 7714
-0.009040f, -0.021708f, -0.033936f, -0.038805f, -0.012408f, 0.039039f, -0.030565f, // 7721
0.128319f, 0.232680f, 0.226458f, 0.083726f, 0.023886f, -0.030779f, -0.086705f, // 7728
-0.135337f, 0.023362f, 0.024528f, 0.026623f, 0.008318f, -0.058796f, 0.111689f, // 7735
0.004978f, 0.014889f, -0.063051f, -0.090416f, -0.218495f, -0.313544f, -0.229759f, // 7742
-0.090105f, 0.001296f, -0.204059f, 0.038565f, 0.130107f, 0.102985f, 0.126391f, // 7749
-0.088000f, -0.111179f, -0.112313f, -0.003134f, -0.016765f, -0.004987f, -0.019585f, // 7756
-0.034435f, 0.084272f, 0.010570f, 0.026384f, -0.061197f, -0.081284f, -0.118397f, // 7763
-0.062869f, -0.071341f, 0.055023f, 0.099086f, -0.064981f, 0.037800f, 0.142022f, // 7770
0.121004f, 0.149523f, -0.076889f, -0.116094f, -0.080351f, 0.089761f, 0.004490f, // 7777
0.051882f, 0.050380f, 0.070661f, 0.041057f, 0.004307f, 0.026341f, -0.044534f, // 7784
-0.010240f, -0.103675f, -0.076674f, -0.016190f, 0.032449f, 0.058761f, 0.059515f, // 7791
0.046915f, 0.108694f, 0.114237f, 0.126241f, -0.066100f, -0.073240f, 0.024730f, // 7798
0.091282f, 0.032320f, 0.024676f, -0.029073f, 0.064339f, 0.074350f, 0.064432f, // 7805
-0.003655f, 0.003782f, 0.020225f, -0.082322f, -0.041159f, -0.107025f, 0.017386f, // 7812
0.198127f, -0.026936f, -0.003889f, 0.007317f, 0.095206f, 0.126542f, -0.059692f, // 7819
-0.129413f, -0.102425f, 0.135534f, 0.051544f, 0.069512f, 0.083956f, 0.143084f, // 7826
0.086559f, 0.029211f, 0.039657f, 0.035343f, -0.003066f, 0.066308f, -0.048940f, // 7833
-0.078150f, -0.039384f, -0.039660f, 0.256330f, 0.040402f, 0.052374f, 0.086055f, // 7840
0.159815f, -0.059044f, -0.115492f, 0.014281f, 0.116154f, 0.048359f, 0.018986f, // 7847
0.078035f, 0.117239f, 0.010816f, -0.005807f, 0.003825f, -0.042257f, -0.042743f, // 7854
-0.038079f, -0.051570f, -0.131561f, -0.062112f, -0.083054f, 0.437893f, 0.045736f, // 7861
0.066987f, 0.070153f, 0.081117f, -0.015201f, -0.024354f, 0.026299f, 0.163041f, // 7868
0.016038f, -0.048604f, -0.036996f, 0.097132f, 0.020556f, -0.026499f, 0.015362f, // 7875
-0.099300f, -0.009232f, -0.032273f, -0.052995f, -0.128844f, -0.184932f, -0.218835f, // 7882
0.257088f, 0.070507f, 0.117848f, 0.070967f, 0.069532f, 0.049594f, -0.038448f, // 7889
-0.016640f, 0.128829f, 0.043711f, -0.055582f, -0.024589f, 0.086201f, 0.073349f, // 7896
0.002620f, -0.014731f, -0.070678f, -0.062188f, -0.100611f, -0.094739f, -0.200016f, // 7903
-0.203680f, -0.199143f, 0.460837f, 0.047835f, 0.082127f, 0.067593f, 0.102556f, // 7910
0.092066f, -0.024286f, 0.039436f, 0.091520f, 0.032614f, 0.005681f, -0.078670f, // 7917
-0.002455f, 0.002828f, 0.034533f, -0.008811f, -0.122597f, -0.085272f, -0.164304f, // 7924
-0.112465f, -0.135713f, -0.334530f, -0.371389f, 0.336941f, 0.088954f, 0.096638f, // 7931
0.073752f, 0.100477f, 0.052653f, -0.028213f, 0.050232f, 0.005357f, 0.057600f, // 7938
0.023380f, -0.029198f, -0.028438f, -0.010981f, -0.054420f, -0.097205f, -0.166001f, // 7945
-0.079776f, -0.201363f, -0.133068f, -0.285596f, -0.249213f, -0.205005f, 0.584791f, // 7952
0.157244f, 0.079067f, 0.072423f, 0.100251f, 0.045569f, -0.045721f, -0.032938f, // 7959
-0.128622f, -0.024810f, -0.009597f, -0.003828f, -0.091296f, -0.045757f, -0.121215f, // 7966
-0.265527f, -0.186644f, -0.067683f, -0.122699f, -0.025991f, -0.162515f, -0.182707f, // 7973
-0.177508f, 0.535641f, 0.193396f, 0.226860f, 0.041633f, 0.067781f, 0.026658f, // 7980
0.029504f, -0.004527f, -0.018926f, -0.004803f, -0.009168f, -0.028817f, -0.075188f, // 7987
-0.100133f, -0.079913f, -0.296240f, -0.272183f, -0.151398f, -0.171167f, -0.011566f, // 7994
-0.048909f, -0.062632f, -0.103408f, 0.530701f, 0.106075f, 0.469552f, 0.278879f, // 8001
0.177326f, 0.143825f, 0.043913f, 0.035077f, 0.051196f, 0.071400f, 0.205408f, // 8008
0.035599f, -0.030131f, -0.057956f, -0.041292f, -0.192710f, -0.248864f, -0.211005f, // 8015
-0.228826f, -0.139449f, -0.184226f, -0.154673f, -0.132078f, 0.562350f, 0.388111f, // 8022
0.637570f, 0.378901f, 0.177499f, 0.104941f, 0.061230f, 0.064149f, 0.096048f, // 8029
0.179175f, 0.225077f, 0.125661f, 0.072570f, 0.127038f, 0.159137f, 0.045356f, // 8036
-0.151222f, -0.160441f, -0.092771f, 0.063835f, -0.266093f, -0.035840f, 0.035350f, // 8043
0.016107f, -0.029060f, -0.072871f, -0.088385f, -0.053107f, 0.100481f, 0.038435f, // 8050
0.000269f, 0.023559f, 0.062410f, 0.117951f, 0.091884f, 0.101528f, 0.158860f, // 8057
0.202088f, 0.167914f, 0.143570f, 0.105764f, 0.023141f, -0.042734f, -0.025113f, // 8064
-0.061986f, 0.000908f, -0.111244f, -0.074490f, -0.124482f, -0.003376f, 0.076888f, // 8071
0.113475f, 0.146598f, 0.129518f, 0.132284f, 0.137302f, 0.129939f, 0.131095f, // 8078
0.184480f, 0.233094f, 0.196082f, 0.199535f, 0.129682f, 0.121973f, 0.139485f, // 8085
0.000891f, -0.051118f, -0.119106f, -0.045959f, -0.127930f, 0.016651f, 0.058730f, // 8092
0.007823f, -0.011882f, 0.065546f, 0.092214f, 0.054011f, 0.029531f, 0.085244f, // 8099
0.098458f, 0.096556f, 0.065611f, 0.070251f, 0.091216f, 0.117816f, 0.104503f, // 8106
0.092384f, 0.128088f, -0.007660f, -0.083488f, -0.096364f, -0.022895f, -0.109380f, // 8113
0.064291f, 0.029745f, -0.003584f, -0.106044f, 0.020354f, 0.049134f, 0.062946f, // 8120
0.123081f, 0.154807f, 0.192421f, 0.196548f, 0.105921f, 0.123354f, 0.118112f, // 8127
0.113582f, 0.095198f, 0.023969f, -0.031707f, -0.102917f, 0.035386f, -0.016011f, // 8134
0.017314f, -0.119231f, 0.041938f, -0.001574f, -0.052199f, -0.127642f, -0.075956f, // 8141
0.006700f, -0.063264f, -0.017441f, 0.018310f, 0.049476f, 0.079837f, 0.094040f, // 8148
0.047318f, 0.077252f, -0.000956f, -0.043733f, -0.014555f, 0.029114f, -0.122490f, // 8155
-0.049601f, -0.085600f, 0.034898f, -0.184947f, -0.023811f, -0.011417f, -0.076581f, // 8162
-0.086806f, -0.092456f, -0.092305f, -0.092746f, -0.097730f, -0.023233f, 0.047366f, // 8169
0.013059f, -0.065099f, -0.075565f, -0.081838f, -0.063265f, -0.048837f, -0.055777f, // 8176
0.011009f, -0.071300f, -0.112991f, -0.168795f, -0.018944f, -0.215345f, -0.129717f, // 8183
-0.051631f, -0.032523f, -0.189862f, -0.144531f, -0.175105f, -0.171053f, -0.138615f, // 8190
0.017378f, 0.015866f, -0.117223f, -0.228705f, -0.169015f, -0.121791f, -0.161990f, // 8197
-0.132570f, -0.151858f, 0.013077f, -0.075924f, -0.029194f, -0.035925f, 0.011205f, // 8204
-0.202227f, -0.070866f, -0.076952f, -0.015741f, -0.097446f, -0.120821f, -0.100258f, // 8211
-0.107745f, -0.153064f, -0.104209f, -0.003442f, -0.166640f, -0.152683f, -0.151466f, // 8218
-0.037624f, -0.057207f, -0.075862f, -0.046839f, 0.039255f, 0.036831f, 0.016785f, // 8225
0.006108f, 0.022461f, -0.225237f, -0.103488f, -0.137400f, -0.095713f, -0.140848f, // 8232
-0.107823f, -0.060649f, -0.004851f, -0.137440f, -0.153445f, -0.132588f, -0.066959f, // 8239
-0.097752f, -0.065258f, -0.039340f, -0.079834f, -0.099464f, -0.048739f, -0.035390f, // 8246
-0.024546f, -0.016296f, 0.005463f, -0.025587f, -0.240131f, -0.091685f, -0.029753f, // 8253
-0.027440f, -0.050314f, -0.083399f, -0.055360f, -0.111557f, -0.116070f, -0.206275f, // 8260
-0.223144f, -0.171146f, -0.074227f, -0.025473f, -0.050716f, -0.157127f, -0.189475f, // 8267
-0.140297f, -0.131088f, -0.126995f, -0.074634f, -0.040351f, -0.010946f, -0.268612f, // 8274
-0.210135f, -0.045163f, 0.051825f, 0.039379f, -0.073736f, -0.017838f, -0.062818f, // 8281
-0.088215f, -0.304379f, -0.280068f, -0.237367f, -0.180523f, -0.201100f, -0.072962f, // 8288
-0.072575f, -0.219916f, -0.206804f, -0.217591f, -0.131036f, -0.146361f, -0.052851f, // 8295
-0.066407f, -0.386223f, -0.331667f, -0.271041f, -0.104961f, 0.009628f, -0.015153f, // 8302
0.067950f, -0.006058f, -0.127865f, -0.260677f, -0.308197f, -0.360174f, -0.284273f, // 8309
-0.194638f, 0.009277f, -0.026201f, -0.182760f, -0.229910f, -0.191417f, -0.169148f, // 8316
-0.230629f, -0.188553f, -0.052299f, -0.321133f, -0.306052f, -0.185023f, -0.104767f, // 8323
0.044560f, 0.067611f, 0.029006f, -0.040234f, -0.136761f, -0.215324f, -0.301242f, // 8330
-0.243921f, -0.178668f, -0.122591f, -0.041183f, 0.023845f, -0.049740f, -0.117734f, // 8337
-0.259609f, -0.322913f, -0.328006f, -0.190445f, -0.083948f, -0.236585f, -0.026609f, // 8344
-0.173734f, -0.144995f, -0.149718f, -0.176109f, -0.088699f, -0.090327f, -0.148097f, // 8351
-0.180987f, -0.241191f, -0.310259f, -0.320480f, -0.171771f, -0.127575f, -0.106759f, // 8358
-0.166141f, -0.214182f, -0.241755f, -0.187041f, -0.187170f, -0.103710f, -0.030008f, // 8365
-0.615487f, -0.408454f, -0.672384f, -0.572080f, -0.325533f, -0.331737f, -0.301466f, // 8372
-0.250203f, -0.145386f, -0.076237f, -0.076234f, -0.041633f, 0.014331f, -0.117879f, // 8379
-0.149087f, -0.209203f, -0.358098f, -0.349966f, -0.127993f, -0.134771f, -0.253850f, // 8386
-0.443372f, -0.490511f, -1.681151f, -1.137352f, -1.425600f, -0.818963f, -0.482549f, // 8393
-0.551022f, -0.729672f, -0.599232f, -0.536075f, -0.671984f, -0.524356f, -0.436559f, // 8400
-0.539785f, -0.509504f, -0.389674f, -0.438217f, -0.520571f, -0.473113f, -0.510927f, // 8407
-0.752112f, -0.796656f, -0.853298f, -0.699868f, -1.386677f, -1.129500f, -1.212752f, // 8414
-0.819647f, -0.391066f, -0.513570f, -1.014793f, -1.315558f, -1.262646f, -1.012007f, // 8421
-0.795467f, -0.839790f, -0.988926f, -0.796959f, -0.433115f, -0.433701f, -0.647480f, // 8428
-0.580916f, -0.695593f, -1.029616f, -1.247616f, -1.024583f, -0.621937f, -1.172163f, // 8435
-1.281017f, -0.930820f, -0.446081f, -0.230994f, -0.747259f, -0.514935f, -0.594745f, // 8442
-0.938117f, -0.467778f, -0.324377f, -0.466186f, -0.678759f, -0.077938f, 0.135657f, // 8449
-0.344743f, -0.272070f, -0.221411f, -0.530654f, -1.143520f, -0.998028f, -1.050486f, // 8456
-0.481123f, -0.913445f, -1.133336f, -0.936722f, -0.738104f, -0.576894f, -1.017881f, // 8463
-1.122432f, -1.056976f, -1.126814f, -0.496472f, -0.307635f, -0.419570f, -0.786101f, // 8470
-0.385445f, -0.092985f, -0.215983f, -0.309741f, -0.169581f, -0.338804f, -0.792622f, // 8477
-0.786868f, -1.138881f, -0.372315f, -0.424409f, -0.893364f, -0.681037f, -0.455781f, // 8484
-0.754487f, -0.972868f, -0.968495f, -1.055556f, -0.808323f, -0.395576f, -0.226666f, // 8491
-0.248523f, -0.426386f, -0.530811f, -0.170471f, -0.509648f, -0.178060f, 0.030711f, // 8498
0.011041f, -0.204602f, -0.428418f, -0.837359f, -0.459469f, -0.321742f, -0.922896f, // 8505
-0.776437f, -0.425702f, -0.575554f, -0.756338f, -0.806378f, -0.951122f, -0.835101f, // 8512
-0.445439f, -0.281805f, -0.346638f, -0.556657f, -0.527023f, -0.530934f, -0.613837f, // 8519
-0.152986f, -0.077023f, 0.154911f, 0.072135f, -0.077190f, 0.059563f, -0.114468f, // 8526
-0.546913f, -0.897375f, -0.741730f, -0.462247f, -0.547517f, -0.979396f, -1.030992f, // 8533
-1.220568f, -1.008780f, -0.714790f, -0.514414f, -0.271864f, -0.190277f, -0.219129f, // 8540
-0.261119f, -0.127760f, 0.304503f, 0.135163f, -0.007720f, -0.124846f, -0.016181f, // 8547
0.016776f, 0.005218f, -0.593061f, -0.985696f, -0.574777f, -0.394234f, -0.465757f, // 8554
-0.912652f, -1.065097f, -0.993803f, -1.064391f, -0.677164f, -0.320411f, -0.395713f, // 8561
-0.222865f, -0.020743f, 0.080064f, -0.003764f, 0.166061f, -0.034442f, -0.032693f, // 8568
-0.046096f, 0.059951f, -0.025223f, -0.007163f, -0.870468f, -0.953413f, -1.014024f, // 8575
-0.906728f, -1.070786f, -1.314874f, -1.431167f, -1.134969f, -0.847678f, -0.676465f, // 8582
-0.418460f, -0.520906f, -0.535630f, -0.314780f, -0.219734f, 0.052035f, 0.229861f, // 8589
-0.011670f, 0.171698f, 0.193800f, 0.321508f, 0.078517f, -0.081033f, -0.621957f, // 8596
-1.026819f, -1.317942f, -1.335745f, -1.546060f, -1.579617f, -1.716820f, -1.306739f, // 8603
-0.996960f, -0.625169f, -0.668499f, -0.838546f, -0.772726f, -0.575677f, -0.406908f, // 8610
-0.022779f, 0.155790f, -0.055634f, 0.118898f, 0.021765f, 0.215653f, -0.033341f, // 8617
-0.147256f, -0.605150f, -0.723391f, -1.031278f, -0.937323f, -1.266367f, -1.445338f, // 8624
-1.434942f, -1.273464f, -0.976194f, -0.491563f, -0.402791f, -0.534918f, -0.550997f, // 8631
-0.740909f, -0.412677f, -0.181186f, 0.022551f, -0.030520f, -0.028006f, -0.201512f, // 8638
0.058874f, -0.215301f, -0.136372f, 0.042084f, -0.143236f, 0.096456f, 0.156022f, // 8645
-0.218285f, -0.539610f, -0.654505f, -0.668711f, -0.462851f, -0.371816f, -0.471179f, // 8652
-0.520054f, -0.827956f, -0.655230f, -0.239056f, 0.095847f, 0.252170f, -0.117867f, // 8659
0.144725f, -0.228730f, -0.049046f, -0.456172f, -0.242715f, 0.298146f, 0.153660f, // 8666
0.372467f, 0.118452f, -0.082252f, -0.147037f, -0.262699f, -0.424326f, -0.443673f, // 8673
-0.380084f, -0.436797f, -0.557953f, -0.555230f, -0.530276f, -0.407090f, -0.179779f, // 8680
0.107233f, 0.123341f, 0.219532f, 0.459820f, -0.040224f, -0.342317f, -0.307089f, // 8687
-1.235094f, -1.134390f, -1.447558f, -1.454211f, -1.329066f, -1.257669f, -1.071246f, // 8694
-1.181688f, -0.863572f, -0.840695f, -0.811997f, -0.770857f, -0.688260f, -0.736073f, // 8701
-0.809122f, -0.888204f, -0.996972f, -1.204703f, -0.993569f, -0.976076f, -0.859730f, // 8708
-0.812841f, -0.757293f, -2.507214f, -1.941302f, -2.271835f, -1.602733f, -1.169798f, // 8715
-1.330436f, -1.421400f, -1.298957f, -1.255523f, -1.149385f, -1.132486f, -1.081974f, // 8722
-1.128253f, -1.104754f, -1.177161f, -1.097994f, -1.251488f, -1.312171f, -1.357378f, // 8729
-1.463442f, -1.583763f, -1.463742f, -1.002638f, -2.239825f, -1.902652f, -1.934190f, // 8736
-1.559110f, -1.211431f, -1.294447f, -1.765486f, -2.000784f, -1.884771f, -1.714412f, // 8743
-1.573019f, -1.492981f, -1.588760f, -1.410377f, -1.160444f, -1.069259f, -1.289526f, // 8750
-1.178262f, -1.411436f, -1.779096f, -2.009921f, -1.491559f, -0.978487f, -1.929228f, // 8757
-1.891460f, -1.743386f, -1.066904f, -0.927517f, -1.390669f, -1.264077f, -1.586951f, // 8764
-1.548393f, -0.938862f, -0.799481f, -0.796198f, -1.079693f, -0.767423f, -0.596842f, // 8771
-0.943800f, -0.927565f, -0.810138f, -1.230109f, -2.050226f, -2.125139f, -1.669255f, // 8778
-0.814759f, -1.533185f, -1.649796f, -1.516448f, -1.255150f, -1.244519f, -1.913820f, // 8785
-2.049270f, -1.785320f, -1.653616f, -0.895878f, -0.607418f, -0.687677f, -1.225806f, // 8792
-1.053730f, -0.785242f, -0.895737f, -0.780279f, -0.646428f, -0.854151f, -1.577007f, // 8799
-1.716475f, -1.835908f, -0.682954f, -0.981528f, -1.614563f, -1.423066f, -0.989164f, // 8806
-1.385191f, -1.898486f, -2.009432f, -2.106657f, -1.645840f, -0.922672f, -0.722134f, // 8813
-0.841842f, -1.135849f, -1.238578f, -1.010656f, -1.178237f, -0.674667f, -0.489323f, // 8820
-0.555551f, -0.977596f, -1.152388f, -1.454643f, -0.752920f, -0.854907f, -1.747652f, // 8827
-1.591623f, -1.071771f, -1.212686f, -1.579910f, -1.808635f, -1.992250f, -1.678518f, // 8834
-1.154944f, -0.899381f, -0.985444f, -1.364324f, -1.355100f, -1.397497f, -1.640502f, // 8841
-0.973982f, -0.701304f, -0.490170f, -0.617450f, -0.656357f, -0.537317f, -0.540024f, // 8848
-1.067362f, -1.517446f, -1.410844f, -1.138084f, -1.314301f, -1.933428f, -2.043622f, // 8855
-2.380652f, -2.100252f, -1.716797f, -1.597703f, -1.293617f, -1.125153f, -0.945563f, // 8862
-1.088334f, -0.804990f, -0.270810f, -0.396104f, -0.617428f, -0.703599f, -0.722996f, // 8869
-0.671397f, -0.281463f, -1.113015f, -1.637485f, -1.386200f, -1.417236f, -1.310713f, // 8876
-1.947009f, -2.055949f, -2.074023f, -1.979025f, -1.514824f, -1.259628f, -1.419230f, // 8883
-1.316805f, -0.923131f, -0.743853f, -0.594628f, -0.566250f, -0.626115f, -0.613845f, // 8890
-0.631734f, -0.598062f, -0.718050f, -0.418295f, -1.445685f, -1.838384f, -2.167551f, // 8897
-2.108016f, -2.149146f, -2.311984f, -2.317816f, -2.097418f, -2.024199f, -1.741049f, // 8904
-1.708325f, -1.760029f, -1.928902f, -1.641002f, -1.220111f, -0.684657f, -0.570928f, // 8911
-0.549400f, -0.472171f, -0.452016f, -0.438318f, -0.650211f, -0.581957f, -1.360259f, // 8918
-2.151419f, -2.496101f, -2.600035f, -2.493461f, -2.528308f, -2.606654f, -2.295084f, // 8925
-2.177686f, -2.033594f, -2.229181f, -2.422539f, -2.350749f, -2.001903f, -1.656567f, // 8932
-1.111935f, -0.673135f, -0.678490f, -0.474094f, -0.801233f, -0.942016f, -1.102736f, // 8939
-0.795988f, -1.422582f, -1.957055f, -2.483821f, -2.518141f, -2.635396f, -2.601667f, // 8946
-2.633818f, -2.694251f, -2.417487f, -2.155700f, -2.119168f, -2.191557f, -2.155082f, // 8953
-2.379596f, -1.962655f, -1.510263f, -1.133180f, -0.901965f, -0.944543f, -1.109666f, // 8960
-1.399496f, -1.284317f, -0.715882f, -0.229950f, -1.005522f, -0.902011f, -1.057976f, // 8967
-1.399890f, -1.728799f, -1.777840f, -1.830595f, -1.601023f, -1.652158f, -1.753259f, // 8974
-1.901076f, -2.218971f, -2.043459f, -1.649532f, -1.283080f, -1.032293f, -1.193893f, // 8981
-0.951385f, -1.189552f, -1.124056f, -1.326696f, -0.701647f, -0.292020f, -0.528888f, // 8988
-0.624661f, -0.871879f, -1.005243f, -1.089332f, -1.290200f, -1.438130f, -1.461012f, // 8995
-1.494611f, -1.561566f, -1.638482f, -1.463740f, -1.439452f, -1.266565f, -1.150664f, // 9002
-1.002208f, -0.905853f, -0.806329f, -0.591967f, -1.073054f, -1.222764f, -0.944021f, // 9009
-0.024253f, 0.016202f, 0.039598f, 0.020655f, 0.004688f, -0.013079f, -0.028247f, // 9016
-0.027022f, -0.015749f, -0.007268f, 0.013010f, 0.007919f, 0.005934f, -0.007786f, // 9023
0.003536f, 0.009194f, -0.006358f, -0.013214f, -0.018243f, -0.001018f, 0.006653f, // 9030
0.001821f, 0.006306f, -0.000393f, 0.058477f, 0.087886f, 0.056523f, 0.050695f, // 9037
0.034637f, -0.013759f, -0.059786f, -0.037367f, -0.011415f, -0.013293f, -0.007430f, // 9044
-0.021800f, -0.016988f, -0.008569f, 0.001178f, -0.024538f, -0.050245f, -0.092631f, // 9051
-0.088652f, -0.005868f, 0.012240f, 0.022765f, 0.011111f, 0.047305f, 0.078888f, // 9058
0.054581f, 0.049234f, 0.024505f, -0.023046f, -0.036400f, -0.059894f, -0.029842f, // 9065
-0.036072f, -0.040601f, -0.036290f, -0.011624f, -0.005100f, 0.011235f, -0.005295f, // 9072
-0.026460f, -0.069069f, -0.079314f, -0.031620f, -0.016790f, 0.012508f, 0.030255f, // 9079
0.060338f, 0.106516f, 0.066796f, 0.053109f, 0.020240f, 0.003047f, -0.013217f, // 9086
-0.041657f, -0.024668f, -0.023784f, -0.023874f, -0.028102f, -0.000982f, 0.006831f, // 9093
0.012230f, -0.013734f, -0.023751f, -0.056650f, -0.081603f, -0.072890f, -0.037190f, // 9100
0.044046f, 0.036688f, 0.054719f, 0.103240f, 0.061480f, 0.053811f, 0.010430f, // 9107
0.002455f, -0.005466f, -0.024698f, -0.021467f, -0.018937f, -0.012785f, -0.003470f, // 9114
-0.021046f, 0.005570f, 0.006024f, -0.025126f, -0.036828f, -0.057569f, -0.051158f, // 9121
-0.040910f, -0.030192f, 0.060170f, 0.057273f, 0.074904f, 0.100671f, 0.074365f, // 9128
0.057579f, 0.025897f, -0.020646f, -0.031209f, -0.065157f, -0.037266f, -0.002942f, // 9135
0.000242f, 0.000468f, 0.002412f, 0.000470f, 0.005335f, -0.022338f, -0.039371f, // 9142
-0.072206f, -0.096274f, -0.063934f, -0.015425f, 0.049154f, 0.074785f, 0.073833f, // 9149
0.076271f, 0.056697f, 0.051218f, 0.032995f, -0.015049f, -0.025115f, -0.014653f, // 9156
-0.029191f, 0.008392f, 0.027130f, 0.009904f, 0.007755f, -0.005837f, -0.013056f, // 9163
-0.071185f, -0.049639f, -0.081013f, -0.106752f, -0.087032f, -0.025981f, 0.061599f, // 9170
0.069527f, 0.075566f, 0.087851f, 0.055048f, 0.072063f, 0.072893f, 0.020698f, // 9177
-0.022665f, -0.045992f, -0.032097f, 0.013710f, 0.029919f, 0.024437f, 0.038110f, // 9184
0.008342f, -0.018790f, -0.056696f, -0.037667f, -0.080076f, -0.078356f, -0.043956f, // 9191
-0.004719f, 0.069316f, 0.069266f, 0.077457f, 0.068689f, 0.052644f, 0.049014f, // 9198
0.065978f, 0.026869f, -0.031901f, -0.046522f, -0.032401f, -0.011461f, 0.015265f, // 9205
0.025887f, 0.030551f, 0.014155f, -0.000375f, -0.049346f, -0.044401f, -0.064743f, // 9212
-0.049540f, -0.031056f, -0.009694f, 0.077938f, 0.063253f, 0.045415f, 0.065542f, // 9219
0.041327f, 0.026251f, 0.030530f, 0.014358f, -0.023844f, -0.053302f, -0.039416f, // 9226
-0.025478f, -0.018285f, 0.000373f, 0.007530f, -0.016097f, -0.029284f, -0.067386f, // 9233
-0.060816f, -0.091667f, -0.049902f, -0.020527f, -0.014568f, 0.019859f, 0.032596f, // 9240
0.018238f, 0.041024f, 0.027408f, 0.002101f, -0.006365f, -0.011816f, -0.044829f, // 9247
-0.059931f, -0.067997f, -0.056974f, -0.072222f, -0.053745f, -0.035896f, -0.035063f, // 9254
-0.051732f, -0.067766f, -0.047893f, -0.058371f, -0.059183f, -0.053494f, -0.028853f, // 9261
0.022476f, 0.040718f, 0.009883f, -0.003282f, -0.000698f, -0.014307f, -0.023821f, // 9268
-0.027427f, -0.045441f, -0.046839f, -0.070066f, -0.050131f, -0.059841f, -0.071435f, // 9275
-0.070548f, -0.059843f, -0.062570f, -0.051062f, -0.043626f, -0.068368f, -0.093887f, // 9282
-0.097274f, -0.045256f, 0.015063f, 0.053905f, 0.013745f, 0.016556f, 0.023457f, // 9289
0.018733f, -0.016586f, -0.051840f, -0.044983f, -0.038112f, -0.052873f, -0.052990f, // 9296
-0.052311f, -0.067977f, -0.054716f, -0.048747f, -0.059192f, -0.039107f, -0.015106f, // 9303
-0.043763f, -0.083790f, -0.078236f, -0.036653f, 0.026270f, 0.060030f, 0.053033f, // 9310
0.051456f, 0.047400f, 0.026640f, 0.024181f, 0.011006f, -0.010018f, -0.010325f, // 9317
-0.018102f, -0.021886f, -0.021538f, -0.026348f, -0.021856f, 0.011992f, 0.018094f, // 9324
-0.000488f, 0.013178f, 0.022831f, 0.023496f, 0.001183f, 0.026598f, 0.016767f, // 9331
-0.019406f, -0.037859f, 0.017471f, 0.010788f, 0.034501f, 0.021227f, 0.018984f, // 9338
-0.006755f, -0.021364f, -0.027865f, 0.020042f, 0.019371f, 0.033215f, 0.038900f, // 9345
0.032161f, 0.016250f, 0.044050f, 0.022702f, -0.032457f, -0.015885f, -0.004835f, // 9352
-0.025213f, -0.034331f, 0.041904f, -0.016651f, 0.049096f, 0.063724f, 0.086754f, // 9359
0.092693f, 0.028108f, 0.040292f, 0.046335f, 0.057084f, 0.036497f, 0.040047f, // 9366
0.100201f, 0.120704f, 0.047231f, 0.042594f, 0.083906f, 0.091357f, 0.056638f, // 9373
0.019951f, -0.018591f, -0.021699f, -0.029437f, 0.049737f, 0.013683f, 0.144931f, // 9380
0.098050f, 0.114271f, 0.129029f, 0.122686f, 0.128686f, 0.135206f, 0.168536f, // 9387
0.173264f, 0.165808f, 0.151078f, 0.154420f, 0.117570f, 0.106759f, 0.139141f, // 9394
0.163500f, 0.129897f, 0.088339f, 0.077969f, 0.056354f, 0.012478f, 0.031500f, // 9401
0.006406f, 0.112673f, 0.082584f, 0.113943f, 0.069470f, 0.137045f, 0.111628f, // 9408
0.159422f, 0.152458f, 0.132845f, 0.164712f, 0.157680f, 0.155844f, 0.124461f, // 9415
0.116426f, 0.098211f, 0.105702f, 0.084725f, 0.086263f, 0.072746f, 0.065678f, // 9422
0.007630f, 0.033866f, -0.007584f, 0.096996f, 0.052542f, 0.027395f, -0.024357f, // 9429
-0.005056f, -0.000302f, 0.062360f, 0.065461f, 0.032842f, 0.047309f, 0.064937f, // 9436
0.048440f, 0.076734f, 0.019499f, 0.008257f, 0.028904f, 0.053196f, 0.073404f, // 9443
0.052718f, 0.041310f, 0.000894f, 0.032534f, 0.002630f, 0.041792f, -0.013289f, // 9450
0.003667f, -0.000740f, 0.035921f, 0.006641f, -0.011134f, 0.001293f, -0.002183f, // 9457
-0.006040f, -0.000146f, 0.018011f, 0.015568f, 0.016286f, 0.018043f, 0.015846f, // 9464
0.029439f, 0.023827f, 0.005482f, 0.008992f, -0.000848f, -0.000806f, -0.043633f, // 9471
-0.042426f, -0.041662f, -0.017706f, 0.019899f, 0.019882f, -0.032507f, -0.039507f, // 9478
-0.032533f, -0.046182f, -0.028963f, 0.000977f, -0.005078f, 0.006165f, 0.017447f, // 9485
-0.014410f, -0.012665f, -0.004286f, -0.011578f, -0.015438f, -0.009993f, -0.018872f, // 9492
0.002602f, -0.061363f, -0.077321f, -0.058666f, -0.058758f, -0.024996f, -0.011773f, // 9499
-0.032858f, -0.040500f, -0.043832f, -0.037501f, -0.012238f, -0.013287f, -0.011989f, // 9506
-0.006328f, 0.000148f, -0.034683f, -0.015183f, -0.017986f, -0.002883f, -0.004336f, // 9513
-0.008095f, -0.010160f, 0.011080f, -0.064027f, -0.088514f, -0.088740f, -0.082370f, // 9520
-0.079195f, -0.076203f, -0.069327f, -0.062432f, -0.035673f, -0.045419f, -0.036274f, // 9527
-0.023473f, -0.055235f, -0.053232f, -0.048320f, -0.050452f, -0.011415f, 0.000665f, // 9534
-0.035659f, -0.027961f, -0.017013f, 0.007546f, 0.004936f, -0.078463f, -0.078938f, // 9541
-0.098131f, -0.101959f, -0.103971f, -0.095638f, -0.073381f, -0.046058f, -0.059411f, // 9548
-0.034924f, -0.060318f, -0.063848f, -0.067636f, -0.040930f, -0.060952f, -0.033958f, // 9555
-0.005541f, -0.002636f, -0.044406f, -0.046830f, -0.007803f, 0.006512f, -0.009540f, // 9562
-0.136739f, -0.088026f, -0.124427f, -0.084927f, -0.094762f, -0.086998f, -0.072611f, // 9569
-0.073482f, -0.079063f, -0.036758f, -0.034665f, -0.079733f, -0.093495f, -0.051173f, // 9576
-0.025314f, -0.030013f, -0.007294f, -0.015299f, -0.041375f, -0.077521f, -0.043949f, // 9583
0.021588f, 0.008692f, -0.096819f, -0.014777f, -0.014443f, 0.029347f, -0.006875f, // 9590
0.014579f, -0.003811f, -0.014900f, -0.039936f, -0.018566f, -0.019991f, -0.024179f, // 9597
-0.034966f, -0.020792f, -0.032059f, -0.014889f, -0.005594f, -0.023717f, -0.046249f, // 9604
-0.069793f, -0.045976f, 0.022988f, 0.041939f, -0.014018f, 0.015134f, 0.051907f, // 9611
0.056346f, 0.017615f, 0.025191f, 0.040016f, 0.041741f, 0.033801f, 0.034544f, // 9618
0.025605f, 0.032939f, 0.050593f, 0.046696f, 0.056018f, 0.035785f, 0.035604f, // 9625
0.014371f, -0.010339f, -0.009203f, -0.012689f, 0.043457f, 0.026336f, 0.010762f, // 9632
0.063934f, 0.033203f, 0.010237f, -0.026645f, -0.032215f, -0.010600f, -0.011943f, // 9639
-0.012170f, -0.021711f, -0.048143f, -0.041276f, -0.024879f, -0.000569f, -0.003576f, // 9646
-0.017554f, -0.015463f, -0.008623f, 0.002729f, -0.006102f, -0.001651f, 0.000011f, // 9653
0.134142f, 0.130873f, 0.187288f, 0.134951f, 0.089317f, 0.159949f, 0.254702f, // 9660
0.206848f, 0.172571f, 0.211056f, 0.173756f, 0.233099f, 0.231812f, 0.180533f, // 9667
0.162286f, 0.134689f, 0.139951f, 0.136514f, 0.159885f, 0.263960f, 0.209861f, // 9674
0.090717f, 0.059307f, 0.272385f, 0.108057f, 0.140757f, 0.100167f, 0.075829f, // 9681
0.085632f, 0.229836f, 0.302963f, 0.199826f, 0.120154f, 0.106564f, 0.194357f, // 9688
0.178719f, 0.091673f, 0.124034f, 0.067787f, 0.109422f, 0.083866f, 0.040904f, // 9695
0.101242f, -0.013142f, -0.033414f, -0.016990f, 0.222565f, 0.084691f, 0.148123f, // 9702
0.047152f, 0.027789f, 0.165629f, 0.203439f, 0.244296f, 0.276075f, 0.170278f, // 9709
0.202171f, 0.261040f, 0.204661f, 0.199734f, 0.242618f, 0.100312f, 0.042509f, // 9716
0.044515f, 0.104272f, 0.175129f, 0.148226f, 0.081847f, -0.021597f, 0.197410f, // 9723
0.030526f, 0.134610f, -0.053993f, -0.060496f, 0.113757f, 0.222999f, 0.304057f, // 9730
0.181418f, 0.132712f, 0.086598f, 0.120324f, 0.137233f, 0.155985f, 0.194554f, // 9737
0.046574f, 0.033837f, 0.061985f, 0.046586f, 0.230739f, 0.196680f, 0.133947f, // 9744
-0.155823f, 0.231160f, 0.040488f, 0.131109f, -0.013212f, -0.048451f, 0.173510f, // 9751
0.277582f, 0.321815f, 0.296904f, 0.243168f, 0.168492f, 0.168816f, 0.174198f, // 9758
0.285651f, 0.155445f, 0.043653f, 0.072701f, 0.091164f, 0.080939f, 0.201750f, // 9765
0.132170f, 0.128355f, -0.086426f, 0.240607f, 0.061839f, 0.100652f, 0.010450f, // 9772
0.054389f, 0.179647f, 0.293330f, 0.285781f, 0.357535f, 0.264150f, 0.172296f, // 9779
0.159008f, 0.225257f, 0.315145f, 0.281748f, 0.123363f, 0.017196f, 0.054141f, // 9786
0.040103f, 0.186706f, 0.120801f, 0.101810f, -0.085167f, 0.162457f, 0.034737f, // 9793
0.021838f, 0.051812f, 0.084110f, 0.252830f, 0.352949f, 0.303518f, 0.300176f, // 9800
0.255125f, 0.176256f, 0.206933f, 0.245015f, 0.341778f, 0.316854f, 0.324818f, // 9807
0.225226f, 0.163280f, 0.080401f, 0.169673f, 0.063182f, 0.072939f, -0.060471f, // 9814
0.133178f, -0.013806f, -0.009984f, 0.073382f, 0.113176f, 0.185204f, 0.310976f, // 9821
0.255301f, 0.306706f, 0.291708f, 0.202910f, 0.188255f, 0.175477f, 0.241511f, // 9828
0.382289f, 0.285729f, 0.197480f, 0.110950f, 0.051824f, 0.072127f, 0.112781f, // 9835
-0.031102f, -0.076693f, 0.113022f, -0.025570f, 0.034005f, 0.089548f, 0.104626f, // 9842
0.182808f, 0.255094f, 0.235169f, 0.194409f, 0.198684f, 0.194510f, 0.143279f, // 9849
0.156454f, 0.209646f, 0.233126f, 0.127745f, 0.094116f, 0.095649f, 0.071184f, // 9856
0.060216f, 0.043536f, -0.025267f, -0.126876f, 0.178262f, 0.014639f, 0.123563f, // 9863
0.149964f, 0.117312f, 0.145277f, 0.216000f, 0.229098f, 0.277515f, 0.276806f, // 9870
0.174596f, 0.185630f, 0.236103f, 0.268350f, 0.251980f, 0.175490f, 0.159463f, // 9877
0.124498f, 0.134267f, 0.059929f, 0.034917f, 0.029527f, 0.005022f, 0.317392f, // 9884
0.141675f, 0.260011f, 0.234603f, 0.109618f, 0.074320f, 0.206308f, 0.207148f, // 9891
0.238303f, 0.321134f, 0.317351f, 0.382862f, 0.534651f, 0.458160f, 0.316799f, // 9898
0.178895f, 0.170137f, 0.109289f, 0.115540f, 0.137141f, 0.220339f, 0.026272f, // 9905
0.033770f, 0.298010f, 0.199226f, 0.385464f, 0.306324f, 0.155814f, 0.136993f, // 9912
0.302896f, 0.349604f, 0.349273f, 0.394101f, 0.397886f, 0.472565f, 0.507138f, // 9919
0.466021f, 0.349847f, 0.216735f, 0.107191f, 0.101526f, 0.231354f, 0.351563f, // 9926
0.348506f, 0.188381f, 0.154250f, 0.281606f, 0.159272f, 0.281400f, 0.235464f, // 9933
0.177211f, 0.278108f, 0.351695f, 0.300896f, 0.303534f, 0.340278f, 0.351147f, // 9940
0.366197f, 0.402502f, 0.334584f, 0.332355f, 0.244270f, 0.127501f, 0.087738f, // 9947
0.247616f, 0.350636f, 0.261268f, 0.233096f, 0.106820f, 0.223401f, 0.180813f, // 9954
0.244162f, 0.243108f, 0.217226f, 0.233262f, 0.316315f, 0.300207f, 0.271445f, // 9961
0.288770f, 0.285198f, 0.272523f, 0.281157f, 0.335209f, 0.280871f, 0.213890f, // 9968
0.114401f, 0.078052f, 0.219304f, 0.282354f, 0.261820f, 0.200724f, 0.128256f, // 9975
0.157853f, 0.129652f, 0.084090f, 0.109709f, 0.042463f, 0.120097f, 0.141142f, // 9982
0.129268f, 0.078393f, 0.074744f, -0.036191f, 0.035709f, 0.049740f, 0.056524f, // 9989
0.015016f, 0.072919f, 0.050029f, 0.031363f, 0.025808f, 0.170690f, 0.131959f, // 9996
0.144554f, 0.120886f, 0.443203f, 0.235551f, 0.222435f, 0.067614f, -0.092692f, // 10003
-0.084259f, 0.118503f, 0.017692f, -0.003896f, 0.050562f, 0.019452f, 0.009958f, // 10010
0.008804f, -0.044185f, 0.018485f, -0.082327f, -0.101905f, -0.147064f, -0.022122f, // 10017
0.143494f, 0.132292f, 0.235221f, 0.199433f, 0.573885f, 0.154906f, 0.040666f, // 10024
-0.209283f, -0.360154f, -0.205342f, -0.061769f, -0.044074f, -0.008785f, -0.129805f, // 10031
-0.215192f, -0.189700f, -0.255121f, -0.171467f, -0.131462f, -0.347035f, -0.426725f, // 10038
-0.292520f, -0.034438f, 0.085262f, 0.105063f, 0.108841f, -0.040557f, 0.530002f, // 10045
0.106057f, -0.083001f, -0.322769f, -0.464111f, -0.276480f, -0.234772f, -0.144498f, // 10052
-0.235757f, -0.342195f, -0.379478f, -0.481681f, -0.466477f, -0.486849f, -0.363360f, // 10059
-0.456484f, -0.349432f, -0.263921f, -0.064228f, 0.082148f, 0.215608f, 0.170940f, // 10066
0.102025f, 0.524632f, 0.072431f, -0.061204f, -0.175090f, -0.252157f, -0.074808f, // 10073
0.085498f, 0.125491f, 0.020143f, -0.169962f, -0.163602f, -0.213500f, -0.172475f, // 10080
-0.059387f, -0.216742f, -0.196222f, -0.084731f, -0.074004f, -0.024685f, 0.056222f, // 10087
0.055524f, 0.154980f, 0.143294f, 0.523377f, 0.094115f, 0.001423f, -0.096175f, // 10094
-0.056199f, 0.000800f, 0.146760f, 0.132449f, 0.072288f, -0.020875f, -0.143450f, // 10101
-0.180407f, -0.024244f, -0.001980f, 0.009678f, -0.083478f, -0.162041f, -0.175992f, // 10108
-0.113311f, -0.008933f, 0.118141f, 0.176474f, 0.180245f, 0.453772f, 0.194243f, // 10115
0.005896f, -0.004563f, -0.005784f, 0.157713f, 0.188901f, 0.135296f, 0.129423f, // 10122
0.052610f, 0.006387f, 0.055918f, 0.102803f, 0.147219f, 0.192688f, 0.172359f, // 10129
0.065937f, -0.010796f, -0.072831f, 0.046525f, 0.139121f, 0.201519f, 0.180012f, // 10136
0.433812f, 0.207412f, 0.032616f, 0.044102f, -0.019024f, 0.043444f, 0.152105f, // 10143
0.143068f, 0.116161f, 0.016117f, -0.006009f, -0.047405f, -0.045269f, 0.043363f, // 10150
0.146152f, 0.016229f, -0.130912f, -0.106354f, -0.050000f, -0.022674f, 0.021382f, // 10157
0.073027f, 0.154296f, 0.461508f, 0.190268f, -0.003119f, 0.008493f, -0.048595f, // 10164
-0.049538f, 0.039326f, 0.118168f, 0.075516f, -0.048525f, -0.122381f, -0.117127f, // 10171
-0.142611f, -0.106344f, -0.103188f, -0.194133f, -0.164006f, -0.118574f, -0.051375f, // 10178
-0.067918f, -0.106743f, 0.012473f, 0.066666f, 0.516858f, 0.231086f, 0.173278f, // 10185
0.186126f, 0.071854f, 0.040757f, 0.123674f, 0.160743f, 0.154235f, 0.109041f, // 10192
-0.103912f, -0.076743f, -0.049958f, 0.008865f, -0.005900f, -0.000241f, -0.061414f, // 10199
-0.043744f, 0.020060f, -0.123271f, -0.127616f, 0.033241f, 0.039450f, 0.640239f, // 10206
0.256086f, 0.199511f, 0.121301f, 0.108703f, 0.109032f, 0.221560f, 0.196171f, // 10213
0.145249f, 0.070858f, 0.052227f, 0.123775f, 0.249767f, 0.108980f, 0.141825f, // 10220
0.072264f, 0.025011f, -0.048439f, -0.014305f, -0.037024f, -0.085776f, -0.020049f, // 10227
0.052244f, 0.632556f, 0.252844f, 0.384779f, 0.359301f, 0.209116f, 0.192092f, // 10234
0.297406f, 0.336094f, 0.269546f, 0.165075f, 0.164556f, 0.173811f, 0.175301f, // 10241
0.202433f, 0.122275f, 0.093494f, 0.085489f, 0.081206f, 0.129601f, 0.179081f, // 10248
0.051280f, 0.016806f, 0.145343f, 0.535738f, 0.287642f, 0.356988f, 0.261887f, // 10255
0.228199f, 0.284188f, 0.328379f, 0.322182f, 0.307156f, 0.360985f, 0.353059f, // 10262
0.323599f, 0.403761f, 0.321035f, 0.341479f, 0.330370f, 0.258071f, 0.202892f, // 10269
0.265482f, 0.387149f, 0.258371f, 0.249124f, 0.181039f, 0.353476f, 0.185702f, // 10276
0.297034f, 0.256016f, 0.139547f, 0.100146f, 0.138842f, 0.193722f, 0.188395f, // 10283
0.240929f, 0.252962f, 0.213559f, 0.222531f, 0.286690f, 0.265035f, 0.179137f, // 10290
0.093865f, 0.098604f, 0.185669f, 0.200128f, 0.251387f, 0.225587f, 0.134849f, // 10297
-0.021119f, 0.002064f, 0.017152f, 0.015445f, 0.004212f, 0.005765f, -0.017522f, // 10304
-0.003529f, -0.037253f, -0.053563f, -0.068887f, -0.068341f, -0.068959f, -0.048946f, // 10311
-0.083214f, -0.053158f, -0.051223f, -0.023983f, -0.014782f, -0.008684f, -0.014010f, // 10318
-0.007201f, 0.000570f, 0.003380f, 0.026550f, 0.068345f, 0.030179f, 0.030697f, // 10325
0.089719f, 0.015148f, -0.011971f, -0.020302f, 0.004708f, 0.016297f, 0.020091f, // 10332
0.004967f, 0.007408f, 0.048260f, 0.000688f, -0.033440f, -0.037540f, -0.058562f, // 10339
-0.042181f, -0.007606f, -0.007122f, 0.002181f, 0.014886f, 0.034777f, 0.074531f, // 10346
0.035748f, 0.039815f, 0.089562f, 0.005898f, -0.009626f, 0.005504f, -0.003557f, // 10353
0.006154f, 0.001806f, -0.005376f, 0.035096f, 0.031370f, 0.004517f, -0.011645f, // 10360
-0.010994f, -0.040112f, -0.030500f, -0.007203f, -0.015609f, -0.003711f, 0.020408f, // 10367
0.045714f, 0.073600f, 0.027949f, 0.022305f, 0.033974f, -0.014225f, -0.018573f, // 10374
-0.004767f, -0.021331f, -0.011655f, -0.008278f, -0.014455f, -0.011569f, -0.006544f, // 10381
-0.010772f, -0.014549f, -0.022118f, -0.026240f, -0.031500f, -0.020603f, -0.014818f, // 10388
-0.001270f, 0.015434f, 0.047407f, 0.060798f, 0.037112f, 0.035491f, 0.014642f, // 10395
0.006331f, 0.004478f, 0.011906f, -0.020538f, -0.004958f, 0.007541f, 0.016632f, // 10402
-0.016253f, -0.002761f, -0.003782f, -0.018081f, -0.016031f, -0.029558f, -0.012271f, // 10409
-0.014201f, -0.011159f, -0.007781f, 0.023423f, 0.064960f, 0.079667f, 0.057068f, // 10416
0.052841f, 0.048489f, -0.003442f, 0.007063f, 0.002741f, -0.008520f, 0.012352f, // 10423
0.019914f, 0.025392f, -0.001744f, 0.000062f, 0.002667f, -0.015661f, -0.021107f, // 10430
-0.032714f, -0.042496f, -0.036110f, -0.005047f, -0.008167f, 0.020990f, 0.057562f, // 10437
0.063076f, 0.040390f, 0.050278f, 0.065062f, 0.016448f, 0.009536f, 0.018845f, // 10444
-0.017776f, 0.027789f, 0.051568f, 0.037266f, 0.015348f, 0.016062f, 0.016811f, // 10451
-0.052882f, -0.036776f, -0.048404f, -0.064836f, -0.052675f, -0.015986f, -0.004131f, // 10458
0.007354f, 0.049249f, 0.057452f, 0.036950f, 0.051509f, 0.062063f, 0.034186f, // 10465
0.005309f, -0.005015f, -0.008965f, 0.024484f, 0.039638f, 0.038831f, 0.028762f, // 10472
0.019582f, 0.005683f, -0.037165f, -0.021371f, -0.054276f, -0.053367f, -0.041394f, // 10479
-0.003410f, 0.012118f, 0.009406f, 0.041875f, 0.051915f, 0.024787f, 0.025145f, // 10486
0.046002f, 0.026237f, -0.004307f, -0.016035f, -0.010604f, -0.005911f, 0.009613f, // 10493
0.018613f, 0.024372f, 0.008733f, 0.011289f, -0.033271f, -0.026126f, -0.047137f, // 10500
-0.042023f, -0.034679f, -0.008666f, 0.014469f, 0.006177f, 0.015118f, 0.062785f, // 10507
0.022725f, 0.019657f, 0.038212f, 0.023191f, -0.001215f, -0.031816f, -0.026164f, // 10514
-0.015454f, 0.003646f, 0.007435f, 0.007860f, -0.003654f, -0.005742f, -0.036979f, // 10521
-0.024948f, -0.066099f, -0.042497f, -0.021910f, -0.013485f, 0.007578f, 0.014288f, // 10528
0.031643f, 0.065420f, 0.057446f, 0.035142f, 0.033687f, 0.000936f, -0.025014f, // 10535
-0.041144f, -0.045056f, -0.023057f, -0.012431f, 0.007443f, 0.011758f, -0.009010f, // 10542
-0.017482f, -0.027708f, -0.010260f, -0.027711f, -0.033234f, -0.020601f, -0.031223f, // 10549
0.009831f, -0.005802f, 0.021130f, 0.051739f, 0.032664f, 0.026032f, 0.032719f, // 10556
-0.001478f, -0.015506f, -0.018838f, -0.018181f, -0.010258f, -0.021287f, -0.029055f, // 10563
-0.018378f, -0.018298f, -0.033921f, -0.038341f, -0.022127f, -0.036094f, -0.053200f, // 10570
-0.073115f, -0.033641f, 0.000925f, -0.027065f, -0.002506f, 0.026324f, 0.015051f, // 10577
0.022931f, 0.031728f, -0.010187f, -0.033874f, -0.028033f, -0.033396f, -0.023237f, // 10584
-0.034760f, -0.035572f, -0.030506f, -0.023652f, -0.053089f, -0.043282f, -0.027114f, // 10591
-0.036246f, -0.044201f, -0.067436f, -0.029948f, 0.004119f, -0.004820f, 0.010112f, // 10598
0.028946f, 0.031831f, 0.033094f, 0.040116f, 0.026630f, 0.006018f, 0.003367f, // 10605
-0.003393f, 0.004665f, 0.008886f, 0.010533f, 0.002312f, 0.001535f, 0.001513f, // 10612
-0.025944f, -0.022660f, -0.009400f, -0.006452f, 0.005187f, 0.010718f, 0.007556f, // 10619
0.007383f, -0.011969f, -0.005160f, -0.015363f, -0.015128f, -0.012335f, 0.014843f, // 10626
0.013445f, 0.014978f, 0.006863f, 0.022900f, 0.023652f, 0.021998f, 0.020912f, // 10633
-0.010206f, -0.002196f, 0.012787f, -0.002232f, -0.016476f, 0.008443f, 0.017654f, // 10640
-0.005043f, -0.007771f, 0.008523f, -0.031489f, -0.042044f, -0.028759f, -0.039989f, // 10647
-0.048994f, -0.042346f, -0.021164f, -0.016605f, -0.010841f, -0.000276f, -0.015804f, // 10654
0.012822f, 0.012231f, -0.023591f, -0.039722f, -0.029646f, -0.033090f, -0.023647f, // 10661
-0.012971f, -0.003831f, -0.013474f, 0.006015f, 0.031424f, -0.003302f, -0.000860f, // 10668
0.006045f, 0.010877f, -0.012165f, -0.015766f, 0.011232f, 0.001054f, -0.005731f, // 10675
-0.077351f, -0.092418f, 0.009213f, 0.050678f, 0.031087f, -0.006144f, 0.001118f, // 10682
0.014999f, -0.030570f, 0.003714f, 0.019970f, 0.010761f, 0.014358f, 0.026706f, // 10689
-0.001736f, -0.004345f, 0.012853f, 0.010498f, 0.009789f, -0.029461f, -0.039047f, // 10696
0.011003f, -0.025803f, -0.015946f, -0.005098f, 0.002084f, 0.037871f, 0.017963f, // 10703
0.005237f, 0.042786f, 0.020962f, -0.020721f, -0.013435f, 0.011501f, 0.010854f, // 10710
0.028423f, 0.042125f, 0.003004f, 0.028775f, 0.017946f, 0.011913f, -0.000145f, // 10717
0.005389f, -0.014293f, 0.020955f, 0.005922f, 0.032317f, 0.013434f, 0.008916f, // 10724
0.045657f, 0.057255f, 0.039470f, 0.014708f, -0.006747f, -0.018635f, -0.018683f, // 10731
0.006005f, -0.000710f, 0.031785f, 0.038826f, 0.009152f, 0.014541f, 0.006626f, // 10738
0.017828f, 0.002071f, -0.007683f, -0.012487f, 0.006186f, 0.025489f, 0.037338f, // 10745
0.029422f, 0.018811f, 0.037089f, 0.043765f, 0.038045f, 0.013414f, 0.008507f, // 10752
-0.006819f, -0.016617f, -0.013139f, -0.010406f, 0.036528f, 0.022352f, -0.000772f, // 10759
0.005509f, -0.012965f, -0.005361f, -0.003252f, 0.014054f, 0.010436f, -0.004143f, // 10766
0.014824f, -0.008287f, -0.008839f, -0.011360f, -0.001385f, 0.021854f, 0.025083f, // 10773
-0.016600f, -0.001198f, -0.006648f, -0.017117f, -0.013201f, -0.022606f, 0.020471f, // 10780
0.011556f, -0.005985f, -0.031360f, -0.026017f, -0.021295f, -0.009324f, 0.007138f, // 10787
0.013140f, 0.003211f, 0.017265f, 0.009913f, 0.001788f, -0.006111f, -0.002175f, // 10794
0.002402f, 0.019562f, -0.019561f, 0.009566f, -0.003256f, -0.017170f, -0.017990f, // 10801
-0.028036f, 0.018736f, 0.027522f, -0.010480f, -0.031790f, -0.041541f, -0.037908f, // 10808
-0.021785f, -0.012032f, -0.005226f, -0.009412f, 0.018517f, 0.023305f, 0.012403f, // 10815
-0.012727f, -0.013427f, -0.011885f, 0.004601f, -0.003055f, -0.005116f, 0.008244f, // 10822
-0.009072f, -0.001502f, -0.010842f, 0.034376f, 0.035102f, 0.010862f, -0.012406f, // 10829
-0.021475f, -0.022226f, -0.033488f, -0.018408f, -0.017675f, -0.020172f, -0.028314f, // 10836
-0.000064f, -0.023839f, -0.032270f, -0.035167f, -0.034428f, -0.045862f, -0.019275f, // 10843
-0.008112f, 0.002863f, 0.011325f, 0.021941f, -0.006413f, 0.031695f, 0.043787f, // 10850
0.016201f, 0.021938f, -0.013365f, 0.000507f, -0.018343f, -0.028443f, -0.022916f, // 10857
-0.031232f, -0.021209f, -0.014412f, -0.030157f, -0.055645f, -0.048598f, -0.042710f, // 10864
-0.018144f, -0.020627f, -0.012120f, -0.007918f, -0.024739f, -0.041640f, -0.016402f, // 10871
0.014412f, 0.043392f, 0.016557f, 0.007242f, 0.007825f, 0.007787f, -0.023165f, // 10878
-0.033685f, -0.015805f, -0.020091f, -0.010725f, -0.009495f, -0.004898f, -0.003638f, // 10885
-0.035342f, -0.026994f, -0.027275f, -0.024699f, -0.011374f, -0.016783f, -0.013557f, // 10892
-0.027494f, -0.022706f, 0.018439f, 0.080233f, 0.030883f, 0.034231f, 0.048723f, // 10899
0.006590f, -0.021137f, 0.008013f, 0.026846f, 0.032806f, 0.035163f, 0.029888f, // 10906
0.006878f, 0.008757f, 0.004308f, -0.010653f, -0.029498f, -0.030979f, -0.018846f, // 10913
-0.011810f, 0.001395f, 0.018016f, 0.009737f, 0.034681f, 0.125502f, 0.083616f, // 10920
0.098186f, 0.066320f, 0.036836f, 0.017801f, 0.021271f, 0.006480f, 0.016340f, // 10927
0.029691f, 0.021475f, 0.010285f, -0.002569f, 0.004738f, 0.027833f, -0.014140f, // 10934
-0.022401f, 0.009319f, 0.016925f, 0.044875f, 0.048212f, 0.040538f, 0.026954f, // 10941
0.089365f, 0.171623f, 0.183419f, 0.109153f, 0.008920f, -0.005268f, 0.079391f, // 10948
0.181484f, 0.221502f, 0.301432f, 0.245465f, 0.178735f, 0.167280f, 0.087131f, // 10955
0.104885f, 0.085488f, 0.127611f, 0.179778f, 0.186545f, 0.193322f, 0.137144f, // 10962
0.093165f, 0.045933f, 0.127758f, 0.128782f, 0.182318f, 0.170215f, 0.111027f, // 10969
0.012571f, 0.111084f, 0.208581f, 0.261618f, 0.241546f, 0.205122f, 0.166586f, // 10976
0.150064f, 0.112286f, 0.094040f, 0.052596f, 0.040280f, 0.117006f, 0.088549f, // 10983
0.200764f, 0.181961f, 0.171057f, 0.026360f, 0.055773f, 0.153400f, 0.206458f, // 10990
0.140092f, 0.013567f, -0.124087f, -0.074745f, 0.086788f, 0.229223f, 0.265010f, // 10997
0.149984f, 0.061244f, 0.122255f, 0.106212f, 0.091548f, 0.105602f, 0.042319f, // 11004
0.090399f, 0.106539f, 0.144846f, 0.208434f, 0.090812f, -0.027328f, 0.026184f, // 11011
0.019913f, 0.087203f, 0.021758f, -0.020980f, -0.038680f, 0.067617f, 0.096001f, // 11018
0.100507f, 0.122435f, 0.137132f, 0.100987f, 0.101330f, 0.164305f, 0.111835f, // 11025
0.082295f, 0.054428f, 0.055238f, 0.108713f, 0.171381f, 0.268644f, 0.190879f, // 11032
-0.042472f, 0.035493f, 0.021445f, 0.047578f, 0.069387f, 0.029073f, -0.099701f, // 11039
0.042160f, 0.110137f, 0.093780f, 0.039198f, 0.079056f, 0.114906f, 0.133875f, // 11046
0.082938f, 0.116710f, 0.035944f, -0.016574f, -0.028131f, 0.160491f, 0.251740f, // 11053
0.278851f, 0.197096f, -0.020409f, 0.048202f, -0.022982f, 0.027003f, 0.087574f, // 11060
0.050301f, -0.061789f, 0.037539f, 0.171122f, 0.187448f, 0.068708f, 0.168954f, // 11067
0.176144f, 0.134149f, 0.081330f, 0.109427f, 0.111904f, -0.050537f, -0.052419f, // 11074
0.136737f, 0.168218f, 0.230369f, 0.192291f, 0.061846f, 0.069243f, 0.040503f, // 11081
0.116984f, 0.047292f, -0.016641f, -0.005253f, 0.120854f, 0.303062f, 0.278659f, // 11088
0.207545f, 0.225764f, 0.261018f, 0.299203f, 0.251835f, 0.214025f, 0.189486f, // 11095
-0.061766f, 0.008055f, 0.028722f, 0.079120f, 0.227256f, 0.227488f, 0.106887f, // 11102
0.026501f, 0.057263f, 0.125677f, 0.029382f, -0.099463f, -0.016707f, 0.128830f, // 11109
0.252882f, 0.253895f, 0.179230f, 0.243578f, 0.250919f, 0.299046f, 0.290192f, // 11116
0.129684f, 0.106144f, -0.113268f, -0.068025f, 0.014203f, 0.052894f, 0.147977f, // 11123
0.169169f, 0.025639f, 0.091986f, 0.115918f, 0.132497f, 0.091220f, -0.019490f, // 11130
-0.017315f, 0.091893f, 0.170880f, 0.164375f, 0.117495f, 0.136093f, 0.181008f, // 11137
0.285416f, 0.235425f, 0.114949f, 0.042768f, -0.080565f, -0.006467f, 0.027247f, // 11144
0.104239f, 0.163796f, 0.078792f, -0.019449f, 0.104845f, 0.136435f, 0.207562f, // 11151
0.173262f, 0.118316f, 0.058507f, 0.084827f, 0.104950f, 0.092098f, 0.133829f, // 11158
0.088539f, 0.117095f, 0.185574f, 0.184689f, 0.092209f, -0.020474f, -0.075928f, // 11165
0.010599f, 0.001223f, 0.126269f, 0.150583f, 0.035359f, -0.057071f, 0.149468f, // 11172
0.164524f, 0.234478f, 0.268674f, 0.102004f, -0.000655f, 0.012119f, 0.060441f, // 11179
0.057961f, 0.127146f, 0.110001f, 0.215480f, 0.301516f, 0.234565f, 0.067739f, // 11186
-0.082174f, -0.036586f, 0.038579f, 0.010168f, 0.073520f, 0.060057f, 0.041080f, // 11193
-0.010699f, 0.111224f, 0.116734f, 0.258576f, 0.081475f, -0.026276f, -0.090014f, // 11200
0.099171f, 0.180210f, 0.192077f, 0.052721f, 0.093854f, 0.154588f, 0.214137f, // 11207
0.217713f, 0.054621f, -0.117976f, -0.096719f, -0.034115f, -0.005008f, 0.133760f, // 11214
0.098982f, 0.029147f, -0.050698f, 0.131068f, 0.080798f, 0.241077f, 0.144551f, // 11221
-0.034795f, -0.031617f, 0.073098f, 0.121893f, 0.145667f, 0.112296f, 0.130054f, // 11228
0.184195f, 0.166412f, 0.123569f, 0.104219f, 0.034654f, -0.030730f, 0.044223f, // 11235
0.148189f, 0.190049f, 0.188924f, 0.151477f, 0.009519f, 0.125824f, 0.039182f, // 11242
0.119518f, 0.081123f, 0.003172f, -0.017910f, 0.055640f, 0.074841f, 0.089727f, // 11249
0.062152f, 0.054038f, 0.016700f, 0.074781f, 0.105803f, 0.098678f, 0.047541f, // 11256
0.015555f, 0.041029f, 0.182911f, 0.189000f, 0.090914f, 0.082061f, -0.024763f, // 11263
0.092854f, 0.050218f, 0.068469f, 0.051209f, 0.028266f, 0.042067f, 0.079662f, // 11270
0.139955f, 0.189111f, 0.192879f, 0.214282f, 0.188707f, 0.168349f, 0.121638f, // 11277
0.095053f, 0.084937f, 0.136770f, 0.159733f, 0.145254f, 0.119170f, 0.112082f, // 11284
0.100497f, 0.113810f, 0.156011f, 0.084704f, 0.088311f, 0.106317f, 0.101516f, // 11291
0.088299f, 0.108758f, 0.123380f, 0.204545f, 0.091270f, 0.089481f, 0.129336f, // 11298
0.102676f, 0.121438f, 0.124212f, 0.049938f, 0.111462f, 0.170129f, 0.157089f, // 11305
0.119073f, 0.050733f, 0.110085f, 0.045524f, 0.104623f, 0.063837f, 0.056369f, // 11312
0.033889f, 0.104903f, 0.055637f, 0.088214f, 0.068870f, 0.093021f, 0.011270f, // 11319
0.060144f, 0.091749f, 0.019379f, -0.010987f, 0.029271f, 0.053478f, 0.088657f, // 11326
0.107864f, 0.100646f, -0.007404f, 0.036918f, 0.046495f, 0.046698f, 0.094431f, // 11333
-0.001015f, 0.059698f, 0.000478f, 0.100832f, 0.041972f, 0.080689f, 0.156137f, // 11340
-0.069594f, -0.070276f, -0.079279f, -0.093832f, -0.029343f, 0.002449f, -0.007294f, // 11347
0.036321f, 0.100596f, 0.125542f, 0.136056f, 0.150432f, 0.165578f, 0.128300f, // 11354
0.070439f, 0.095705f, 0.021224f, 0.032310f, 0.015110f, -0.012993f, -0.050024f, // 11361
0.018594f, 0.068232f, -0.025578f, -0.070829f, -0.129935f, -0.064023f, -0.014342f, // 11368
0.042155f, -0.024490f, -0.008522f, 0.085827f, 0.116866f, 0.149340f, 0.193698f, // 11375
0.154721f, 0.117029f, 0.076673f, 0.143222f, 0.041173f, 0.058693f, 0.059654f, // 11382
-0.003554f, 0.026791f, 0.086748f, 0.126699f, 0.027866f, -0.064438f, -0.110299f, // 11389
-0.078785f, -0.003225f, -0.034664f, -0.059457f, 0.034555f, 0.027040f, 0.034673f, // 11396
0.127902f, 0.155176f, 0.155015f, 0.127886f, 0.124246f, 0.131765f, 0.040570f, // 11403
0.056776f, 0.065977f, 0.004001f, 0.012792f, 0.036015f, 0.078611f, 0.053040f, // 11410
0.043305f, 0.033696f, 0.027453f, 0.038571f, 0.000403f, 0.010048f, -0.002655f, // 11417
-0.036818f, 0.025351f, 0.045451f, 0.043018f, 0.085865f, 0.120151f, 0.121865f, // 11424
0.137877f, 0.027912f, 0.078290f, 0.067748f, -0.008793f, 0.041942f, 0.010295f, // 11431
0.002266f, 0.052742f, 0.066712f, 0.050696f, 0.013219f, 0.031642f, 0.048388f, // 11438
-0.052915f, -0.028217f, -0.134801f, -0.011187f, 0.025479f, 0.034970f, 0.098704f, // 11445
0.113809f, 0.104668f, 0.159992f, 0.040264f, 0.072543f, 0.062951f, 0.032859f, // 11452
0.021043f, 0.007802f, 0.010683f, 0.032700f, 0.062960f, 0.011392f, -0.011100f, // 11459
-0.004372f, -0.033739f, -0.072651f, -0.063491f, -0.070467f, 0.013176f, 0.038222f, // 11466
0.052211f, 0.073484f, 0.063346f, 0.094270f, 0.134783f, 0.055398f, 0.096982f, // 11473
0.088532f, 0.069258f, 0.049074f, -0.007684f, -0.007482f, 0.061655f, 0.093092f, // 11480
0.059278f, 0.080521f, 0.018619f, -0.007261f, -0.004894f, -0.002649f, -0.014118f, // 11487
0.052275f, 0.069493f, 0.021553f, 0.043144f, 0.059543f, 0.060218f, 0.156632f, // 11494
0.067138f, 0.117221f, 0.151591f, 0.029839f, 0.066805f, 0.012610f, 0.040773f, // 11501
0.080360f, 0.110843f, 0.081002f, 0.071433f, 0.040191f, -0.006561f, -0.006757f, // 11508
-0.056685f, -0.020718f, 0.050839f, 0.043750f, 0.089367f, 0.178482f, 0.110839f, // 11515
0.093768f, 0.143836f, 0.041303f, 0.109344f, 0.058095f, 0.059235f, -0.000793f, // 11522
-0.009631f, 0.027749f, 0.078309f, 0.057820f, 0.096137f, 0.031695f, 0.004863f, // 11529
0.044773f, 0.090139f, 0.004327f, -0.008213f, 0.041827f, 0.086424f, 0.130787f, // 11536
0.173727f, 0.146117f, 0.085432f, 0.092014f, -0.034921f, 0.123971f, 0.066985f, // 11543
-0.034434f, -0.004087f, -0.021916f, 0.001222f, -0.020589f, -0.060187f, -0.048583f, // 11550
0.049019f, 0.032826f, -0.025374f, 0.086658f, 0.143491f, 0.087178f, 0.051821f, // 11557
0.127131f, 0.106221f, 0.179145f, 0.114183f, 0.056518f, -0.049120f, -0.265353f, // 11564
-0.116516f, -0.068833f, -0.045336f, -0.064317f, -0.059246f, -0.045547f, -0.020111f, // 11571
-0.042735f, -0.068470f, -0.075152f, -0.063983f, -0.051570f, -0.028071f, -0.039607f, // 11578
-0.032304f, -0.061007f, 0.021732f, 0.020398f, -0.115368f, -0.094854f, -0.119841f, // 11585
};
size_t bbox_pred_data_size = sizeof(bbox_pred_data) / sizeof(bbox_pred_data[0]);
float proposal_ref[] = {
0.0f, 22.352310f, 0.000000f, 349.000000f, 209.000000f, // 0
0.0f, 130.680084f, 0.000000f, 349.000000f, 209.000000f, // 1
0.0f, 0.000000f, 0.000000f, 252.452972f, 209.000000f, // 2
0.0f, 1.774189f, 22.472458f, 59.339947f, 88.426353f, // 3
0.0f, 24.237768f, 67.444435f, 72.869484f, 125.272179f, // 4
0.0f, 0.000000f, 23.966194f, 26.863934f, 49.532013f, // 5
0.0f, 57.724426f, 3.690552f, 308.103027f, 174.179031f, // 6
0.0f, 0.000000f, 108.646774f, 116.770569f, 209.000000f, // 7
0.0f, 0.000000f, 32.020794f, 23.279818f, 70.009903f, // 8
0.0f, 19.225525f, 89.005424f, 56.076027f, 130.468338f, // 9
0.0f, 5.159458f, 54.143593f, 56.088039f, 114.672554f, // 10
0.0f, 330.745087f, 176.481247f, 349.000000f, 209.000000f, // 11
0.0f, 301.384399f, 100.898796f, 349.000000f, 199.248260f, // 12
0.0f, 14.639599f, 28.670826f, 78.429504f, 103.527649f, // 13
0.0f, 283.631805f, 73.577911f, 349.000000f, 189.415466f, // 14
0.0f, 137.680038f, 164.404709f, 197.854782f, 203.887833f, // 15
0.0f, 0.000000f, 0.000000f, 43.068649f, 36.425880f, // 16
0.0f, 35.838318f, 98.144012f, 83.084885f, 143.304626f, // 17
0.0f, 0.000000f, 0.000000f, 211.339508f, 172.520187f, // 18
0.0f, 159.378235f, 155.087418f, 216.235291f, 192.013504f, // 19
0.0f, 8.810448f, 73.558136f, 100.592865f, 209.000000f, // 20
0.0f, 169.873520f, 144.298248f, 220.242905f, 178.490601f, // 21
0.0f, 116.218491f, 169.518890f, 172.685928f, 209.000000f, // 22
0.0f, 324.900055f, 43.218887f, 349.000000f, 126.112991f, // 23
0.0f, 183.979691f, 0.000000f, 341.391418f, 129.322388f, // 24
};
size_t proposal_ref_size = sizeof(proposal_ref) / sizeof(proposal_ref[0]);
| 139,069 |
348 | <filename>docs/data/leg-t2/007/00701072.json
{"nom":"Coux","circ":"1ère circonscription","dpt":"Ardèche","inscrits":1379,"abs":647,"votants":732,"blancs":51,"nuls":27,"exp":654,"res":[{"nuance":"SOC","nom":"M. <NAME>","voix":492},{"nuance":"REM","nom":"M. <NAME>","voix":162}]} | 116 |
5,169 | {
"name": "SMGridView",
"version": "1.0.1",
"summary": "UIScrollView subclass that uses methods similar to UITableView, UITableViewDataSource, and UITableViewDelegate.",
"homepage": "https://github.com/brewster/SMGridView",
"license": "MIT",
"authors": {
"<NAME>": "<EMAIL>",
"<NAME>": "<EMAIL>"
},
"source": {
"git": "https://github.com/brewster/SMGridView.git",
"tag": "1.0.1"
},
"platforms": {
"ios": null
},
"source_files": "SMGridView/source/*.{h,m}",
"frameworks": [
"QuartzCore",
"UIKit",
"Foundation",
"CoreGraphics"
],
"requires_arc": false
}
| 261 |
1,483 | /*
* Copyright Lealone Database Group.
* Licensed under the Server Side Public License, v 1.
* Initial Developer: zhh
*/
package org.lealone.sql;
import java.util.List;
import org.lealone.db.Command;
import org.lealone.db.CommandParameter;
import org.lealone.db.async.Future;
import org.lealone.db.result.Result;
public interface SQLCommand extends Command {
int getFetchSize();
void setFetchSize(int fetchSize);
/**
* Get the parameters (if any).
*
* @return the parameters
*/
List<? extends CommandParameter> getParameters();
/**
* Get an empty result set containing the meta data of the result.
*
* @return the empty result
*/
Result getMetaData();
/**
* Check if this is a query.
*
* @return true if it is a query
*/
boolean isQuery();
/**
* Execute the query.
*
* @param maxRows the maximum number of rows returned
* @return the result
*/
default Future<Result> executeQuery(int maxRows) {
return executeQuery(maxRows, false);
}
/**
* Execute the query.
*
* @param maxRows the maximum number of rows returned
* @param scrollable if the result set must be scrollable
* @return the result
*/
Future<Result> executeQuery(int maxRows, boolean scrollable);
/**
* Execute the update command
*
* @return the update count
*/
Future<Integer> executeUpdate();
}
| 539 |
335 | <filename>A/Accepted_adjective.json
{
"word": "Accepted",
"definitions": [
"Generally believed or recognized to be valid or correct."
],
"parts-of-speech": "Adjective"
} | 77 |
1,799 | // Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "lite/core/scope.h"
#include <gtest/gtest.h>
namespace paddle {
namespace lite {
TEST(Scope, Var) {
Scope scope;
auto* x = scope.Var("x");
*x->GetMutable<int>() = 100;
ASSERT_EQ(x->Get<int>(), 100);
}
TEST(Scope, FindVar) {
Scope scope;
ASSERT_FALSE(scope.FindVar("x"));
scope.Var("x");
ASSERT_TRUE(scope.FindVar("x"));
}
} // namespace lite
} // namespace paddle
| 329 |
2,023 | <reponame>tdiprima/code
import glob
import os
import time
import bs4
import socks
import socket
import magic
import random
import hashlib
# Tor proxy
def create_connection(address, timeout=None, source_address=None):
sock = socks.socksocket()
sock.connect(address)
return sock
socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS5, "127.0.0.1", 9050)
socket.socket = socks.socksocket
socket.create_connection = create_connection
import mechanize
br = mechanize.Browser()
#br.set_debug_http(True)
#br.set_debug_redirects(True)
#br.set_debug_responses(True)
checkmd5url = "http://libgen.io/foreignfiction/index.php?md5="
uploadurl = "http://libgen.io/foreignfiction/librarian"
username = "genesis"
password = "<PASSWORD>"
# Browser options
br.set_handle_equiv(True)
br.set_handle_gzip(True)
br.set_handle_redirect(True)
br.set_handle_referer(True)
br.set_handle_robots(False)
# Follows refresh 0 but not hangs on refresh > 0
br.set_handle_refresh(mechanize._http.HTTPRefreshProcessor(), max_time=1)
br.add_password(uploadurl, username, password)
for filename in sorted(glob.glob("*.epub")):
print "File : %s" % filename
# Getting mimetype
with magic.Magic(flags=magic.MAGIC_MIME_TYPE) as m:
mimetype = m.id_filename(filename)
filesize = os.stat(filename).st_size
# Calculating MD5 hash
digester = hashlib.md5()
with open(filename, "rb") as f:
for chunk in iter(lambda: f.read(4096), b""):
digester.update(chunk)
md5sum = digester.hexdigest()
# Check if MD5 is already in DB
response = br.open(checkmd5url + md5sum)
soup = bs4.BeautifulSoup(response.read())
fonts = soup.find_all('font')
foundmd5 = True
for font in fonts:
if font.get_text().strip() == "Found 0 results":
foundmd5 = False
break
if foundmd5:
print "Already in DB : %s" % filename
continue
# Uploading
br.open(uploadurl)
br.select_form(nr=0)
br.form.add_file(open(filename), mimetype, filename, name='uploadedfile')
#~ print br.form
response = br.submit()
# Registering after upload
try:
br.select_form(nr=1)
except mechanize.FormNotFoundError as fnfe:
print response.read()
continue
# Fixing required data
br.form.set_all_readonly(False)
if br.form["authorfamily1"] == "":
if br.form["authorsurname1"] != "":
# Surname is present
br.form["authorfamily1"] = br.form["authorsurname1"]
br.form["authorsurname1"] = ""
else:
# Only name present
br.form["authorfamily1"] = br.form["authorname1"]
br.form["authorname1"] = ""
response = br.submit()
# Reading registration response
soup = bs4.BeautifulSoup(response.read())
h1s = soup.find_all('h1')
if len(h1s) == 1:
print h1s[0].get_text().strip()
else:
print soup.prettify()
# Cooldown
time.sleep(random.randint(1,9))
| 1,258 |
2,177 | <reponame>denghuafeng/nutz
package org.nutz.dao.test.meta.issue1302;
import org.nutz.dao.entity.annotation.ColDefine;
import org.nutz.dao.entity.annotation.ColType;
import org.nutz.dao.entity.annotation.Column;
import org.nutz.dao.entity.annotation.Id;
import org.nutz.dao.entity.annotation.Name;
import org.nutz.dao.entity.annotation.Table;
@Table("t_issue_1302_master")
public class Issue1302Master {
@Id
private int id;
@Name
private String name;
@Column
@ColDefine(type=ColType.INT)
private Issue1302UserAction act;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Issue1302UserAction getAct() {
return act;
}
public void setAct(Issue1302UserAction act) {
this.act = act;
}
}
| 426 |
569 | package us.koller.cameraroll.util;
import android.content.Context;
import android.net.Uri;
import android.webkit.MimeTypeMap;
public class MediaType {
private static String[] imageExtensions = {"jpg", "png", "jpe", "jpeg", "bmp"};
private static String[] imageMimeTypes = {"image/*", "image/jpeg", "image/jpg", "image/png", "image/bmp"};
private static String[] videoExtensions = {"mp4", "mkv", "webm", "avi"};
private static String[] videoMimeTypes = {"video/*", "video/mp4", "video/x-matroska", "video/webm", "video/avi"};
private static String[] gifExtensions = {"gif"};
private static String[] gifMimeTypes = {"image/gif"};
private static String[] rawExtensions = {"dng", "cr2", "arw"};
private static String[] rawMimeTypes = {"image/x-adobe-dng", "image/x-canon-cr2", "image/arw", "image/x-sony-arw"};
private static String[] exifExtensions = {"jpg", "jpe", "jpeg", "dng", "cr2"};
private static String[] exifMimeTypes = {"image/jpeg", "image/jpg", "image/x-adobe-dng", "image/x-canon-cr2"};
private static String[] exifWritingExtensions = {"jpg", "jpe", "jpeg"};
private static String[] exifWritingMimeTypes = {"image/jpeg", "image/jpg"};
private static String[] wallpaperMimeTypes = {"image/jpeg", "image/png"};
public static boolean isMedia(String path) {
return checkImageExtension(path) ||
checkRAWExtension(path) ||
checkGifExtension(path) ||
checkVideoExtension(path);
}
public static String getMimeType(String path) {
if (path == null) {
return null;
}
String fileExtension = MimeTypeMap.getFileExtensionFromUrl(path);
return MimeTypeMap.getSingleton().getMimeTypeFromExtension(fileExtension);
}
public static String getMimeType(Context context, Uri uri) {
return context.getContentResolver().getType(uri);
}
//trying to check via mimeType
public static boolean isImage(String path) {
return path != null && checkImageExtension(path);
}
public static boolean isVideo(String path) {
return path != null && checkVideoExtension(path);
}
public static boolean isGif(String path) {
return path != null && checkGifExtension(path);
}
public static boolean isRAWImage(String path) {
return path != null && checkRAWExtension(path);
}
/*check mimeTypes*/
public static boolean doesSupportExifMimeType(String mimeType) {
return checkExtension(mimeType, exifMimeTypes);
}
public static boolean doesSupportWritingExifMimeType(String mimeType) {
return checkExtension(mimeType, exifWritingMimeTypes);
}
public static boolean checkImageMimeType(String mimeType) {
return checkExtension(mimeType, imageMimeTypes);
}
public static boolean checkVideoMimeType(String mimeType) {
return checkExtension(mimeType, videoMimeTypes);
}
public static boolean checkGifMimeType(String mimeType) {
return checkExtension(mimeType, gifMimeTypes);
}
public static boolean checkRAWMimeType(String mimeType) {
return checkExtension(mimeType, rawMimeTypes);
}
/*check fileExtensions*/
@SuppressWarnings("unused")
public static boolean doesSupportExifFileExtension(String path) {
return checkExtension(path, exifExtensions);
}
@SuppressWarnings("unused")
public static boolean doesSupportWritingExifFileExtension(String path) {
return checkExtension(path, exifWritingExtensions);
}
private static boolean checkImageExtension(String path) {
return checkExtension(path, imageExtensions);
}
private static boolean checkVideoExtension(String path) {
return checkExtension(path, videoExtensions);
}
private static boolean checkGifExtension(String path) {
return checkExtension(path, gifExtensions);
}
private static boolean checkRAWExtension(String path) {
return checkExtension(path, rawExtensions);
}
@SuppressWarnings("DefaultLocale")
private static boolean checkExtension(String path, String[] extensions) {
if (path == null) {
return false;
}
for (int i = 0; i < extensions.length; i++) {
if (path.toLowerCase().endsWith(extensions[i])) {
return true;
}
}
return false;
}
public static boolean suitableAsWallpaper(Context context, Uri uri) {
if (uri != null) {
String mimeType = getMimeType(context, uri);
return mimeType != null && checkExtension(mimeType, wallpaperMimeTypes);
}
return false;
}
}
| 1,796 |
848 | /*
* Copyright 2019 Xilinx 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.
*/
#include <iostream>
#include <string>
#include <vector>
#include "UniLog/UniLog.hpp"
#include "xir/attrs/attrs.hpp"
#include "xir/graph/graph.hpp"
#include "xir/util/data_type.hpp"
int main(int, char* argv[]) {
UniLog::Initial(argv[0], UNI_LOG_STD, UNI_LOG_LEVEL_INFO,
UNI_LOG_STD_LEVEL_INFO);
auto g = xir::Graph::create("test");
g->set_attr<std::string>("test", "test");
UNI_LOG_CHECK(g->has_attr("test"), ERROR_SAMPLE);
UNI_LOG_INFO << g->get_attr<std::string>("test");
UNI_LOG_INFO << "Graph name: " << g->get_name();
auto w1 = g->add_op("conv1_w", "const", xir::Attrs::create(), {},
xir::DataType{"FLOAT32"});
UNI_LOG_INFO << "Add Op " << w1->get_name();
auto i = g->add_op("input_data", "data", xir::Attrs::create(), {},
xir::DataType{"FLOAT32"});
UNI_LOG_INFO << "Add Op " << i->get_name();
auto attrs = xir::Attrs::create();
attrs->set_attr<std::vector<int>>("kernel", {3, 3});
attrs->set_attr<std::vector<int>>("stride", {3, 3});
attrs->set_attr<int>("pad_mode", 0);
attrs->set_attr<std::vector<int>>("pad", {1, 1, 1, 1});
std::cout << attrs->debug_info() << std::endl;
auto c1 =
g->add_op("conv1", "conv2d", xir::Attrs::clone(attrs.get()),
{{"weights", {w1}}, {"input", {i}}}, xir::DataType{"FLOAT32"});
UNI_LOG_INFO << "Add Op " << c1->get_name();
auto w2 = g->add_op("conv2_w", "const", xir::Attrs::create(), {},
xir::DataType{"FLOAT32"});
UNI_LOG_INFO << "Add Op " << w2->get_name();
auto c2 =
g->add_op("conv2", "conv2d", xir::Attrs::clone(attrs.get()),
{{"weights", {w2}}, {"input", {c1}}}, xir::DataType{"FLOAT32"});
UNI_LOG_INFO << "Add Op " << c2->get_name();
auto topo = g->topological_sort();
for (auto op : topo) {
std::cout << op->get_name() << std::endl;
}
g->remove_op(c2);
g->visualize("test", "png");
auto o = g->get_op("conv1_w");
std::cout << "find " << o->get_name() << std::endl;
return 0;
}
| 1,113 |
765 | <reponame>hyu-iot/gem5
/*
* Copyright (c) 2021 The Regents of the University of California
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met: redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer;
* redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution;
* neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "dev/lupio/lupio_sys.hh"
#include "debug/LupioSYS.hh"
#include "mem/packet_access.hh"
#include "params/LupioSYS.hh"
#include "sim/sim_exit.hh"
namespace gem5
{
LupioSYS::LupioSYS(const Params ¶ms) :
BasicPioDevice(params, params.pio_size)
{
DPRINTF(LupioSYS, "LupioSYS initalized\n");
}
uint8_t
LupioSYS::lupioSYSRead(uint8_t addr)
{
return 0;
}
void
LupioSYS::lupioSYSWrite(uint8_t addr, uint64_t val64)
{
switch (addr >> 2) {
case LUPIO_SYS_HALT:
DPRINTF(LupioSYS, "Trying to halt\n");
exitSimLoopNow("LUPIO_SYS_HALT called, exiting", val64, 0, false);
break;
case LUPIO_SYS_REBT:
DPRINTF(LupioSYS, "Trying to reboot\n");
exitSimLoopNow("LUPIO_SYS_REBT called, exiting", val64, 0, false);
break;
default:
panic("Unexpected write to the LupioRTC device at address %d!",
addr);
break;
}
}
Tick
LupioSYS::read(PacketPtr pkt)
{
Addr daddr = pkt->getAddr() - pioAddr;
DPRINTF(LupioSYS,
"Read request - addr: %#x, size: %#x\n", daddr, pkt->getSize());
uint64_t sys_read = lupioSYSRead(daddr);
DPRINTF(LupioSYS, "Packet Read: %#x\n", sys_read);
pkt->setUintX(sys_read, byteOrder);
pkt->makeResponse();
return pioDelay;
}
Tick
LupioSYS::write(PacketPtr pkt)
{
Addr daddr = pkt->getAddr() - pioAddr;
DPRINTF(LupioSYS, "Write register %#x value %#x\n", daddr,
pkt->getUintX(byteOrder));
lupioSYSWrite(daddr, pkt->getUintX(byteOrder));
DPRINTF(LupioSYS, "Packet Write Value: %d\n", pkt->getUintX(byteOrder));
pkt->makeResponse();
return pioDelay;
}
} // namespace gem5
| 1,307 |
416 | <gh_stars>100-1000
/*
NSJSONSerialization.h
Copyright (c) 2009-2017, Apple Inc. All rights reserved.
*/
#import <Foundation/NSObject.h>
@class NSError, NSOutputStream, NSInputStream, NSData;
NS_ASSUME_NONNULL_BEGIN
typedef NS_OPTIONS(NSUInteger, NSJSONReadingOptions) {
NSJSONReadingMutableContainers = (1UL << 0),
NSJSONReadingMutableLeaves = (1UL << 1),
NSJSONReadingAllowFragments = (1UL << 2)
} API_AVAILABLE(macos(10.7), ios(5.0), watchos(2.0), tvos(9.0));
typedef NS_OPTIONS(NSUInteger, NSJSONWritingOptions) {
NSJSONWritingPrettyPrinted = (1UL << 0),
/* Sorts dictionary keys for output using [NSLocale systemLocale]. Keys are compared using NSNumericSearch. The specific sorting method used is subject to change.
*/
NSJSONWritingSortedKeys API_AVAILABLE(macos(10.13), ios(11.0), watchos(4.0), tvos(11.0)) = (1UL << 1)
} API_AVAILABLE(macos(10.7), ios(5.0), watchos(2.0), tvos(9.0));
/* A class for converting JSON to Foundation objects and converting Foundation objects to JSON.
An object that may be converted to JSON must have the following properties:
- Top level object is an NSArray or NSDictionary
- All objects are NSString, NSNumber, NSArray, NSDictionary, or NSNull
- All dictionary keys are NSStrings
- NSNumbers are not NaN or infinity
*/
NS_CLASS_AVAILABLE(10_7, 5_0)
@interface NSJSONSerialization : NSObject {
@private
void *reserved[6];
}
/* Returns YES if the given object can be converted to JSON data, NO otherwise. The object must have the following properties:
- Top level object is an NSArray or NSDictionary
- All objects are NSString, NSNumber, NSArray, NSDictionary, or NSNull
- All dictionary keys are NSStrings
- NSNumbers are not NaN or infinity
Other rules may apply. Calling this method or attempting a conversion are the definitive ways to tell if a given object can be converted to JSON data.
*/
+ (BOOL)isValidJSONObject:(id)obj;
/* Generate JSON data from a Foundation object. If the object will not produce valid JSON then an exception will be thrown. Setting the NSJSONWritingPrettyPrinted option will generate JSON with whitespace designed to make the output more readable. If that option is not set, the most compact possible JSON will be generated. If an error occurs, the error parameter will be set and the return value will be nil. The resulting data is a encoded in UTF-8.
*/
+ (nullable NSData *)dataWithJSONObject:(id)obj options:(NSJSONWritingOptions)opt error:(NSError **)error;
/* Create a Foundation object from JSON data. Set the NSJSONReadingAllowFragments option if the parser should allow top-level objects that are not an NSArray or NSDictionary. Setting the NSJSONReadingMutableContainers option will make the parser generate mutable NSArrays and NSDictionaries. Setting the NSJSONReadingMutableLeaves option will make the parser generate mutable NSString objects. If an error occurs during the parse, then the error parameter will be set and the result will be nil.
The data must be in one of the 5 supported encodings listed in the JSON specification: UTF-8, UTF-16LE, UTF-16BE, UTF-32LE, UTF-32BE. The data may or may not have a BOM. The most efficient encoding to use for parsing is UTF-8, so if you have a choice in encoding the data passed to this method, use UTF-8.
*/
+ (nullable id)JSONObjectWithData:(NSData *)data options:(NSJSONReadingOptions)opt error:(NSError **)error;
/* Write JSON data into a stream. The stream should be opened and configured. The return value is the number of bytes written to the stream, or 0 on error. All other behavior of this method is the same as the dataWithJSONObject:options:error: method.
*/
+ (NSInteger)writeJSONObject:(id)obj toStream:(NSOutputStream *)stream options:(NSJSONWritingOptions)opt error:(NSError **)error;
/* Create a JSON object from JSON data stream. The stream should be opened and configured. All other behavior of this method is the same as the JSONObjectWithData:options:error: method.
*/
+ (nullable id)JSONObjectWithStream:(NSInputStream *)stream options:(NSJSONReadingOptions)opt error:(NSError **)error;
@end
NS_ASSUME_NONNULL_END
| 1,223 |
1,614 | <gh_stars>1000+
/**
* Copyright (C) the original author or 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 ninja.utils;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertThat;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.io.OutputStream;
import java.io.Writer;
import ninja.Context;
import ninja.Result;
import ninja.Results;
import ninja.template.TemplateEngine;
import ninja.template.TemplateEngineManager;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;
import org.slf4j.Logger;
@RunWith(MockitoJUnitRunner.class)
public class ResultHandlerTest {
@Mock
private TemplateEngineManager templateEngineManager;
@Mock
private TemplateEngine templateEngine;
@Mock
private TemplateEngine templateEngineHtml;
@Mock
private ResponseStreams responseStreams;
@Mock
private OutputStream outputStream;
@Mock
private Writer writer;
private ResultHandler resultHandler;
@Mock
private Context context;
@Mock
private Logger logger;
@Before
public final void init() throws Exception {
resultHandler = new ResultHandler(logger, templateEngineManager);
when(responseStreams.getOutputStream()).thenReturn(outputStream);
when(responseStreams.getWriter()).thenReturn(writer);
when(context.finalizeHeaders(any(Result.class)))
.thenReturn(responseStreams);
when(templateEngineManager
.getTemplateEngineForContentType(Result.APPLICATION_JSON))
.thenReturn(templateEngine);
when(templateEngineManager.getTemplateEngineForContentType(Result.TEXT_HTML))
.thenReturn(templateEngineHtml);
}
/**
* If Cache-Control is not set the no-cache strategy has to be applied.
*
* We expect Cache-Control: ... Date: ... Expires: ...
*/
@Test
public void testAddingOfDefaultHeadersWorks() {
Result result = Results.json();
// just a new object as dummy...
result.render(new Object());
// make sure the stuff is not set by default json method (just in
// case...)
assertNull(result.getHeaders().get(Result.CACHE_CONTROL));
assertNull(result.getHeaders().get(Result.DATE));
assertNull(result.getHeaders().get(Result.EXPIRES));
// handle result
resultHandler.handleResult(result, context);
// make sure stuff is there:
assertEquals(Result.CACHE_CONTROL_DEFAULT_NOCACHE_VALUE, result
.getHeaders().get(Result.CACHE_CONTROL));
assertNotNull(result.getHeaders().get(Result.DATE));
assertEquals(DateUtil.formatForHttpHeader(0L),
result.getHeaders().get(Result.EXPIRES));
}
@Test
public void testCacheControlDoesNotGetTouchedWhenSet() {
Result result = Results.json();
// just a simple cache control header:
result.addHeader(Result.CACHE_CONTROL, "must-revalidate");
// just a new object as dummy...
result.render(new Object());
// handle result
resultHandler.handleResult(result, context);
// make sure stuff is there:
assertEquals("must-revalidate",
result.getHeaders().get(Result.CACHE_CONTROL));
assertNull(result.getHeaders().get(Result.DATE));
assertNull(result.getHeaders().get(Result.EXPIRES));
}
@Test
public void testRenderPlainStringAndSetDefaultContentType() {
final String toRender = "this is just a plain string";
Result result = Results.ok();
result.renderRaw(toRender);
resultHandler.handleResult(result, context);
assertEquals(Result.TEXT_PLAIN, result.getContentType());
}
@Test
public void testContentNegotiation() {
when(context.getAcceptContentType()).thenReturn("text/html");
Result result = Results.ok();
resultHandler.handleResult(result, context);
assertEquals("text/html", result.getContentType());
verify(templateEngineHtml).invoke(context, result);
}
@Test
public void testRenderPlainStringLeavesExplicitlySetContentTypeUntouched() {
final String toRender = "this is just a plain string";
final String contentType = "any/contenttype";
Result result = Results.ok();
result.contentType(contentType);
result.renderRaw(toRender);
resultHandler.handleResult(result, context);
assertEquals(contentType, result.getContentType());
}
@Test
public void testRenderPictureFromBytes() {
final byte[] toRender = new byte[] { 1, 2, 3 };
final String contentType = "image/png";
Result result = Results.ok();
result.contentType(contentType);
result.renderRaw(toRender);
resultHandler.handleResult(result, context);
assertEquals(contentType, result.getContentType());
}
@Test
public void testThatNoHttpBodyWorks() {
// make sure that NoHttpBody causes the resulthandler to finalize
// the context and does not call a tempate render engine.
Result result = new Result(200);
result.render(new NoHttpBody());
resultHandler.handleResult(result, context);
verify(context).finalizeHeaders(result);
}
@Test
public void testThatFallbackContentTypeWorks() {
Result result
= new Result(200)
.fallbackContentType(Result.TEXT_HTML)
.contentType(null);
resultHandler.handleResult(result, context);
assertThat(result.getContentType(), equalTo(Result.TEXT_HTML));
}
}
| 2,437 |
335 | <reponame>Safal08/Hacktoberfest-1
{
"word": "Piss",
"definitions": [
"Urinate.",
"Discharge (something, especially blood) when urinating.",
"Urinate involuntarily (often used hyperbolically to indicate hilarity or intense fear).",
"Rain heavily."
],
"parts-of-speech": "Verb"
} | 133 |
32,544 | package com.baeldung.jpa.multiplebagfetchexception;
import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
@Entity
class Artist {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
private String name;
@OneToMany(mappedBy = "artist")
private List<Song> songs;
@OneToMany(mappedBy = "artist", cascade = CascadeType.PERSIST)
private List<Offer> offers;
Artist(String name) {
this.name = name;
this.offers = new ArrayList<>();
}
void createOffer(String description) {
this.offers.add(new Offer(description, this));
}
@Override
public boolean equals(Object o) {
if (this == o)
return true;
if (o == null || getClass() != o.getClass())
return false;
Artist artist = (Artist) o;
return Objects.equals(id, artist.id);
}
@Override
public int hashCode() {
return id != null ? id.hashCode() : 0;
}
protected Artist() {
}
}
| 503 |
1,165 | <filename>api/pacman-api-notifications/src/main/java/com/tmobile/pacman/api/notification/service/NotificationServiceImpl.java<gh_stars>1000+
/*******************************************************************************
* Copyright 2018 T Mobile, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy
* of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
******************************************************************************/
package com.tmobile.pacman.api.notification.service;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.ResultSetExtractor;
import org.springframework.stereotype.Service;
import com.esotericsoftware.minlog.Log;
import com.google.common.collect.Maps;
import com.tmobile.pacman.api.commons.Constants;
import com.tmobile.pacman.api.commons.repo.ElasticSearchRepository;
@Service
public class NotificationServiceImpl implements NotificationService,Constants {
@Autowired
private ElasticSearchRepository elasticSearchRepository;
@Autowired
private JdbcTemplate jdbcTemplate;
@Override
public List<Map<String, Object>> getApiRoles(String serviceProject, String environment) {
String query = "SELECT roles, urls FROM ApiRbac WHERE serviceProject='"+ serviceProject +"' AND environment='"+ environment +"'";
return jdbcTemplate.queryForList(query);
}
/**
* @throws Exception
*
*/
public Map<String,Object> getDeviceDetails(String deviceId) throws Exception{
Map<String, Object> mustFilter= new HashMap<>();
mustFilter.put("_id", deviceId);
List<Map<String,Object>> response = elasticSearchRepository.getSortedDataFromES("pac_cache", "element", mustFilter, null, null, null,null, null);
if(null!=response) return response.get(0);
else
throw new Exception("no data found");
}
@Override
public List<Map<String,Object>> getAllAssetGroupOwnerEmailDetails() {
String query = "SELECT displayName AS ownerName, groupName AS assetGroup, ownerEmailId AS ownerEmail FROM cf_AssetGroupDetails LEFT JOIN cf_AssetGroupOwnerDetails ON (groupName = assetGroupName) WHERE groupType = 'Director' AND ownerEmailId NOT IN (SELECT emailId FROM PacmanSubscriptions WHERE subscriptionValue=0) GROUP BY groupName";
return jdbcTemplate.queryForList(query);
}
@Override
public Map<String, Object> unsubscribeDigestMail(final String mailId) {
String sql = "SELECT subscriptionValue AS subscriptionValue FROM PacmanSubscriptions WHERE emailId = ?";
String updateOrInsertQuery ;
Object[] parameters;
Date date = new Date();
Boolean isUnsubscriptedAlready = jdbcTemplate.query(sql, new Object[]{mailId}, new ResultSetExtractor<Boolean>() {
@Override
public Boolean extractData(ResultSet rs) {
try {
return rs.next() ? rs.getBoolean("subscriptionValue") : null;
} catch (SQLException e) {
Log.error(e.getMessage());
return null;
}
}
});
if(isUnsubscriptedAlready != null) {
updateOrInsertQuery="UPDATE PacmanSubscriptions SET emailId=?, subscriptionValue=?, modifiedDate=? WHERE emailId=?";
parameters = new Object[] {mailId, false, date, mailId};
} else {
updateOrInsertQuery="INSERT INTO PacmanSubscriptions (emailId, subscriptionValue, createdDate, modifiedDate) VALUES (?,?,?,?)";
parameters = new Object[] {mailId, false, date, date};
}
int status = jdbcTemplate.update(updateOrInsertQuery, parameters);
Map<String, Object> response = Maps.newHashMap();
if(status==1) {
response.put(STATUS, true);
response.put(MESSAGE_KEY, "You have successfully unsubscribed");
} else {
response.put(STATUS, false);
response.put(MESSAGE_KEY, "Unsubscribing Failed!!!");
}
return response;
}
@Override
public Map<String, Object> subscribeDigestMail(String mailId) {
String sql = "SELECT subscriptionValue AS subscriptionValue FROM PacmanSubscriptions WHERE emailId = ?";
String updateOrInsertQuery ;
Object[] parameters;
Date date = new Date();
Boolean isUnsubscriptedAlready = jdbcTemplate.query(sql, new Object[]{mailId}, new ResultSetExtractor<Boolean>() {
@Override
public Boolean extractData(ResultSet rs) {
try {
return rs.next() ? rs.getBoolean("subscriptionValue") : null;
} catch (SQLException e) {
Log.error(e.getMessage());
return null;
}
}
});
if(isUnsubscriptedAlready != null) {
updateOrInsertQuery="UPDATE PacmanSubscriptions SET emailId=?, subscriptionValue=?, modifiedDate=? WHERE emailId=?";
parameters = new Object[] {mailId, true, date, mailId};
} else {
updateOrInsertQuery="INSERT INTO PacmanSubscriptions (emailId, subscriptionValue, createdDate, modifiedDate) VALUES (?,?,?,?)";
parameters = new Object[] {mailId, true, date, date};
}
int status = jdbcTemplate.update(updateOrInsertQuery, parameters);
Map<String, Object> response = Maps.newHashMap();
if(status==1) {
response.put(STATUS, true);
response.put(MESSAGE_KEY, "You have successfully subscribed");
} else {
response.put(STATUS, false);
response.put(MESSAGE_KEY, "Subscription Failed!!!");
}
return response;
}
}
| 1,896 |
435 | <gh_stars>100-1000
{
"description": "Exactly 23 years have passed since release of one of the biggest IT\nclassics - \"Design Patterns: Elements of Reusable Object-Oriented\nSoftware\".\n\nContents of the book had considerable influence on dominant\nprogramming languages of those days. However, design patterns were\nnot glorified by everyone. Voices of rational critic appeared,\npointing out that design patterns are just ways to compensate for\nmissing languages features by tons of clumsy code. If one implements\ndesign patterns in Python by the book, they will get code that looks\nawkward, at best.\n\nThis talk is to present Python's features that either simplifies or\neliminates need for implementing design patterns. Even if you don't\nknow what design patterns are - don't worry. You still may see some\nnew interesting Python's features and their usage.",
"duration": 1623,
"language": "eng",
"recorded": "2017-07-11",
"speakers": [
"<NAME>\u0144ski"
],
"thumbnail_url": "https://i.ytimg.com/vi/G5OeYHCJuv0/hqdefault.jpg",
"title": "Why you don't need design patterns in Python?",
"videos": [
{
"type": "youtube",
"url": "https://www.youtube.com/watch?v=G5OeYHCJuv0"
}
]
}
| 375 |
1,848 | <reponame>pcwalton/rust-bindgen
template<typename T>
class Foo {
typedef T elem_type;
typedef T* ptr_type;
typedef struct Bar {
int x, y;
} Bar;
};
| 70 |
434 | package com.github.anzewei.parallaxbacklayout.transform;
import android.graphics.Canvas;
import android.view.View;
import com.github.anzewei.parallaxbacklayout.widget.ParallaxBackLayout;
import static com.github.anzewei.parallaxbacklayout.ViewDragHelper.EDGE_BOTTOM;
import static com.github.anzewei.parallaxbacklayout.ViewDragHelper.EDGE_LEFT;
import static com.github.anzewei.parallaxbacklayout.ViewDragHelper.EDGE_RIGHT;
import static com.github.anzewei.parallaxbacklayout.ViewDragHelper.EDGE_TOP;
/**
* ParallaxBackLayout
*
* @author <NAME> (anzewei88[at]gmail[dot]com)
* @since ${VERSION}
*/
public class CoverTransform implements ITransform {
@Override
public void transform(Canvas canvas, ParallaxBackLayout parallaxBackLayout, View child) {
int edge = parallaxBackLayout.getEdgeFlag();
if (edge == EDGE_LEFT) {
canvas.clipRect(0, 0, child.getLeft(), child.getBottom());
} else if (edge == EDGE_TOP) {
canvas.clipRect(0, 0, child.getRight(), child.getTop() + parallaxBackLayout.getSystemTop());
} else if (edge == EDGE_RIGHT) {
canvas.clipRect(child.getRight(), 0, parallaxBackLayout.getWidth(), child.getBottom());
} else if (edge == EDGE_BOTTOM) {
canvas.clipRect(0, child.getBottom(), child.getRight(), parallaxBackLayout.getHeight());
}
}
}
| 524 |
474 | <filename>QNShortVideo-With-TuTu-iOS/PLShortVideoKit-master/Example/PLShortVideoKitDemo/Transition/TransitionModelMaker.h
//
// TransitionModelView.h
// PLShortVideoKitDemo
//
// Created by hxiongan on 2018/1/25.
// Copyright © 2018年 Pili Engineering, Qiniu Inc. All rights reserved.
//
#import <UIKit/UIKit.h>
#import <PLShortVideoKit/PLShortVideoKit.h>
@interface TransitionModelMaker : NSObject
@property (nonatomic, strong) NSString *title;
@property (nonatomic, strong) NSString *detailTitle;
@property (nonatomic, strong) UIColor *titleColor;
@property (nonatomic, strong) UIFont *titleFont;
@property (nonatomic, strong)UIColor *detailTitleColor;
@property (nonatomic, strong)UIFont *detailTitleFont;
/**
@abstract 根据配置的参数，返回一个CAAnimation对象，预览view的尺寸和导出视频的尺寸不一样的时候，为了能让预览效果达到和导出视频一样效果，需要对动画的位置等做比例缩放
@param videoSize 最终生成的文字转mp4视频的width、heigh
@return 包含imageSetting和textSetting
*/
- (NSDictionary *)settingsWithVideoSize:(CGSize)videoSize;
@end
// 大标题
@interface TransitionModelMakerBigTitle : TransitionModelMaker
@property (nonatomic, assign) NSInteger bigTitleSettingID;
- (NSArray <PLSTransition *> *)bigSettingTranstionWithTextSetting:(PLSTextSetting *)textSetting;
@end
// 章节
@interface TransitionModelMakerChapter : TransitionModelMaker
@property (nonatomic, assign) NSInteger chapterSettingID;
@property (nonatomic, assign) NSInteger textSettingID;
- (NSArray <PLSTransition *> *)textSettingTranstionWithTextSetting:(PLSTextSetting *)textSetting;
- (NSArray <PLSTransition *> *)chapterSettingTranstionWithTextSetting:(PLSTextSetting *)textSetting;
@end
// 简约
@interface TransitionModelMakerSimple : TransitionModelMaker
@property (nonatomic, assign) NSInteger imageSettingID;
@property (nonatomic, assign) NSInteger textSettingID;
- (NSArray <PLSTransition *> *)textSettingTranstionWithTextSetting:(PLSTextSetting *)textSetting;
- (NSArray <PLSTransition *> *)imageSettingTranstionWithImageSetting:(PLSImageSetting *)imageSetting;
@end
// 引用
@interface TransitionModelMakerQuote : TransitionModelMaker
@property (nonatomic, assign) NSInteger imageSettingID;
@property (nonatomic, assign) NSInteger textSettingID;
- (NSArray <PLSTransition *> *)textSettingTranstionWithTextSetting:(PLSTextSetting *)textSetting;
- (NSArray <PLSTransition *> *)imageSettingTranstionWithImageSetting:(PLSImageSetting *)imageSetting;
@end
// 标题和副标题
@interface TransitionModelMakerDetail : TransitionModelMaker
@property (nonatomic, assign) NSInteger detailSettingID;
@property (nonatomic, assign )NSInteger titleSettingID;
- (NSArray <PLSTransition *> *)titleSettingTranstionWithTextSetting:(PLSTextSetting *)textSetting;
- (NSArray <PLSTransition *> *)detailSettingTranstionWithTextSetting:(PLSTextSetting *)textSetting;
@end
// 片尾
@interface TransitionModelMakerTail : TransitionModelMaker
@property (nonatomic, assign) NSInteger directorNameSettingID;
@property (nonatomic, assign) NSInteger dateLocationValueSettingID;
@property (nonatomic, assign) NSInteger directorSettingID;
@property (nonatomic, assign) NSInteger dateLocationSettingID;
- (NSArray <PLSTransition *> *)directorSettingTranstionWithTextSetting:(PLSTextSetting *)textSetting;
- (NSArray <PLSTransition *> *)directorNameSettingTranstionWithTextSetting:(PLSTextSetting *)textSetting;
- (NSArray <PLSTransition *> *)dateLocationSettingTranstionWithTextSetting:(PLSTextSetting *)textSetting;
- (NSArray <PLSTransition *> *)dateLocationValueSettingTranstionWithTextSetting:(PLSTextSetting *)textSetting;
@end
| 1,267 |
1,405 | package QQPIM;
public final class EVirusPriority {
public static final EVirusPriority VP_High = new EVirusPriority(2, 2, "VP_High");
public static final EVirusPriority VP_Low = new EVirusPriority(0, 0, "VP_Low");
public static final EVirusPriority VP_Mid = new EVirusPriority(1, 1, "VP_Mid");
public static final int _VP_High = 2;
public static final int _VP_Low = 0;
public static final int _VP_Mid = 1;
static final /* synthetic */ boolean a = (!EVirusPriority.class.desiredAssertionStatus());
private static EVirusPriority[] b = new EVirusPriority[3];
private int c;
private String d = new String();
private EVirusPriority(int i, int i2, String str) {
this.d = str;
this.c = i2;
b[i] = this;
}
public static EVirusPriority convert(int i) {
for (int i2 = 0; i2 < b.length; i2++) {
if (b[i2].value() == i) {
return b[i2];
}
}
if (a) {
return null;
}
throw new AssertionError();
}
public static EVirusPriority convert(String str) {
for (int i = 0; i < b.length; i++) {
if (b[i].toString().equals(str)) {
return b[i];
}
}
if (a) {
return null;
}
throw new AssertionError();
}
public final String toString() {
return this.d;
}
public final int value() {
return this.c;
}
}
| 684 |
1,347 | // The Class loader provides constructors for all EJBinding* subclasses to
// JavaScript and takes care building and instantiating JSClasses and JSObjects.
// EJClassLoader works closely with EJBinding classes. It uses Obj-C reflection
// functions to get a list of all Methods of an Obj-C class. Using a convention
// of prefixes for functions and properties that should be exposed to JS, the
// Class Loader constructs a JSClass for each Obj-C class and hands it to JSC.
// The EJJavaScriptView instantiates the loader with the name "Ejecta". The
// loader creates a global object with that name under which all EJBinding*
// contructors can be accessed.
// The Class Loader is lazy - a JSClass is only ever constructed when an attempt
// is made to access the contructor of that class in JavaScript.
#import <Foundation/Foundation.h>
#import <JavaScriptCore/JavaScriptCore.h>
@class EJJavaScriptView;
@class EJLoadedJSClass;
@interface EJClassLoader : NSObject {
JSClassRef jsConstructorClass;
NSMutableDictionary *classCache;
}
- (EJLoadedJSClass *)getJSClass:(id)class;
- (EJLoadedJSClass *)loadJSClass:(id)class;
- (id)initWithScriptView:(EJJavaScriptView *)scriptView name:(NSString *)name;
@property (nonatomic, readonly) JSClassRef jsConstructorClass;
@end
@interface EJLoadedJSClass : NSObject {
JSClassRef jsClass;
NSDictionary *constantValues;
}
- (id)initWithJSClass:(JSClassRef)jsClassp constantValues:(NSDictionary *)constantValuesp;
@property (readonly) JSClassRef jsClass;
@property (readonly) NSDictionary *constantValues;
@end
| 463 |
432 | <reponame>lambdaxymox/DragonFlyBSD
/*
* Copyright (c) 1988 <NAME>.
* Copyright (c) 1992, 1993
* The Regents of the University of California. All rights reserved.
*
* This code is derived from software contributed to Berkeley by
* <NAME> of Stanford University.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University 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 REGENTS 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 REGENTS 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.
*
* @(#)igmp.c 8.1 (Berkeley) 7/19/93
* $FreeBSD: src/sys/netinet/igmp.c,v 1.29.2.2 2003/01/23 21:06:44 sam Exp $
*/
/*
* Internet Group Management Protocol (IGMP) routines.
*
* Written by <NAME>, Stanford, May 1988.
* Modified by <NAME>, Stanford, Aug 1994.
* Modified by <NAME>, <NAME>, Feb 1995.
* Modified to fully comply to IGMPv2 by <NAME>, Oct 1995.
*
* MULTICAST Revision: 3.5.1.4
*/
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/malloc.h>
#include <sys/mbuf.h>
#include <sys/socket.h>
#include <sys/protosw.h>
#include <sys/kernel.h>
#include <sys/sysctl.h>
#include <sys/in_cksum.h>
#include <sys/thread2.h>
#include <machine/stdarg.h>
#include <net/if.h>
#include <net/route.h>
#include <net/netmsg2.h>
#include <net/netisr2.h>
#include <netinet/in.h>
#include <netinet/in_var.h>
#include <netinet/in_systm.h>
#include <netinet/ip.h>
#include <netinet/ip_var.h>
#include <netinet/igmp.h>
#include <netinet/igmp_var.h>
#define IGMP_FASTTIMO (hz / PR_FASTHZ)
#define IGMP_SLOWTIMO (hz / PR_SLOWHZ)
static MALLOC_DEFINE(M_IGMP, "igmp", "igmp state");
static struct router_info *
find_rti (struct ifnet *ifp);
static struct igmpstat igmpstat;
SYSCTL_STRUCT(_net_inet_igmp, IGMPCTL_STATS, stats, CTLFLAG_RW,
&igmpstat, igmpstat, "IGMP statistics");
static int igmp_timers_are_running;
static u_long igmp_all_hosts_group;
static u_long igmp_all_rtrs_group;
static struct mbuf *router_alert;
static struct router_info *Head;
static void igmp_sendpkt (struct in_multi *, int, unsigned long);
static void igmp_fasttimo_dispatch(netmsg_t);
static void igmp_fasttimo(void *);
static void igmp_slowtimo_dispatch(netmsg_t);
static void igmp_slowtimo(void *);
static struct netmsg_base igmp_slowtimo_netmsg;
static struct callout igmp_slowtimo_ch;
static struct netmsg_base igmp_fasttimo_netmsg;
static struct callout igmp_fasttimo_ch;
void
igmp_init(void)
{
struct ipoption *ra;
/*
* To avoid byte-swapping the same value over and over again.
*/
igmp_all_hosts_group = htonl(INADDR_ALLHOSTS_GROUP);
igmp_all_rtrs_group = htonl(INADDR_ALLRTRS_GROUP);
igmp_timers_are_running = 0;
/*
* Construct a Router Alert option to use in outgoing packets
*/
MGET(router_alert, M_NOWAIT, MT_DATA);
ra = mtod(router_alert, struct ipoption *);
ra->ipopt_dst.s_addr = 0;
ra->ipopt_list[0] = IPOPT_RA; /* Router Alert Option */
ra->ipopt_list[1] = 0x04; /* 4 bytes long */
ra->ipopt_list[2] = 0x00;
ra->ipopt_list[3] = 0x00;
router_alert->m_len = sizeof(ra->ipopt_dst) + ra->ipopt_list[1];
Head = NULL;
callout_init_mp(&igmp_slowtimo_ch);
netmsg_init(&igmp_slowtimo_netmsg, NULL, &netisr_adone_rport,
MSGF_PRIORITY, igmp_slowtimo_dispatch);
callout_init_mp(&igmp_fasttimo_ch);
netmsg_init(&igmp_fasttimo_netmsg, NULL, &netisr_adone_rport,
MSGF_PRIORITY, igmp_fasttimo_dispatch);
callout_reset_bycpu(&igmp_slowtimo_ch, IGMP_SLOWTIMO,
igmp_slowtimo, NULL, 0);
callout_reset_bycpu(&igmp_fasttimo_ch, IGMP_FASTTIMO,
igmp_fasttimo, NULL, 0);
}
static struct router_info *
find_rti(struct ifnet *ifp)
{
struct router_info *rti = Head;
#ifdef IGMP_DEBUG
kprintf("[igmp.c, _find_rti] --> entering \n");
#endif
while (rti) {
if (rti->rti_ifp == ifp) {
#ifdef IGMP_DEBUG
kprintf("[igmp.c, _find_rti] --> found old entry \n");
#endif
return rti;
}
rti = rti->rti_next;
}
rti = kmalloc(sizeof *rti, M_IGMP, M_INTWAIT);
rti->rti_ifp = ifp;
rti->rti_type = IGMP_V2_ROUTER;
rti->rti_time = 0;
rti->rti_next = Head;
Head = rti;
#ifdef IGMP_DEBUG
kprintf("[igmp.c, _find_rti] --> created an entry \n");
#endif
return rti;
}
int
igmp_input(struct mbuf **mp, int *offp, int proto)
{
struct mbuf *m = *mp;
int iphlen;
struct igmp *igmp;
struct ip *ip;
int igmplen;
struct ifnet *ifp = m->m_pkthdr.rcvif;
int minlen;
struct in_multi *inm;
struct in_ifaddr *ia;
struct in_multistep step;
struct router_info *rti;
int timer; /** timer value in the igmp query header **/
iphlen = *offp;
*mp = NULL;
++igmpstat.igps_rcv_total;
ip = mtod(m, struct ip *);
igmplen = ip->ip_len;
/*
* Validate lengths
*/
if (igmplen < IGMP_MINLEN) {
++igmpstat.igps_rcv_tooshort;
m_freem(m);
return(IPPROTO_DONE);
}
minlen = iphlen + IGMP_MINLEN;
if ((m->m_flags & M_EXT || m->m_len < minlen) &&
(m = m_pullup(m, minlen)) == NULL) {
++igmpstat.igps_rcv_tooshort;
return(IPPROTO_DONE);
}
/*
* Validate checksum
*/
m->m_data += iphlen;
m->m_len -= iphlen;
igmp = mtod(m, struct igmp *);
if (in_cksum(m, igmplen)) {
++igmpstat.igps_rcv_badsum;
m_freem(m);
return(IPPROTO_DONE);
}
m->m_data -= iphlen;
m->m_len += iphlen;
ip = mtod(m, struct ip *);
timer = igmp->igmp_code * PR_FASTHZ / IGMP_TIMER_SCALE;
if (timer == 0)
timer = 1;
rti = find_rti(ifp);
/*
* In the IGMPv2 specification, there are 3 states and a flag.
*
* In Non-Member state, we simply don't have a membership record.
* In Delaying Member state, our timer is running (inm->inm_timer)
* In Idle Member state, our timer is not running (inm->inm_timer==0)
*
* The flag is inm->inm_state, it is set to IGMP_OTHERMEMBER if
* we have heard a report from another member, or IGMP_IREPORTEDLAST
* if I sent the last report.
*/
switch (igmp->igmp_type) {
case IGMP_MEMBERSHIP_QUERY:
++igmpstat.igps_rcv_queries;
if (ifp->if_flags & IFF_LOOPBACK)
break;
if (igmp->igmp_code == 0) {
/*
* Old router. Remember that the querier on this
* interface is old, and set the timer to the
* value in RFC 1112.
*/
rti->rti_type = IGMP_V1_ROUTER;
rti->rti_time = 0;
timer = IGMP_MAX_HOST_REPORT_DELAY * PR_FASTHZ;
if (ip->ip_dst.s_addr != igmp_all_hosts_group ||
igmp->igmp_group.s_addr != 0) {
++igmpstat.igps_rcv_badqueries;
m_freem(m);
return(IPPROTO_DONE);
}
} else {
/*
* New router. Simply do the new validity check.
*/
if (igmp->igmp_group.s_addr != 0 &&
!IN_MULTICAST(ntohl(igmp->igmp_group.s_addr))) {
++igmpstat.igps_rcv_badqueries;
m_freem(m);
return(IPPROTO_DONE);
}
}
/*
* - Start the timers in all of our membership records
* that the query applies to for the interface on
* which the query arrived excl. those that belong
* to the "all-hosts" group (192.168.127.12).
* - Restart any timer that is already running but has
* a value longer than the requested timeout.
* - Use the value specified in the query message as
* the maximum timeout.
*/
IN_FIRST_MULTI(step, inm);
while (inm != NULL) {
if (inm->inm_ifp == ifp &&
inm->inm_addr.s_addr != igmp_all_hosts_group &&
(igmp->igmp_group.s_addr == 0 ||
igmp->igmp_group.s_addr == inm->inm_addr.s_addr)) {
if (inm->inm_timer == 0 ||
inm->inm_timer > timer) {
inm->inm_timer =
IGMP_RANDOM_DELAY(timer);
igmp_timers_are_running = 1;
}
}
IN_NEXT_MULTI(step, inm);
}
break;
case IGMP_V1_MEMBERSHIP_REPORT:
case IGMP_V2_MEMBERSHIP_REPORT:
/*
* For fast leave to work, we have to know that we are the
* last person to send a report for this group. Reports
* can potentially get looped back if we are a multicast
* router, so discard reports sourced by me.
*/
ia = IFP_TO_IA(ifp);
if (ia && ip->ip_src.s_addr == IA_SIN(ia)->sin_addr.s_addr)
break;
++igmpstat.igps_rcv_reports;
if (ifp->if_flags & IFF_LOOPBACK)
break;
if (!IN_MULTICAST(ntohl(igmp->igmp_group.s_addr))) {
++igmpstat.igps_rcv_badreports;
m_freem(m);
return(IPPROTO_DONE);
}
/*
* KLUDGE: if the IP source address of the report has an
* unspecified (i.e., zero) subnet number, as is allowed for
* a booting host, replace it with the correct subnet number
* so that a process-level multicast routing demon can
* determine which subnet it arrived from. This is necessary
* to compensate for the lack of any way for a process to
* determine the arrival interface of an incoming packet.
*/
if ((ntohl(ip->ip_src.s_addr) & IN_CLASSA_NET) == 0)
if (ia) ip->ip_src.s_addr = htonl(ia->ia_subnet);
/*
* If we belong to the group being reported, stop
* our timer for that group.
*/
inm = IN_LOOKUP_MULTI(&igmp->igmp_group, ifp);
if (inm != NULL) {
inm->inm_timer = 0;
++igmpstat.igps_rcv_ourreports;
inm->inm_state = IGMP_OTHERMEMBER;
}
break;
}
/*
* Pass all valid IGMP packets up to any process(es) listening
* on a raw IGMP socket.
*/
*mp = m;
rip_input(mp, offp, proto);
return(IPPROTO_DONE);
}
void
igmp_joingroup(struct in_multi *inm)
{
crit_enter();
if (inm->inm_addr.s_addr == igmp_all_hosts_group
|| inm->inm_ifp->if_flags & IFF_LOOPBACK) {
inm->inm_timer = 0;
inm->inm_state = IGMP_OTHERMEMBER;
} else {
inm->inm_rti = find_rti(inm->inm_ifp);
igmp_sendpkt(inm, inm->inm_rti->rti_type, 0);
inm->inm_timer = IGMP_RANDOM_DELAY(
IGMP_MAX_HOST_REPORT_DELAY*PR_FASTHZ);
inm->inm_state = IGMP_IREPORTEDLAST;
igmp_timers_are_running = 1;
}
crit_exit();
}
void
igmp_leavegroup(struct in_multi *inm)
{
if (inm->inm_state == IGMP_IREPORTEDLAST &&
inm->inm_addr.s_addr != igmp_all_hosts_group &&
!(inm->inm_ifp->if_flags & IFF_LOOPBACK) &&
inm->inm_rti->rti_type != IGMP_V1_ROUTER)
igmp_sendpkt(inm, IGMP_V2_LEAVE_GROUP, igmp_all_rtrs_group);
}
static void
igmp_fasttimo(void *dummy __unused)
{
struct netmsg_base *msg = &igmp_fasttimo_netmsg;
KKASSERT(mycpuid == 0);
crit_enter();
if (msg->lmsg.ms_flags & MSGF_DONE)
netisr_sendmsg_oncpu(msg);
crit_exit();
}
static void
igmp_fasttimo_dispatch(netmsg_t nmsg)
{
struct in_multi *inm;
struct in_multistep step;
ASSERT_NETISR0;
crit_enter();
netisr_replymsg(&nmsg->base, 0); /* reply ASAP */
crit_exit();
/*
* Quick check to see if any work needs to be done, in order
* to minimize the overhead of fasttimo processing.
*/
if (!igmp_timers_are_running)
goto done;
igmp_timers_are_running = 0;
IN_FIRST_MULTI(step, inm);
while (inm != NULL) {
if (inm->inm_timer == 0) {
/* do nothing */
} else if (--inm->inm_timer == 0) {
igmp_sendpkt(inm, inm->inm_rti->rti_type, 0);
inm->inm_state = IGMP_IREPORTEDLAST;
} else {
igmp_timers_are_running = 1;
}
IN_NEXT_MULTI(step, inm);
}
done:
callout_reset(&igmp_fasttimo_ch, IGMP_FASTTIMO, igmp_fasttimo, NULL);
}
static void
igmp_slowtimo(void *dummy __unused)
{
struct netmsg_base *msg = &igmp_slowtimo_netmsg;
KKASSERT(mycpuid == 0);
crit_enter();
if (msg->lmsg.ms_flags & MSGF_DONE)
netisr_sendmsg_oncpu(msg);
crit_exit();
}
static void
igmp_slowtimo_dispatch(netmsg_t nmsg)
{
struct router_info *rti = Head;
ASSERT_NETISR0;
crit_enter();
netisr_replymsg(&nmsg->base, 0); /* reply ASAP */
crit_exit();
#ifdef IGMP_DEBUG
kprintf("[igmp.c,_slowtimo] -- > entering \n");
#endif
while (rti) {
if (rti->rti_type == IGMP_V1_ROUTER) {
rti->rti_time++;
if (rti->rti_time >= IGMP_AGE_THRESHOLD) {
rti->rti_type = IGMP_V2_ROUTER;
}
}
rti = rti->rti_next;
}
#ifdef IGMP_DEBUG
kprintf("[igmp.c,_slowtimo] -- > exiting \n");
#endif
callout_reset(&igmp_slowtimo_ch, IGMP_SLOWTIMO, igmp_slowtimo, NULL);
}
static struct route igmprt;
static void
igmp_sendpkt(struct in_multi *inm, int type, unsigned long addr)
{
struct mbuf *m;
struct igmp *igmp;
struct ip *ip;
struct ip_moptions imo;
MGETHDR(m, M_NOWAIT, MT_HEADER);
if (m == NULL)
return;
m->m_pkthdr.rcvif = loif;
m->m_pkthdr.len = sizeof(struct ip) + IGMP_MINLEN;
MH_ALIGN(m, IGMP_MINLEN + sizeof(struct ip));
m->m_data += sizeof(struct ip);
m->m_len = IGMP_MINLEN;
igmp = mtod(m, struct igmp *);
igmp->igmp_type = type;
igmp->igmp_code = 0;
igmp->igmp_group = inm->inm_addr;
igmp->igmp_cksum = 0;
igmp->igmp_cksum = in_cksum(m, IGMP_MINLEN);
m->m_data -= sizeof(struct ip);
m->m_len += sizeof(struct ip);
ip = mtod(m, struct ip *);
ip->ip_tos = 0;
ip->ip_len = sizeof(struct ip) + IGMP_MINLEN;
ip->ip_off = 0;
ip->ip_p = IPPROTO_IGMP;
ip->ip_src.s_addr = INADDR_ANY;
ip->ip_dst.s_addr = addr ? addr : igmp->igmp_group.s_addr;
imo.imo_multicast_ifp = inm->inm_ifp;
imo.imo_multicast_ttl = 1;
imo.imo_multicast_vif = -1;
/*
* Request loopback of the report if we are acting as a multicast
* router, so that the process-level routing demon can hear it.
*/
imo.imo_multicast_loop = (ip_mrouter != NULL);
/*
* XXX
* Do we have to worry about reentrancy here? Don't think so.
*/
ip_output(m, router_alert, &igmprt, 0, &imo, NULL);
++igmpstat.igps_snd_reports;
}
| 6,240 |
1,038 | /**
* This package (org.dataalgorithms.chap08.mapreduce) contains source code
* for chapter 08 of the Data Algorithms book published by O'Reilly.
*
* First solution: representing friends as String/Text:
*
* CommonFriendsDriver.java
* CommonFriendsMapper.java
* CommonFriendsReducer.java
*
*
* Second solution: representing friends as ArrayListOfLongsWritable:
*
* CommonFriendsDriverUsingList.java
* CommonFriendsMapperUsingList.java
* CommonFriendsReducerUsingList.java
*
*
* @author <NAME>
*
*/
package org.dataalgorithms.chap08.mapreduce;
//rest of the file is empty
| 217 |
2,151 | <reponame>nagineni/chromium-crosswalk<filename>chrome/common/extensions/docs/server2/file_system_util.py
# Copyright 2013 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 posixpath
def CreateURLsFromPaths(file_system, directory, urlprefix):
'''Yields a tuple (url, prefix) for every file in |directory|, where the URL
is given relative to |urlprefix|.
'''
for root, _, files in file_system.Walk(directory):
for f in files:
url = posixpath.join(urlprefix, root, f)
yield url, posixpath.join(directory, root, f)
| 211 |
760 | <reponame>hexiangyuan/react-native-multibundler<filename>android/app/src/main/java/com/reactnative_multibundler/UpdateProgressListener.java
package com.reactnative_multibundler;
public interface UpdateProgressListener {
public void updateProgressChange(int precent);
public void complete(boolean success);
}
| 95 |
458 | <gh_stars>100-1000
/*
* mod_vhostdb - virtual hosts mapping from backend database
*
* Copyright(c) 2017 <NAME> <EMAIL> All rights reserved
* License: BSD 3-clause (same as lighttpd)
*/
#include "first.h"
#include <stdlib.h>
#include <string.h>
#include "mod_vhostdb_api.h"
#include "base.h"
#include "plugin.h"
#include "plugin_config.h"
#include "log.h"
#include "stat_cache.h"
#include "algo_splaytree.h"
/**
* vhostdb framework
*/
typedef struct {
splay_tree *sptree; /* data in nodes of tree are (vhostdb_cache_entry *) */
time_t max_age;
} vhostdb_cache;
typedef struct {
const http_vhostdb_backend_t *vhostdb_backend;
vhostdb_cache *vhostdb_cache;
} plugin_config;
typedef struct {
PLUGIN_DATA;
plugin_config defaults;
plugin_config conf;
} plugin_data;
typedef struct {
char *server_name;
char *document_root;
uint32_t slen;
uint32_t dlen;
unix_time64_t ctime;
} vhostdb_cache_entry;
static vhostdb_cache_entry *
vhostdb_cache_entry_init (const buffer * const server_name, const buffer * const docroot)
{
const uint32_t slen = buffer_clen(server_name);
const uint32_t dlen = buffer_clen(docroot);
vhostdb_cache_entry * const ve =
malloc(sizeof(vhostdb_cache_entry) + slen + dlen);
force_assert(ve);
ve->ctime = log_monotonic_secs;
ve->slen = slen;
ve->dlen = dlen;
ve->server_name = (char *)(ve + 1);
ve->document_root = ve->server_name + slen;
memcpy(ve->server_name, server_name->ptr, slen);
memcpy(ve->document_root, docroot->ptr, dlen);
return ve;
}
static void
vhostdb_cache_entry_free (vhostdb_cache_entry *ve)
{
free(ve);
}
static void
vhostdb_cache_free (vhostdb_cache *vc)
{
splay_tree *sptree = vc->sptree;
while (sptree) {
vhostdb_cache_entry_free(sptree->data);
sptree = splaytree_delete(sptree, sptree->key);
}
free(vc);
}
static vhostdb_cache *
vhostdb_cache_init (const array *opts)
{
vhostdb_cache *vc = malloc(sizeof(vhostdb_cache));
force_assert(vc);
vc->sptree = NULL;
vc->max_age = 600; /* 10 mins */
for (uint32_t i = 0, used = opts->used; i < used; ++i) {
data_unset *du = opts->data[i];
if (buffer_is_equal_string(&du->key, CONST_STR_LEN("max-age")))
vc->max_age = (time_t)config_plugin_value_to_int32(du, vc->max_age);
}
return vc;
}
static vhostdb_cache_entry *
mod_vhostdb_cache_query (request_st * const r, plugin_data * const p)
{
const int ndx = splaytree_djbhash(BUF_PTR_LEN(&r->uri.authority));
splay_tree ** const sptree = &p->conf.vhostdb_cache->sptree;
*sptree = splaytree_splay(*sptree, ndx);
vhostdb_cache_entry * const ve =
(*sptree && (*sptree)->key == ndx) ? (*sptree)->data : NULL;
return ve
&& buffer_is_equal_string(&r->uri.authority, ve->server_name, ve->slen)
? ve
: NULL;
}
static void
mod_vhostdb_cache_insert (request_st * const r, plugin_data * const p, vhostdb_cache_entry * const ve)
{
const int ndx = splaytree_djbhash(BUF_PTR_LEN(&r->uri.authority));
splay_tree ** const sptree = &p->conf.vhostdb_cache->sptree;
/*(not necessary to re-splay (with current usage) since single-threaded
* and splaytree has not been modified since mod_vhostdb_cache_query())*/
/* *sptree = splaytree_splay(*sptree, ndx); */
if (NULL == *sptree || (*sptree)->key != ndx)
*sptree = splaytree_insert(*sptree, ndx, ve);
else { /* collision; replace old entry */
vhostdb_cache_entry_free((*sptree)->data);
(*sptree)->data = ve;
}
}
INIT_FUNC(mod_vhostdb_init) {
return calloc(1, sizeof(plugin_data));
}
FREE_FUNC(mod_vhostdb_free) {
plugin_data *p = p_d;
if (NULL == p->cvlist) return;
/* (init i to 0 if global context; to 1 to skip empty global context) */
for (int i = !p->cvlist[0].v.u2[1], used = p->nconfig; i < used; ++i) {
config_plugin_value_t *cpv = p->cvlist + p->cvlist[i].v.u2[0];
for (; -1 != cpv->k_id; ++cpv) {
if (cpv->vtype != T_CONFIG_LOCAL || NULL == cpv->v.v) continue;
switch (cpv->k_id) {
case 1: /* vhostdb.cache */
vhostdb_cache_free(cpv->v.v);
break;
default:
break;
}
}
}
http_vhostdb_dumbdata_reset();
}
static void mod_vhostdb_merge_config_cpv(plugin_config * const pconf, const config_plugin_value_t * const cpv) {
switch (cpv->k_id) { /* index into static config_plugin_keys_t cpk[] */
case 0: /* vhostdb.backend */
if (cpv->vtype == T_CONFIG_LOCAL)
pconf->vhostdb_backend = cpv->v.v;
break;
case 1: /* vhostdb.cache */
if (cpv->vtype == T_CONFIG_LOCAL)
pconf->vhostdb_cache = cpv->v.v;
break;
default:/* should not happen */
return;
}
}
static void mod_vhostdb_merge_config(plugin_config * const pconf, const config_plugin_value_t *cpv) {
do {
mod_vhostdb_merge_config_cpv(pconf, cpv);
} while ((++cpv)->k_id != -1);
}
static void mod_vhostdb_patch_config(request_st * const r, plugin_data * const p) {
memcpy(&p->conf, &p->defaults, sizeof(plugin_config));
for (int i = 1, used = p->nconfig; i < used; ++i) {
if (config_check_cond(r, (uint32_t)p->cvlist[i].k_id))
mod_vhostdb_merge_config(&p->conf, p->cvlist + p->cvlist[i].v.u2[0]);
}
}
SETDEFAULTS_FUNC(mod_vhostdb_set_defaults) {
static const config_plugin_keys_t cpk[] = {
{ CONST_STR_LEN("vhostdb.backend"),
T_CONFIG_STRING,
T_CONFIG_SCOPE_CONNECTION }
,{ CONST_STR_LEN("vhostdb.cache"),
T_CONFIG_ARRAY,
T_CONFIG_SCOPE_CONNECTION }
,{ NULL, 0,
T_CONFIG_UNSET,
T_CONFIG_SCOPE_UNSET }
};
plugin_data * const p = p_d;
if (!config_plugin_values_init(srv, p, cpk, "mod_vhostdb"))
return HANDLER_ERROR;
/* process and validate config directives
* (init i to 0 if global context; to 1 to skip empty global context) */
for (int i = !p->cvlist[0].v.u2[1]; i < p->nconfig; ++i) {
config_plugin_value_t *cpv = p->cvlist + p->cvlist[i].v.u2[0];
for (; -1 != cpv->k_id; ++cpv) {
switch (cpv->k_id) {
case 0: /* vhostdb.backend */
if (!buffer_is_blank(cpv->v.b)) {
const buffer * const b = cpv->v.b;
*(const void **)&cpv->v.v = http_vhostdb_backend_get(b);
if (NULL == cpv->v.v) {
log_error(srv->errh, __FILE__, __LINE__,
"vhostdb.backend not supported: %s", b->ptr);
return HANDLER_ERROR;
}
cpv->vtype = T_CONFIG_LOCAL;
}
break;
case 1: /* vhostdb.cache */
cpv->v.v = vhostdb_cache_init(cpv->v.a);
cpv->vtype = T_CONFIG_LOCAL;
break;
default:/* should not happen */
break;
}
}
}
/* initialize p->defaults from global config context */
if (p->nconfig > 0 && p->cvlist->v.u2[1]) {
const config_plugin_value_t *cpv = p->cvlist + p->cvlist->v.u2[0];
if (-1 != cpv->k_id)
mod_vhostdb_merge_config(&p->defaults, cpv);
}
return HANDLER_GO_ON;
}
REQUEST_FUNC(mod_vhostdb_handle_request_reset) {
plugin_data *p = p_d;
vhostdb_cache_entry *ve;
if ((ve = r->plugin_ctx[p->id])) {
r->plugin_ctx[p->id] = NULL;
vhostdb_cache_entry_free(ve);
}
return HANDLER_GO_ON;
}
__attribute_cold__
static handler_t mod_vhostdb_error_500 (request_st * const r)
{
r->http_status = 500; /* Internal Server Error */
r->handler_module = NULL;
return HANDLER_FINISHED;
}
static handler_t mod_vhostdb_found (request_st * const r, vhostdb_cache_entry * const ve)
{
/* fix virtual server and docroot */
if (ve->slen) {
r->server_name = &r->server_name_buf;
buffer_copy_string_len(&r->server_name_buf, ve->server_name, ve->slen);
}
buffer_copy_string_len(&r->physical.doc_root, ve->document_root, ve->dlen);
return HANDLER_GO_ON;
}
REQUEST_FUNC(mod_vhostdb_handle_docroot) {
plugin_data *p = p_d;
vhostdb_cache_entry *ve;
/* no host specified? */
if (buffer_is_blank(&r->uri.authority)) return HANDLER_GO_ON;
/* check if cached this connection */
ve = r->plugin_ctx[p->id];
if (ve
&& buffer_is_equal_string(&r->uri.authority, ve->server_name, ve->slen))
return mod_vhostdb_found(r, ve); /* HANDLER_GO_ON */
mod_vhostdb_patch_config(r, p);
if (!p->conf.vhostdb_backend) return HANDLER_GO_ON;
if (p->conf.vhostdb_cache && (ve = mod_vhostdb_cache_query(r, p)))
return mod_vhostdb_found(r, ve); /* HANDLER_GO_ON */
buffer * const b = r->tmp_buf; /*(cleared before use in backend->query())*/
const http_vhostdb_backend_t * const backend = p->conf.vhostdb_backend;
if (0 != backend->query(r, backend->p_d, b)) {
return mod_vhostdb_error_500(r); /* HANDLER_FINISHED */
}
if (buffer_is_blank(b)) {
/* no such virtual host */
return HANDLER_GO_ON;
}
/* sanity check that really is a directory */
buffer_append_slash(b);
if (!stat_cache_path_isdir(b)) {
log_perror(r->conf.errh, __FILE__, __LINE__, "%s", b->ptr);
return mod_vhostdb_error_500(r); /* HANDLER_FINISHED */
}
if (ve && !p->conf.vhostdb_cache)
vhostdb_cache_entry_free(ve);
ve = vhostdb_cache_entry_init(&r->uri.authority, b);
if (!p->conf.vhostdb_cache)
r->plugin_ctx[p->id] = ve;
else
mod_vhostdb_cache_insert(r, p, ve);
return mod_vhostdb_found(r, ve); /* HANDLER_GO_ON */
}
/* walk though cache, collect expired ids, and remove them in a second loop */
static void
mod_vhostdb_tag_old_entries (splay_tree * const t, int * const keys, int * const ndx, const time_t max_age, const unix_time64_t cur_ts)
{
if (*ndx == 8192) return; /*(must match num array entries in keys[])*/
if (t->left)
mod_vhostdb_tag_old_entries(t->left, keys, ndx, max_age, cur_ts);
if (t->right)
mod_vhostdb_tag_old_entries(t->right, keys, ndx, max_age, cur_ts);
if (*ndx == 8192) return; /*(must match num array entries in keys[])*/
const vhostdb_cache_entry * const ve = t->data;
if (cur_ts - ve->ctime > max_age)
keys[(*ndx)++] = t->key;
}
__attribute_noinline__
static void
mod_vhostdb_periodic_cleanup(splay_tree **sptree_ptr, const time_t max_age, const unix_time64_t cur_ts)
{
splay_tree *sptree = *sptree_ptr;
int max_ndx, i;
int keys[8192]; /* 32k size on stack */
do {
if (!sptree) break;
max_ndx = 0;
mod_vhostdb_tag_old_entries(sptree, keys, &max_ndx, max_age, cur_ts);
for (i = 0; i < max_ndx; ++i) {
int ndx = keys[i];
sptree = splaytree_splay(sptree, ndx);
if (sptree && sptree->key == ndx) {
vhostdb_cache_entry_free(sptree->data);
sptree = splaytree_delete(sptree, ndx);
}
}
} while (max_ndx == sizeof(keys)/sizeof(int));
*sptree_ptr = sptree;
}
TRIGGER_FUNC(mod_vhostdb_periodic)
{
const plugin_data * const p = p_d;
const unix_time64_t cur_ts = log_monotonic_secs;
if (cur_ts & 0x7) return HANDLER_GO_ON; /*(continue once each 8 sec)*/
UNUSED(srv);
/* future: might construct array of (vhostdb_cache *) at startup
* to avoid the need to search for them here */
/* (init i to 0 if global context; to 1 to skip empty global context) */
if (NULL == p->cvlist) return HANDLER_GO_ON;
for (int i = !p->cvlist[0].v.u2[1], used = p->nconfig; i < used; ++i) {
const config_plugin_value_t *cpv = p->cvlist + p->cvlist[i].v.u2[0];
for (; cpv->k_id != -1; ++cpv) {
if (cpv->k_id != 1) continue; /* k_id == 1 for vhostdb.cache */
if (cpv->vtype != T_CONFIG_LOCAL) continue;
vhostdb_cache *vc = cpv->v.v;
mod_vhostdb_periodic_cleanup(&vc->sptree, vc->max_age, cur_ts);
}
}
return HANDLER_GO_ON;
}
int mod_vhostdb_plugin_init(plugin *p);
int mod_vhostdb_plugin_init(plugin *p) {
p->version = LIGHTTPD_VERSION_ID;
p->name = "vhostdb";
p->init = mod_vhostdb_init;
p->cleanup = mod_vhostdb_free;
p->set_defaults = mod_vhostdb_set_defaults;
p->handle_trigger = mod_vhostdb_periodic;
p->handle_docroot = mod_vhostdb_handle_docroot;
p->handle_request_reset = mod_vhostdb_handle_request_reset;
return 0;
}
| 6,146 |
3,102 | <gh_stars>1000+
//===--- OperatorKinds.h - C++ Overloaded Operators -------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
///
/// \file
/// Defines an enumeration for C++ overloaded operators.
///
//===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_BASIC_OPERATORKINDS_H
#define LLVM_CLANG_BASIC_OPERATORKINDS_H
namespace clang {
/// Enumeration specifying the different kinds of C++ overloaded
/// operators.
enum OverloadedOperatorKind : int {
OO_None, ///< Not an overloaded operator
#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
OO_##Name,
#include "clang/Basic/OperatorKinds.def"
NUM_OVERLOADED_OPERATORS
};
/// Retrieve the spelling of the given overloaded operator, without
/// the preceding "operator" keyword.
const char *getOperatorSpelling(OverloadedOperatorKind Operator);
/// Get the other overloaded operator that the given operator can be rewritten
/// into, if any such operator exists.
inline OverloadedOperatorKind
getRewrittenOverloadedOperator(OverloadedOperatorKind Kind) {
switch (Kind) {
case OO_Less:
case OO_LessEqual:
case OO_Greater:
case OO_GreaterEqual:
return OO_Spaceship;
case OO_ExclaimEqual:
return OO_EqualEqual;
default:
return OO_None;
}
}
} // end namespace clang
#endif
| 508 |
2,542 | // ------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License (MIT). See License.txt in the repo root for license information.
// ------------------------------------------------------------
#pragma once
namespace Store
{
namespace StoreBackupType
{
enum Enum : ULONG
{
None = 0,
Full = 1,
Incremental = 2
};
void WriteToTextWriter(__in Common::TextWriter & w, Enum const & e);
};
class BackupRestoreData : public Serialization::FabricSerializable
{
public:
static Common::GlobalWString FileName;
BackupRestoreData()
: partitionInfo_()
, backupType_(StoreBackupType::None)
, backupChainGuid_(Common::Guid::Empty())
, backupIndex_(0)
, backupFiles_()
, replicaId_(0)
, timeStampUtc_(Common::DateTime::Now())
{
}
explicit BackupRestoreData(
ServiceModel::ServicePartitionInformation const & partitionInfo,
::FABRIC_REPLICA_ID replicaId,
StoreBackupType::Enum backupType,
Common::Guid backupChainGuid,
ULONG backupIndex,
std::unordered_set<std::wstring> && backupFiles)
: partitionInfo_(partitionInfo)
, backupType_(backupType)
, backupChainGuid_(backupChainGuid)
, backupIndex_(backupIndex)
, backupFiles_(std::move(backupFiles))
, replicaId_(replicaId)
, timeStampUtc_(Common::DateTime::Now())
{
}
__declspec(property(get=get_PartitionInfo)) ServiceModel::ServicePartitionInformation const & PartitionInfo;
ServiceModel::ServicePartitionInformation const & get_PartitionInfo() const { return partitionInfo_; }
__declspec(property(get = get_BackupType)) StoreBackupType::Enum const & BackupType;
StoreBackupType::Enum const & get_BackupType() const { return backupType_; }
__declspec(property(get = get_BackupIndex)) ULONG const & BackupIndex;
ULONG const & get_BackupIndex() const { return backupIndex_; }
__declspec(property(get = get_BackupChainGuid)) Common::Guid const & BackupChainGuid;
Common::Guid const & get_BackupChainGuid() const { return backupChainGuid_; }
__declspec(property(get = get_ReplicaId)) ::FABRIC_REPLICA_ID const & ReplicaId;
::FABRIC_REPLICA_ID const & get_ReplicaId() const { return replicaId_; }
__declspec(property(get = get_TimeStampUtc)) Common::DateTime const & TimeStampUtc;
Common::DateTime const & get_TimeStampUtc() const { return timeStampUtc_; }
__declspec(property(get = get_BackupFiles)) std::unordered_set<std::wstring> const & BackupFiles;
std::unordered_set<std::wstring> const & get_BackupFiles() const { return backupFiles_; }
void WriteTo(Common::TextWriter&, Common::FormatOptions const &) const;
FABRIC_FIELDS_07(partitionInfo_, backupType_, backupIndex_, backupChainGuid_, replicaId_, timeStampUtc_, backupFiles_);
private:
ServiceModel::ServicePartitionInformation partitionInfo_;
StoreBackupType::Enum backupType_;
Common::Guid backupChainGuid_;
ULONG backupIndex_;
std::unordered_set<std::wstring> backupFiles_;
// For debugging purposes
::FABRIC_REPLICA_ID replicaId_;
Common::DateTime timeStampUtc_;
};
}
| 1,432 |
433 | <reponame>Andrewnetwork/WorkshopScipy<gh_stars>100-1000
# To be interactively typed in order to explore TF basics.
# Following Oriley's: Hello TensorFlow
## Basic Exploration ##
import tensorflow as tf
graph = tf.get_default_graph()
graph.get_operations()
input_value = tf.constant(1.0)
operations = graph.get_operations()
operations
operations[0].node_def
sess = tf.Session()
# TensorFlow manages it's own state of things and maintains a method of evaluating and executing code.
sess.run(input_value)
## The simplest TensorFlow neuron ##
weight = tf.Variable(0.8)
# Display the operations added to the graph as a result.
for op in graph.get_operations(): print(op.name)
output_value = weight * input_value
op = graph.get_operations()[-1]
op.name
for op_input in op.inputs: print(op_input)
# Generates an operation which initializes all our variables ( in this case just weight ).
#if you add more variables you'll want to use tf.initialize_all_variables() again; a stale init wouldn't include the new variables.
init = tf.initialize_all_variables()
sess.run(init)
sess.run(output_value)
x = tf.constant(1.0, name='input')
w = tf.Variable(0.8, name='weight')
y = tf.mul(w, x, name='output')
summary_writer = tf.train.SummaryWriter('log_simple_graph', sess.graph_def)
# Command line: tensorboard --logdir=log_simple_graph
#localhost:6006/#graphs
## Training a sinngle Neuron ##
y_ = tf.constant(0.0)
# Defining the loss function as the squared diff between current output and desired.
loss = (y - y_)**2
optim = tf.train.GradientDescentOptimizer(learning_rate=0.025)
grads_and_vars = optim.compute_gradients(loss)
sess.run(tf.initialize_all_variables())
sess.run(grads_and_vars[1][0])
sess.run(optim.apply_gradients(grads_and_vars))
sess.run(w)
train_step = tf.train.GradientDescentOptimizer(0.025).minimize(loss)
for i in range(100):
print('before step {}, y is {}'.format(i, sess.run(y)))
summary_str = sess.run(summary_y)
summary_writer.add_summary(summary_str, i)
sess.run(train_step)
sess.run(y)
| 736 |
488 | #include <sys/types.h>
#include <unistd.h>
#include <err.h>
char *TCID = "syscall.47";
int TST_TOTAL = 1;
int main() {
int result = getgid();
if( result == -1 )
err(1,"getgid failed");
return 0;
}
| 95 |
831 | /*
* Copyright (C) 2018 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 com.android.tools.idea.gradle.dsl.parser.configurations;
import com.android.tools.idea.gradle.dsl.parser.elements.GradleDslBlockElement;
import com.android.tools.idea.gradle.dsl.parser.elements.GradleDslElement;
import com.android.tools.idea.gradle.dsl.parser.elements.GradleDslNamedDomainContainer;
import com.android.tools.idea.gradle.dsl.parser.elements.GradleNameElement;
import com.android.tools.idea.gradle.dsl.parser.semantics.PropertiesElementDescription;
import org.jetbrains.annotations.NotNull;
public class ConfigurationsDslElement extends GradleDslBlockElement implements GradleDslNamedDomainContainer {
public static final PropertiesElementDescription<ConfigurationsDslElement> CONFIGURATIONS =
new PropertiesElementDescription<>("configurations", ConfigurationsDslElement.class, ConfigurationsDslElement::new);
@Override
public PropertiesElementDescription getChildPropertiesElementDescription(String name) {
return ConfigurationDslElement.CONFIGURATION;
}
@Override
public boolean implicitlyExists(@NotNull String name) {
// TODO(xof): this is potentially quite complicated, and dependent on the state of the Dsl. Since our main use at the moment is
// to create configurations to work around a *lack* of implicit creation, return false here, but we should probably account for
// the basic artifacts ("", "test", "androidTest") plus the built-in build types ("release", "debug") plus the built-in configuration
// kinds ("api", "compile", "implementation", etc.) There is code in the Project System that compiles valid configurations, though
// from a complete Dsl model, rather than the partial one we have here...
return false;
}
public ConfigurationsDslElement(@NotNull GradleDslElement parent, @NotNull GradleNameElement name) {
super(parent, name);
}
}
| 686 |
698 | <gh_stars>100-1000
from . import auth
from .ctx_tool import BaseContext
from .keyboard import *
from .uploader import *
from .template import TemplateElement, template_gen
from .loop_wrapper import DelayedTask, LoopWrapper
from .mini_types import BotTypes, message_min
from .storage import ABCStorage, CtxStorage
from .utils import convert_shorten_filter, load_blueprints_from_package, run_in_task
from .vkscript_converter import vkscript
| 126 |
2,206 | /*
*
* Copyright (c) 2006-2020, Speedment, Inc. 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.
*/
package com.speedment.runtime.field.internal;
import com.speedment.common.annotation.GeneratedCode;
import com.speedment.runtime.config.identifier.ColumnIdentifier;
import com.speedment.runtime.config.identifier.TableIdentifier;
import com.speedment.runtime.field.LongField;
import com.speedment.runtime.field.LongForeignKeyField;
import com.speedment.runtime.field.comparator.LongFieldComparator;
import com.speedment.runtime.field.comparator.NullOrder;
import com.speedment.runtime.field.internal.comparator.LongFieldComparatorImpl;
import com.speedment.runtime.field.internal.method.BackwardFinderImpl;
import com.speedment.runtime.field.internal.method.FindFromLong;
import com.speedment.runtime.field.internal.method.GetLongImpl;
import com.speedment.runtime.field.internal.predicate.longs.LongBetweenPredicate;
import com.speedment.runtime.field.internal.predicate.longs.LongEqualPredicate;
import com.speedment.runtime.field.internal.predicate.longs.LongGreaterOrEqualPredicate;
import com.speedment.runtime.field.internal.predicate.longs.LongGreaterThanPredicate;
import com.speedment.runtime.field.internal.predicate.longs.LongInPredicate;
import com.speedment.runtime.field.internal.predicate.longs.LongLessOrEqualPredicate;
import com.speedment.runtime.field.internal.predicate.longs.LongLessThanPredicate;
import com.speedment.runtime.field.internal.predicate.longs.LongNotBetweenPredicate;
import com.speedment.runtime.field.internal.predicate.longs.LongNotEqualPredicate;
import com.speedment.runtime.field.internal.predicate.longs.LongNotInPredicate;
import com.speedment.runtime.field.method.BackwardFinder;
import com.speedment.runtime.field.method.FindFrom;
import com.speedment.runtime.field.method.GetLong;
import com.speedment.runtime.field.method.LongGetter;
import com.speedment.runtime.field.method.LongSetter;
import com.speedment.runtime.field.predicate.FieldPredicate;
import com.speedment.runtime.field.predicate.Inclusion;
import com.speedment.runtime.field.predicate.SpeedmentPredicate;
import com.speedment.runtime.typemapper.TypeMapper;
import java.util.Collection;
import java.util.function.Supplier;
import java.util.stream.Stream;
import static com.speedment.runtime.field.internal.util.CollectionUtil.collectionToSet;
import static java.util.Objects.requireNonNull;
/**
* Default implementation of the {@link LongField}-interface.
*
* Generated by com.speedment.sources.pattern.FieldImplPattern
*
* @param <ENTITY> entity type
* @param <D> database type
* @param <FK_ENTITY> foreign entity type
*
* @author <NAME>
* @since 3.0.0
*/
@GeneratedCode(value = "Speedment")
public final class LongForeignKeyFieldImpl<ENTITY, D, FK_ENTITY> implements LongField<ENTITY, D>, LongForeignKeyField<ENTITY, D, FK_ENTITY> {
private final ColumnIdentifier<ENTITY> identifier;
private final GetLong<ENTITY, D> getter;
private final LongSetter<ENTITY> setter;
private final LongField<FK_ENTITY, D> referenced;
private final TypeMapper<D, Long> typeMapper;
private final boolean unique;
private final String tableAlias;
public LongForeignKeyFieldImpl(
ColumnIdentifier<ENTITY> identifier,
LongGetter<ENTITY> getter,
LongSetter<ENTITY> setter,
LongField<FK_ENTITY, D> referenced,
TypeMapper<D, Long> typeMapper,
boolean unique) {
this.identifier = requireNonNull(identifier);
this.getter = new GetLongImpl<>(this, getter);
this.setter = requireNonNull(setter);
this.referenced = requireNonNull(referenced);
this.typeMapper = requireNonNull(typeMapper);
this.unique = unique;
this.tableAlias = identifier.getTableId();
}
private LongForeignKeyFieldImpl(
ColumnIdentifier<ENTITY> identifier,
LongGetter<ENTITY> getter,
LongSetter<ENTITY> setter,
LongField<FK_ENTITY, D> referenced,
TypeMapper<D, Long> typeMapper,
boolean unique,
String tableAlias) {
this.identifier = requireNonNull(identifier);
this.getter = new GetLongImpl<>(this, getter);
this.setter = requireNonNull(setter);
this.referenced = requireNonNull(referenced);
this.typeMapper = requireNonNull(typeMapper);
this.unique = unique;
this.tableAlias = requireNonNull(tableAlias);
}
@Override
public ColumnIdentifier<ENTITY> identifier() {
return identifier;
}
@Override
public LongSetter<ENTITY> setter() {
return setter;
}
@Override
public GetLong<ENTITY, D> getter() {
return getter;
}
@Override
public LongField<FK_ENTITY, D> getReferencedField() {
return referenced;
}
@Override
public BackwardFinder<FK_ENTITY, ENTITY> backwardFinder(TableIdentifier<ENTITY> identifier, Supplier<Stream<ENTITY>> streamSupplier) {
return new BackwardFinderImpl<>(this, identifier, streamSupplier);
}
@Override
public FindFrom<ENTITY, FK_ENTITY> finder(TableIdentifier<FK_ENTITY> identifier, Supplier<Stream<FK_ENTITY>> streamSupplier) {
return new FindFromLong<>(this, referenced, identifier, streamSupplier);
}
@Override
public TypeMapper<D, Long> typeMapper() {
return typeMapper;
}
@Override
public boolean isUnique() {
return unique;
}
@Override
public String tableAlias() {
return tableAlias;
}
@Override
public LongFieldComparator<ENTITY, D> comparator() {
return new LongFieldComparatorImpl<>(this);
}
@Override
public LongFieldComparator<ENTITY, D> reversed() {
return comparator().reversed();
}
@Override
public LongFieldComparator<ENTITY, D> comparatorNullFieldsFirst() {
return comparator();
}
@Override
public NullOrder getNullOrder() {
return NullOrder.LAST;
}
@Override
public boolean isReversed() {
return false;
}
@Override
public FieldPredicate<ENTITY> equal(Long value) {
return new LongEqualPredicate<>(this, value);
}
@Override
public FieldPredicate<ENTITY> greaterThan(Long value) {
return new LongGreaterThanPredicate<>(this, value);
}
@Override
public FieldPredicate<ENTITY> greaterOrEqual(Long value) {
return new LongGreaterOrEqualPredicate<>(this, value);
}
@Override
public FieldPredicate<ENTITY> between(
Long start,
Long end,
Inclusion inclusion) {
return new LongBetweenPredicate<>(this, start, end, inclusion);
}
@Override
public FieldPredicate<ENTITY> in(Collection<Long> values) {
return new LongInPredicate<>(this, collectionToSet(values));
}
@Override
public SpeedmentPredicate<ENTITY> notEqual(Long value) {
return new LongNotEqualPredicate<>(this, value);
}
@Override
public SpeedmentPredicate<ENTITY> lessOrEqual(Long value) {
return new LongLessOrEqualPredicate<>(this, value);
}
@Override
public SpeedmentPredicate<ENTITY> lessThan(Long value) {
return new LongLessThanPredicate<>(this, value);
}
@Override
public SpeedmentPredicate<ENTITY> notBetween(
Long start,
Long end,
Inclusion inclusion) {
return new LongNotBetweenPredicate<>(this, start, end, inclusion);
}
@Override
public SpeedmentPredicate<ENTITY> notIn(Collection<Long> values) {
return new LongNotInPredicate<>(this, collectionToSet(values));
}
@Override
public LongForeignKeyField<ENTITY, D, FK_ENTITY> tableAlias(String tableAlias) {
requireNonNull(tableAlias);
return new LongForeignKeyFieldImpl<>(identifier, getter, setter, referenced, typeMapper, unique, tableAlias);
}
} | 3,251 |
339 | <filename>integration/business-process-tests/tests-integration/bpmn/src/test/java/org/wso2/ei/businessprocess/integration/tests/bpmn/ProcessInstanceTestCase.java<gh_stars>100-1000
/*
* Copyright (c) 2015, WSO2 Inc. (http://www.wso2.org) 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.
*/
package org.wso2.ei.businessprocess.integration.tests.bpmn;
import junit.framework.Assert;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.json.JSONException;
import org.testng.annotations.Test;
import org.wso2.ei.businessprocess.integration.common.clients.bpmn.ActivitiRestClient;
import org.wso2.ei.businessprocess.integration.common.clients.bpmn.RestClientException;
import org.wso2.ei.businessprocess.integration.common.utils.BPSMasterTest;
import org.wso2.carbon.automation.engine.frameworkutils.FrameworkPathUtil;
import java.io.File;
import java.io.IOException;
/**
* This class will deploy a bpmn package test the functionality of the process instance
*/
public class ProcessInstanceTestCase extends BPSMasterTest {
private static final Log log = LogFactory.getLog(ProcessInstanceTestCase.class);
/**
* The method below tests the functionality of process instance. We deploy a bpmn package and
* test
* the requests to process, process instances.
*
* @throws Exception
*/
@Test(groups = {"wso2.bps.test.processInstance"}, description = "Process Instance Test",
priority = 2, singleThreaded = true)
public void processInstanceTest() throws Exception {
init();
ActivitiRestClient tester = new ActivitiRestClient(bpsServer.getInstance().getPorts().
get("http"), bpsServer.getInstance().getHosts().get("default"));
//deploying a bpmn package to the server
String filePath = FrameworkPathUtil.getSystemResourceLocation() + File.separator
+ BPMNTestConstants.DIR_ARTIFACTS + File.separator
+ BPMNTestConstants.DIR_BPMN + File.separator + "HelloApprove.bar";
String fileName = "HelloApprove.bar";
String[] deploymentResponse = {};
try {
deploymentResponse = tester.deployBPMNPackage(filePath, fileName);
Assert.assertTrue("Deployment was not successful", deploymentResponse[0].contains
(BPMNTestConstants.CREATED));
} catch (RestClientException | IOException | JSONException exception) {
log.error("Failed to deploy the bpmn package " + fileName, exception);
Assert.fail("Failed to deploy the bpmn package " + fileName);
}
//verifying if the deployed bpmn package is present in the deployments list by validating if
// the deployment name is present in the deployment list.
try {
String[] deploymentCheckResponse = tester.getDeploymentInfoById(deploymentResponse[1]);
Assert.assertTrue("Deployment is not present", deploymentCheckResponse[2].contains
(fileName));
} catch (RestClientException | IOException | JSONException exception) {
log.error("Deployed bpmn package " + fileName + " was not found ", exception);
Assert.fail("Deployed bpmn package " + fileName + " was not found ");
}
//Acquiring Process Definition ID to start Process Instance
String[] definitionResponse = new String[0];
try {
definitionResponse = tester.findProcessDefinitionInfoById(deploymentResponse[1]);
Assert.assertTrue("Search was not success", definitionResponse[0].contains
(BPMNTestConstants.OK));
} catch (IOException | JSONException exception) {
log.error("Could not find definition id for bpmn package " + fileName, exception);
Assert.fail("Could not find definition id for bpmn package " + fileName);
}
//Starting Process Instance, we used the definition ID to start the process instance,
//when the process instance is started successfully the server responds with a status of
// 201.
String[] processInstanceResponse = new String[0];
try {
processInstanceResponse = tester.startProcessInstanceByDefintionID
(definitionResponse[1]);
Assert.assertTrue("Process instance cannot be started", processInstanceResponse[0].
contains(BPMNTestConstants.CREATED));
} catch (RestClientException | IOException | JSONException exception) {
log.error("Process instance failed to start ", exception);
Assert.fail("Process instance failed to start ");
}
//verifying if the process instance is present in the process instance list by validating if
// the process instance is present in the process instance list.If,
// present the query request
//responds with a http status 200
try {
String searchResponse = tester.searchProcessInstanceByDefintionID
(definitionResponse[1]);
Assert.assertTrue("Process instance does not exist",
searchResponse.contains(BPMNTestConstants.OK));
} catch (IOException exception) {
log.error("Process instance cannot be found", exception);
Assert.fail("Process instance cannot be found");
}
//Suspending the the process instance once the service task is completed. The request will
//respond with a status of 200 when successful.
try {
String[] suspendResponse = tester.suspendProcessInstanceById
(processInstanceResponse[1]);
Assert.assertTrue("Process instance cannot be suspended",
suspendResponse[0].contains(BPMNTestConstants.OK));
Assert.assertTrue("Process instance cannot be suspended",
suspendResponse[1].contains("true"));
} catch (RestClientException | IOException | JSONException exception) {
log.error("Process instance cannot be suspended", exception);
Assert.fail("The Process instance cannot be suspended");
}
//Validating if the process instance is in the suspended state, we retrieve the process
//instance and check the suspended state is true or false.
try {
String stateVerfication = tester.getSuspendedStateOfProcessInstanceByID
(processInstanceResponse[1]);
Assert.assertTrue("The process instance is not in suspended state", stateVerfication.
contains("true"));
} catch (IOException | JSONException exception) {
log.error("The process instance is not in suspended state", exception);
Assert.fail("The process instance is not in suspended state ");
}
//Deleting a Process Instance once the tasks are completed. When the process instance is
// removed
//the server responds with a status of 204
String deleteStatus = "";
try {
for (int i = 0; i < 10; i++) {
Thread.sleep(100);
deleteStatus = tester.deleteProcessInstanceByID(processInstanceResponse[1]);
if (deleteStatus.contains(BPMNTestConstants.NO_CONTENT)) {
break;
}
}
Assert.assertTrue("Process instance cannot be removed",
deleteStatus.contains(BPMNTestConstants.NO_CONTENT));
} catch (IOException exception) {
log.error("Process instance cannot be removed", exception);
Assert.fail("Process instance cannot be removed");
}
//validating if the process instance is removed, the request should throw an exception since
//the process instance is not there
try {
tester.validateProcessInstanceById(definitionResponse[1]);
Assert.fail("Process instance stille exists");
} catch (RestClientException | IOException | JSONException exception) {
Assert.assertTrue("Process instance was removed successfully", BPMNTestConstants.
NOT_AVAILABLE.equals(exception.getMessage()));
// If the process instance does not exist we should get the exception and testCase
// should pass.
// In that case we do not need to log the exception.
}
//Undeploying the bpmn package. The request should return response of 204 after removing the
//bpmn package.
try {
String undeployStatus = tester.unDeployBPMNPackage(deploymentResponse[1]);
Assert.assertTrue("Package cannot be undeployed",
undeployStatus.contains(BPMNTestConstants.NO_CONTENT));
} catch (IOException exception) {
log.error("Failed to undeploy bpmn package " + fileName, exception);
Assert.fail("Failed to remove bpmn package " + fileName);
}
//validating if the bpmn package was successfully removed, the request should throw an
// exception
//since the bpmn package has been removed.
try {
tester.getDeploymentInfoById(deploymentResponse[1]);
Assert.fail("Package still exists after undeployment");
} catch (RestClientException | IOException | JSONException exception) {
Assert.assertTrue("Bpmn package " + fileName + " does not exist", BPMNTestConstants.
NOT_AVAILABLE.equals(exception.getMessage()));
// If the unDeployment succeed then we should get the exception with deployment could
// not found and testCase should pass.
// In that case we do not need to log the exception.
}
}
}
| 3,929 |
3,964 |
def validate_type_strict(object_, object_types):
'''
Validates that object_ is of type object__type
:param object_: the object to check
:param object_types: the desired type of the object (or tuple of types)
'''
if not isinstance(object_types, tuple):
object_types = (object_types,)
exact_type_match = any([type(object_) == t for t in object_types])
if not exact_type_match:
error_format = 'Please pass object_ of type %s as the argument, encountered type %s'
message = error_format % (object_types, type(object_))
raise ValueError(message)
def validate_list_of_strict(object_list, object_types):
'''
Verifies that the items in object_list are of
type object__type
:param object_list: the list of objects to check
:param object_types: the type of the object (or tuple with types)
In general this goes against Python's duck typing ideology
See this discussion for instance
http://stackoverflow.com/questions/1549801/differences-between-isinstance-and-type-in-python
We use it in cases where you can configure the type of class to use
And where we should validate that you are infact supplying that class
'''
for object_ in object_list:
validate_type_strict(object_, object_types)
| 437 |
335 | <filename>M/Mature_verb.json<gh_stars>100-1000
{
"word": "Mature",
"definitions": [
"(of a person or thing) become fully grown or developed.",
"(of a person) reach an advanced stage of mental or emotional development.",
"(with reference to certain foods or drinks) become or cause to become ready for consumption.",
"(of an insurance policy, security, etc.) reach the end of its term and hence become payable."
],
"parts-of-speech": "Verb"
} | 162 |
763 | package org.batfish.common.topology.broadcast;
import static org.batfish.datamodel.InterfaceType.PHYSICAL;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import com.google.common.collect.ImmutableMap;
import org.batfish.common.topology.Layer1Edge;
import org.batfish.common.topology.Layer1Topologies;
import org.batfish.common.topology.Layer1Topology;
import org.batfish.datamodel.ConcreteInterfaceAddress;
import org.batfish.datamodel.Configuration;
import org.batfish.datamodel.Interface;
import org.batfish.datamodel.NetworkFactory;
import org.batfish.datamodel.collections.NodeInterfacePair;
import org.batfish.datamodel.vxlan.VxlanTopology;
import org.junit.Test;
public class BroadcastL3AdjacenciesTest {
/** A simple test that the code works end-to-end. */
@Test
public void testE2e() {
NetworkFactory nf = new NetworkFactory();
Configuration c1 = nf.configurationBuilder().build();
Interface i1 =
nf.interfaceBuilder()
.setOwner(c1)
.setType(PHYSICAL)
.setActive(true)
.setAddress(ConcreteInterfaceAddress.parse("1.2.3.1/24"))
.build();
NodeInterfacePair n1 = NodeInterfacePair.of(i1);
Configuration c2 = nf.configurationBuilder().build();
Interface i2 =
nf.interfaceBuilder()
.setOwner(c2)
.setType(PHYSICAL)
.setActive(true)
.setAddress(ConcreteInterfaceAddress.parse("1.2.3.2/24"))
.build();
NodeInterfacePair n2 = NodeInterfacePair.of(i2);
Configuration c3 = nf.configurationBuilder().build();
Interface i3 =
nf.interfaceBuilder()
.setOwner(c3)
.setType(PHYSICAL)
.setActive(true)
.setAddress(ConcreteInterfaceAddress.parse("1.2.3.3/24"))
.build();
NodeInterfacePair n3 = NodeInterfacePair.of(i3);
{
// With no L1 topology, all 3 interfaces in same domain but not p2p domain.
BroadcastL3Adjacencies adjacencies =
BroadcastL3Adjacencies.create(
Layer1Topologies.empty(),
VxlanTopology.EMPTY,
ImmutableMap.of(c1.getHostname(), c1, c2.getHostname(), c2, c3.getHostname(), c3));
assertTrue(adjacencies.inSameBroadcastDomain(n1, n2));
assertTrue(adjacencies.inSameBroadcastDomain(n2, n1));
assertTrue(adjacencies.inSameBroadcastDomain(n2, n3));
assertTrue(adjacencies.inSameBroadcastDomain(n3, n1));
assertFalse(adjacencies.inSamePointToPointDomain(n1, n2));
assertFalse(adjacencies.inSamePointToPointDomain(n2, n3));
assertFalse(adjacencies.inSamePointToPointDomain(n3, n1));
}
{
// With L1 topology, only connected interfaces in same domain.
Layer1Topology physical =
new Layer1Topology(
new Layer1Edge(
n1.getHostname(), n1.getInterface(), n3.getHostname(), n3.getInterface()));
BroadcastL3Adjacencies adjacencies =
BroadcastL3Adjacencies.create(
new Layer1Topologies(physical, Layer1Topology.EMPTY, physical, physical),
VxlanTopology.EMPTY,
ImmutableMap.of(c1.getHostname(), c1, c2.getHostname(), c2, c3.getHostname(), c3));
assertTrue(adjacencies.inSameBroadcastDomain(n1, n3));
assertFalse(adjacencies.inSameBroadcastDomain(n2, n3));
assertFalse(adjacencies.inSameBroadcastDomain(n2, n1));
assertTrue(adjacencies.inSamePointToPointDomain(n1, n3));
assertTrue(adjacencies.inSamePointToPointDomain(n3, n1));
assertFalse(adjacencies.inSamePointToPointDomain(n2, n3));
assertFalse(adjacencies.inSamePointToPointDomain(n1, n2));
}
{
// Encapsulation vlan honored, even with no L1.
i1.setEncapsulationVlan(4);
BroadcastL3Adjacencies adjacencies =
BroadcastL3Adjacencies.create(
Layer1Topologies.empty(),
VxlanTopology.EMPTY,
ImmutableMap.of(c1.getHostname(), c1, c2.getHostname(), c2, c3.getHostname(), c3));
assertTrue(adjacencies.inSameBroadcastDomain(n2, n3));
assertFalse(adjacencies.inSameBroadcastDomain(n1, n2));
assertFalse(adjacencies.inSameBroadcastDomain(n1, n3));
assertFalse(adjacencies.inSamePointToPointDomain(n2, n3));
assertFalse(adjacencies.inSamePointToPointDomain(n1, n2));
}
}
}
| 1,887 |
611 | package fr.adrienbrault.idea.symfony2plugin.intentions.xml;
import com.intellij.codeInsight.hint.HintManager;
import com.intellij.codeInsight.intention.PsiElementBaseIntentionAction;
import com.intellij.ide.highlighter.XmlFileType;
import com.intellij.openapi.editor.Editor;
import com.intellij.openapi.project.Project;
import com.intellij.psi.PsiElement;
import com.intellij.psi.XmlElementFactory;
import com.intellij.psi.xml.XmlAttribute;
import com.intellij.psi.xml.XmlTag;
import com.intellij.util.IncorrectOperationException;
import com.jetbrains.php.lang.psi.elements.PhpClass;
import fr.adrienbrault.idea.symfony2plugin.Symfony2ProjectComponent;
import fr.adrienbrault.idea.symfony2plugin.action.ServiceActionUtil;
import fr.adrienbrault.idea.symfony2plugin.intentions.php.XmlServiceArgumentIntention;
import fr.adrienbrault.idea.symfony2plugin.stubs.ContainerCollectionResolver;
import fr.adrienbrault.idea.symfony2plugin.util.dict.ServiceTag;
import fr.adrienbrault.idea.symfony2plugin.util.dict.ServiceUtil;
import org.jetbrains.annotations.NotNull;
import java.util.Set;
/**
* @author <NAME> <<EMAIL>>
*/
public class XmlServiceTagIntention extends PsiElementBaseIntentionAction {
@Override
public boolean isAvailable(@NotNull Project project, Editor editor, @NotNull PsiElement psiElement) {
if(psiElement.getContainingFile().getFileType() != XmlFileType.INSTANCE || !Symfony2ProjectComponent.isEnabled(psiElement.getProject())) {
return false;
}
return XmlServiceArgumentIntention.getServiceTagValid(psiElement) != null;
}
@Override
public void invoke(@NotNull final Project project, final Editor editor, @NotNull PsiElement psiElement) throws IncorrectOperationException {
final XmlTag xmlTag = XmlServiceArgumentIntention.getServiceTagValid(psiElement);
if(xmlTag == null) {
return;
}
final PhpClass phpClassFromXmlTag = ServiceActionUtil.getPhpClassFromXmlTag(xmlTag, new ContainerCollectionResolver.LazyServiceCollector(project));
if(phpClassFromXmlTag == null) {
return;
}
Set<String> phpServiceTags = ServiceUtil.getPhpClassServiceTags(phpClassFromXmlTag);
if(phpServiceTags.size() == 0) {
HintManager.getInstance().showErrorHint(editor, "Ops, no possible Tag found");
return;
}
for (XmlTag tag : xmlTag.getSubTags()) {
if(!"tag".equals(tag.getName())) {
continue;
}
XmlAttribute name = tag.getAttribute("name");
if(name == null) {
continue;
}
String value = name.getValue();
if(phpServiceTags.contains(value)) {
phpServiceTags.remove(value);
}
}
ServiceUtil.insertTagWithPopupDecision(editor, phpServiceTags, tag -> {
ServiceTag serviceTag = new ServiceTag(phpClassFromXmlTag, tag);
ServiceUtil.decorateServiceTag(serviceTag);
xmlTag.addSubTag(XmlElementFactory.getInstance(project).createTagFromText(serviceTag.toXmlString()), false);
});
}
@NotNull
@Override
public String getFamilyName() {
return "Symfony";
}
@NotNull
@Override
public String getText() {
return "Symfony: Add Tags";
}
}
| 1,374 |
892 | {
"schema_version": "1.2.0",
"id": "GHSA-2hw2-7jq8-w9vp",
"modified": "2021-12-28T00:01:18Z",
"published": "2021-12-22T00:00:48Z",
"aliases": [
"CVE-2021-24849"
],
"details": "The wcfm_ajax_controller AJAX action of the WCFM Marketplace WordPress plugin before 3.4.12, available to unauthenticated and authenticated user, does not properly sanitise multiple parameters before using them in SQL statements, leading to SQL injections",
"severity": [
],
"affected": [
],
"references": [
{
"type": "ADVISORY",
"url": "https://nvd.nist.gov/vuln/detail/CVE-2021-24849"
},
{
"type": "WEB",
"url": "https://wpscan.com/vulnerability/763c08a0-4b2b-4487-b91c-be6cc2b9322e"
}
],
"database_specific": {
"cwe_ids": [
"CWE-89"
],
"severity": "CRITICAL",
"github_reviewed": false
}
} | 385 |
1,248 | #include <iostream>
#include <vector>
#include <algorithm>
#include <string.h>
#include "driver/CustomAssert.h"
#include <vulkan/vulkan.h>
#include "driver/vkExt.h"
#include "QPUassembler/qpu_assembler.h"
//#define GLFW_INCLUDE_VULKAN
//#define VK_USE_PLATFORM_WIN32_KHR
//#include <GLFW/glfw3.h>
//#define GLFW_EXPOSE_NATIVE_WIN32
//#include <GLFW/glfw3native.h>
//GLFWwindow * window;
//#define WINDOW_WIDTH 640
//#define WINDOW_HEIGHT 480
// Note: support swap chain recreation (not only required for resized windows!)
// Note: window resize may not result in Vulkan telling that the swap chain should be recreated, should be handled explicitly!
void run();
void setupVulkan();
void mainLoop();
void cleanup();
void createInstance();
void createWindowSurface();
void findPhysicalDevice();
void checkSwapChainSupport();
void findQueueFamilies();
void createLogicalDevice();
void createSemaphores();
void createSwapChain();
void createCommandQueues();
void draw();
void CreateRenderPass();
void CreateFramebuffer();
void CreateShaders();
void CreatePipeline();
void CreateUniformBuffer();
void CreateDescriptorSet();
void CreateVertexBuffer();
void CreateTexture();
void recordCommandBuffers();
VkSurfaceFormatKHR chooseSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& availableFormats);
VkExtent2D chooseSwapExtent(const VkSurfaceCapabilitiesKHR& surfaceCapabilities);
VkPresentModeKHR choosePresentMode(const std::vector<VkPresentModeKHR> presentModes);
VkInstance instance; //
VkSurfaceKHR windowSurface; //
VkPhysicalDevice physicalDevice;
VkDevice device; //
VkSemaphore imageAvailableSemaphore; //
VkSemaphore renderingFinishedSemaphore; //
VkSwapchainKHR swapChain; //
VkCommandPool commandPool; //
std::vector<VkCommandBuffer> presentCommandBuffers; //
std::vector<VkImage> swapChainImages; //
VkRenderPass renderPass; //
std::vector<VkFramebuffer> fbs; //
VkShaderModule shaderModule; //
VkPipeline pipeline; //
VkQueue graphicsQueue;
VkQueue presentQueue;
VkBuffer vertexBuffer;
VkDeviceMemory vertexBufferMemory;
VkPhysicalDeviceMemoryProperties pdmp;
std::vector<VkImageView> views; //?
VkSurfaceFormatKHR swapchainFormat;
VkExtent2D swapChainExtent;
VkPipelineLayout pipelineLayout;
uint32_t graphicsQueueFamily;
uint32_t presentQueueFamily;
void cleanup() {
vkDeviceWaitIdle(device);
// Note: this is done implicitly when the command pool is freed, but nice to know about
vkFreeCommandBuffers(device, commandPool, presentCommandBuffers.size(), presentCommandBuffers.data());
vkDestroyCommandPool(device, commandPool, nullptr);
vkDestroySemaphore(device, imageAvailableSemaphore, nullptr);
vkDestroySemaphore(device, renderingFinishedSemaphore, nullptr);
for(int c = 0; c < views.size(); ++c)
vkDestroyImageView(device, views[c], 0);
for (int c = 0; c < fbs.size(); ++c)
vkDestroyFramebuffer(device, fbs[c], 0);
vkDestroyRenderPass(device, renderPass, 0);
vkDestroyShaderModule(device, shaderModule, 0);
vkDestroyPipeline(device, pipeline, 0);
// Note: implicitly destroys images (in fact, we're not allowed to do that explicitly)
vkDestroySwapchainKHR(device, swapChain, nullptr);
vkDestroyDevice(device, nullptr);
vkDestroySurfaceKHR(instance, windowSurface, nullptr);
vkDestroyInstance(instance, nullptr);
}
void run() {
// Note: dynamically loading loader may be a better idea to fail gracefully when Vulkan is not supported
// Create window for Vulkan
//glfwInit();
//glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
//glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE);
//window = glfwCreateWindow(WINDOW_WIDTH, WINDOW_HEIGHT, "The 630 line cornflower blue window", nullptr, nullptr);
// Use Vulkan
setupVulkan();
mainLoop();
cleanup();
}
void setupVulkan() {
createInstance();
findPhysicalDevice();
createWindowSurface();
checkSwapChainSupport();
findQueueFamilies();
createLogicalDevice();
createSemaphores();
createSwapChain();
createCommandQueues();
CreateRenderPass();
CreateFramebuffer();
CreateVertexBuffer();
//CreateUniformBuffer();
CreateShaders();
CreatePipeline();
recordCommandBuffers();
}
void mainLoop() {
//while (!glfwWindowShouldClose(window)) {
for(int c = 0; c < 300; ++c){
draw();
//glfwPollEvents();
}
}
void createInstance() {
VkApplicationInfo appInfo = {};
appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
appInfo.pApplicationName = "VulkanTriangle";
appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
appInfo.pEngineName = "TriangleEngine";
appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0);
appInfo.apiVersion = VK_API_VERSION_1_0;
// Get instance extensions required by GLFW to draw to window
//unsigned int glfwExtensionCount;
//const char** glfwExtensions;
//glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
// Check for extensions
uint32_t extensionCount = 0;
vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, nullptr);
if (extensionCount == 0) {
std::cerr << "no extensions supported!" << std::endl;
assert(0);
}
std::vector<VkExtensionProperties> availableExtensions(extensionCount);
vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, availableExtensions.data());
std::cout << "supported extensions:" << std::endl;
for (const auto& extension : availableExtensions) {
std::cout << "\t" << extension.extensionName << std::endl;
}
const char* enabledExtensions[] = {
"VK_KHR_surface",
"VK_KHR_display"
};
VkInstanceCreateInfo createInfo = {};
createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
createInfo.pNext = 0;
createInfo.pApplicationInfo = &appInfo;
createInfo.enabledExtensionCount = sizeof(enabledExtensions) / sizeof(const char*);
createInfo.ppEnabledExtensionNames = enabledExtensions;
createInfo.enabledLayerCount = 0;
createInfo.ppEnabledLayerNames = 0;
// Initialize Vulkan instance
if (vkCreateInstance(&createInfo, nullptr, &instance) != VK_SUCCESS) {
std::cerr << "failed to create instance!" << std::endl;
assert(0);
}
else {
std::cout << "created vulkan instance" << std::endl;
}
}
void createWindowSurface() {
windowSurface = 0;
uint32_t displayCount;
vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, &displayCount, 0);
VkDisplayPropertiesKHR* displayProperties = (VkDisplayPropertiesKHR*)malloc(sizeof(VkDisplayPropertiesKHR)*displayCount);
vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, &displayCount, displayProperties);
printf("Enumerated displays\n");
for(uint32_t c = 0; c < displayCount; ++c)
{
printf("Display ID %i\n", displayProperties[c].display);
printf("Display name %s\n", displayProperties[c].displayName);
printf("Display width %i\n", displayProperties[c].physicalDimensions.width);
printf("Display height %i\n", displayProperties[c].physicalDimensions.height);
printf("Display horizontal resolution %i\n", displayProperties[c].physicalResolution.width);
printf("Display vertical resolution %i\n", displayProperties[c].physicalResolution.height);
}
uint32_t modeCount;
vkGetDisplayModePropertiesKHR(physicalDevice, displayProperties[0].display, &modeCount, 0);
VkDisplayModePropertiesKHR* displayModeProperties = (VkDisplayModePropertiesKHR*)malloc(sizeof(VkDisplayModePropertiesKHR)*modeCount);
vkGetDisplayModePropertiesKHR(physicalDevice, displayProperties[0].display, &modeCount, displayModeProperties);
// printf("\nEnumerated modes\n");
// for(uint32_t c = 0; c < modeCount; ++c)
// {
// printf("Mode refresh rate %i\n", displayModeProperties[c].parameters.refreshRate);
// printf("Mode width %i\n", displayModeProperties[c].parameters.visibleRegion.width);
// printf("Mode height %i\n\n", displayModeProperties[c].parameters.visibleRegion.height);
// }
VkDisplaySurfaceCreateInfoKHR dsci = {};
dsci.sType = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR;
dsci.displayMode = displayModeProperties[0].displayMode;
dsci.transform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
dsci.alphaMode = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR;
dsci.imageExtent = displayModeProperties[0].parameters.visibleRegion;
vkCreateDisplayPlaneSurfaceKHR(instance, &dsci, 0, &windowSurface);
std::cout << "created window surface" << std::endl;
}
void findPhysicalDevice() {
// Try to find 1 Vulkan supported device
// Note: perhaps refactor to loop through devices and find first one that supports all required features and extensions
uint32_t deviceCount = 1;
VkResult res = vkEnumeratePhysicalDevices(instance, &deviceCount, &physicalDevice);
if (res != VK_SUCCESS && res != VK_INCOMPLETE) {
std::cerr << "enumerating physical devices failed!" << std::endl;
assert(0);
}
if (deviceCount == 0) {
std::cerr << "no physical devices that support vulkan!" << std::endl;
assert(0);
}
std::cout << "physical device with vulkan support found" << std::endl;
vkGetPhysicalDeviceMemoryProperties(physicalDevice, &pdmp);
// Check device features
// Note: will apiVersion >= appInfo.apiVersion? Probably yes, but spec is unclear.
VkPhysicalDeviceProperties deviceProperties;
VkPhysicalDeviceFeatures deviceFeatures;
vkGetPhysicalDeviceProperties(physicalDevice, &deviceProperties);
vkGetPhysicalDeviceFeatures(physicalDevice, &deviceFeatures);
uint32_t supportedVersion[] = {
VK_VERSION_MAJOR(deviceProperties.apiVersion),
VK_VERSION_MINOR(deviceProperties.apiVersion),
VK_VERSION_PATCH(deviceProperties.apiVersion)
};
std::cout << "physical device supports version " << supportedVersion[0] << "." << supportedVersion[1] << "." << supportedVersion[2] << std::endl;
}
void checkSwapChainSupport() {
uint32_t extensionCount = 0;
vkEnumerateDeviceExtensionProperties(physicalDevice, nullptr, &extensionCount, nullptr);
if (extensionCount == 0) {
std::cerr << "physical device doesn't support any extensions" << std::endl;
assert(0);
}
std::vector<VkExtensionProperties> deviceExtensions(extensionCount);
vkEnumerateDeviceExtensionProperties(physicalDevice, nullptr, &extensionCount, deviceExtensions.data());
for (const auto& extension : deviceExtensions) {
if (strcmp(extension.extensionName, VK_KHR_SWAPCHAIN_EXTENSION_NAME) == 0) {
std::cout << "physical device supports swap chains" << std::endl;
return;
}
}
std::cerr << "physical device doesn't support swap chains" << std::endl;
assert(0);
}
void findQueueFamilies() {
// Check queue families
uint32_t queueFamilyCount = 0;
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamilyCount, nullptr);
if (queueFamilyCount == 0) {
std::cout << "physical device has no queue families!" << std::endl;
assert(0);
}
// Find queue family with graphics support
// Note: is a transfer queue necessary to copy vertices to the gpu or can a graphics queue handle that?
std::vector<VkQueueFamilyProperties> queueFamilies(queueFamilyCount);
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamilyCount, queueFamilies.data());
std::cout << "physical device has " << queueFamilyCount << " queue families" << std::endl;
bool foundGraphicsQueueFamily = false;
bool foundPresentQueueFamily = false;
for (uint32_t i = 0; i < queueFamilyCount; i++) {
VkBool32 presentSupport = false;
vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, i, windowSurface, &presentSupport);
if (queueFamilies[i].queueCount > 0 && queueFamilies[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
graphicsQueueFamily = i;
foundGraphicsQueueFamily = true;
if (presentSupport) {
presentQueueFamily = i;
foundPresentQueueFamily = true;
break;
}
}
if (!foundPresentQueueFamily && presentSupport) {
presentQueueFamily = i;
foundPresentQueueFamily = true;
}
}
if (foundGraphicsQueueFamily) {
std::cout << "queue family #" << graphicsQueueFamily << " supports graphics" << std::endl;
if (foundPresentQueueFamily) {
std::cout << "queue family #" << presentQueueFamily << " supports presentation" << std::endl;
}
else {
std::cerr << "could not find a valid queue family with present support" << std::endl;
assert(0);
}
}
else {
std::cerr << "could not find a valid queue family with graphics support" << std::endl;
assert(0);
}
}
void createLogicalDevice() {
// Greate one graphics queue and optionally a separate presentation queue
float queuePriority = 1.0f;
VkDeviceQueueCreateInfo queueCreateInfo[2] = {};
queueCreateInfo[0].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
queueCreateInfo[0].queueFamilyIndex = graphicsQueueFamily;
queueCreateInfo[0].queueCount = 1;
queueCreateInfo[0].pQueuePriorities = &queuePriority;
queueCreateInfo[0].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
queueCreateInfo[0].queueFamilyIndex = presentQueueFamily;
queueCreateInfo[0].queueCount = 1;
queueCreateInfo[0].pQueuePriorities = &queuePriority;
// Create logical device from physical device
// Note: there are separate instance and device extensions!
VkDeviceCreateInfo deviceCreateInfo = {};
deviceCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
deviceCreateInfo.pQueueCreateInfos = queueCreateInfo;
if (graphicsQueueFamily == presentQueueFamily) {
deviceCreateInfo.queueCreateInfoCount = 1;
}
else {
deviceCreateInfo.queueCreateInfoCount = 2;
}
const char* deviceExtensions = VK_KHR_SWAPCHAIN_EXTENSION_NAME;
deviceCreateInfo.enabledExtensionCount = 1;
deviceCreateInfo.ppEnabledExtensionNames = &deviceExtensions;
if (vkCreateDevice(physicalDevice, &deviceCreateInfo, nullptr, &device) != VK_SUCCESS) {
std::cerr << "failed to create logical device" << std::endl;
assert(0);
}
std::cout << "created logical device" << std::endl;
// Get graphics and presentation queues (which may be the same)
vkGetDeviceQueue(device, graphicsQueueFamily, 0, &graphicsQueue);
vkGetDeviceQueue(device, presentQueueFamily, 0, &presentQueue);
std::cout << "acquired graphics and presentation queues" << std::endl;
}
void createSemaphores() {
VkSemaphoreCreateInfo createInfo = {};
createInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
if (vkCreateSemaphore(device, &createInfo, nullptr, &imageAvailableSemaphore) != VK_SUCCESS ||
vkCreateSemaphore(device, &createInfo, nullptr, &renderingFinishedSemaphore) != VK_SUCCESS) {
std::cerr << "failed to create semaphores" << std::endl;
assert(0);
}
else {
std::cout << "created semaphores" << std::endl;
}
}
void createSwapChain() {
// Find surface capabilities
VkSurfaceCapabilitiesKHR surfaceCapabilities;
if (vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, windowSurface, &surfaceCapabilities) != VK_SUCCESS) {
std::cerr << "failed to acquire presentation surface capabilities" << std::endl;
assert(0);
}
// Find supported surface formats
uint32_t formatCount;
if (vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, windowSurface, &formatCount, nullptr) != VK_SUCCESS || formatCount == 0) {
std::cerr << "failed to get number of supported surface formats" << std::endl;
assert(0);
}
std::vector<VkSurfaceFormatKHR> surfaceFormats(formatCount);
if (vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, windowSurface, &formatCount, surfaceFormats.data()) != VK_SUCCESS) {
std::cerr << "failed to get supported surface formats" << std::endl;
assert(0);
}
// Find supported present modes
uint32_t presentModeCount;
if (vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, windowSurface, &presentModeCount, nullptr) != VK_SUCCESS || presentModeCount == 0) {
std::cerr << "failed to get number of supported presentation modes" << std::endl;
assert(0);
}
std::vector<VkPresentModeKHR> presentModes(presentModeCount);
if (vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, windowSurface, &presentModeCount, presentModes.data()) != VK_SUCCESS) {
std::cerr << "failed to get supported presentation modes" << std::endl;
assert(0);
}
// Determine number of images for swap chain
uint32_t imageCount = surfaceCapabilities.minImageCount + 1;
if (surfaceCapabilities.maxImageCount != 0 && imageCount > surfaceCapabilities.maxImageCount) {
imageCount = surfaceCapabilities.maxImageCount;
}
std::cout << "using " << imageCount << " images for swap chain" << std::endl;
// Select a surface format
swapchainFormat = chooseSurfaceFormat(surfaceFormats);
// Select swap chain size
swapChainExtent = chooseSwapExtent(surfaceCapabilities);
// Check if swap chain supports being the destination of an image transfer
// Note: AMD driver bug, though it would be nice to implement a workaround that doesn't use transfering
//if (!(surfaceCapabilities.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_DST_BIT)) {
// std::cerr << "swap chain image does not support VK_IMAGE_TRANSFER_DST usage" << std::endl;
//assert(0);
//}
// Determine transformation to use (preferring no transform)
VkSurfaceTransformFlagBitsKHR surfaceTransform;
if (surfaceCapabilities.supportedTransforms & VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR) {
surfaceTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
}
else {
surfaceTransform = surfaceCapabilities.currentTransform;
}
// Choose presentation mode (preferring MAILBOX ~= triple buffering)
VkPresentModeKHR presentMode = choosePresentMode(presentModes);
// Finally, create the swap chain
VkSwapchainCreateInfoKHR createInfo = {};
createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
createInfo.surface = windowSurface;
createInfo.minImageCount = imageCount;
createInfo.imageFormat = swapchainFormat.format;
createInfo.imageColorSpace = swapchainFormat.colorSpace;
createInfo.imageExtent = swapChainExtent;
createInfo.imageArrayLayers = 1;
createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
createInfo.queueFamilyIndexCount = 0;
createInfo.pQueueFamilyIndices = nullptr;
createInfo.preTransform = surfaceTransform;
createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
createInfo.presentMode = presentMode;
createInfo.clipped = VK_TRUE;
createInfo.oldSwapchain = VK_NULL_HANDLE;
if (vkCreateSwapchainKHR(device, &createInfo, nullptr, &swapChain) != VK_SUCCESS) {
std::cerr << "failed to create swap chain" << std::endl;
assert(0);
}
else {
std::cout << "created swap chain" << std::endl;
}
// Store the images used by the swap chain
// Note: these are the images that swap chain image indices refer to
// Note: actual number of images may differ from requested number, since it's a lower bound
uint32_t actualImageCount = 0;
if (vkGetSwapchainImagesKHR(device, swapChain, &actualImageCount, nullptr) != VK_SUCCESS || actualImageCount == 0) {
std::cerr << "failed to acquire number of swap chain images" << std::endl;
assert(0);
}
swapChainImages.resize(actualImageCount);
views.resize(actualImageCount);
if (vkGetSwapchainImagesKHR(device, swapChain, &actualImageCount, swapChainImages.data()) != VK_SUCCESS) {
std::cerr << "failed to acquire swap chain images" << std::endl;
assert(0);
}
std::cout << "acquired swap chain images" << std::endl;
}
VkSurfaceFormatKHR chooseSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& availableFormats) {
// We can either choose any format
if (availableFormats.size() == 1 && availableFormats[0].format == VK_FORMAT_UNDEFINED) {
return { VK_FORMAT_R8G8B8A8_UNORM, VK_COLORSPACE_SRGB_NONLINEAR_KHR };
}
// Or go with the standard format - if available
for (const auto& availableSurfaceFormat : availableFormats) {
if (availableSurfaceFormat.format == VK_FORMAT_R8G8B8A8_UNORM) {
return availableSurfaceFormat;
}
}
// Or fall back to the first available one
return availableFormats[0];
}
VkExtent2D chooseSwapExtent(const VkSurfaceCapabilitiesKHR& surfaceCapabilities) {
if (surfaceCapabilities.currentExtent.width == -1) {
VkExtent2D swapChainExtent = {};
#define min(a, b) (a < b ? a : b)
#define max(a, b) (a > b ? a : b)
swapChainExtent.width = min(max(640, surfaceCapabilities.minImageExtent.width), surfaceCapabilities.maxImageExtent.width);
swapChainExtent.height = min(max(480, surfaceCapabilities.minImageExtent.height), surfaceCapabilities.maxImageExtent.height);
return swapChainExtent;
}
else {
return surfaceCapabilities.currentExtent;
}
}
VkPresentModeKHR choosePresentMode(const std::vector<VkPresentModeKHR> presentModes) {
for (const auto& presentMode : presentModes) {
if (presentMode == VK_PRESENT_MODE_MAILBOX_KHR) {
return presentMode;
}
}
// If mailbox is unavailable, fall back to FIFO (guaranteed to be available)
return VK_PRESENT_MODE_FIFO_KHR;
}
void createCommandQueues() {
// Create presentation command pool
// Note: only command buffers for a single queue family can be created from this pool
VkCommandPoolCreateInfo poolCreateInfo = {};
poolCreateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
poolCreateInfo.queueFamilyIndex = presentQueueFamily;
if (vkCreateCommandPool(device, &poolCreateInfo, nullptr, &commandPool) != VK_SUCCESS) {
std::cerr << "failed to create command queue for presentation queue family" << std::endl;
assert(0);
}
else {
std::cout << "created command pool for presentation queue family" << std::endl;
}
// Get number of swap chain images and create vector to hold command queue for each one
presentCommandBuffers.resize(swapChainImages.size());
// Allocate presentation command buffers
// Note: secondary command buffers are only for nesting in primary command buffers
VkCommandBufferAllocateInfo allocInfo = {};
allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
allocInfo.commandPool = commandPool;
allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
allocInfo.commandBufferCount = (uint32_t)swapChainImages.size();
if (vkAllocateCommandBuffers(device, &allocInfo, presentCommandBuffers.data()) != VK_SUCCESS) {
std::cerr << "failed to allocate presentation command buffers" << std::endl;
assert(0);
}
else {
std::cout << "allocated presentation command buffers" << std::endl;
}
}
void recordCommandBuffers()
{
// Prepare data for recording command buffers
VkCommandBufferBeginInfo beginInfo = {};
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
beginInfo.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT;
// Note: contains value for each subresource range
VkClearColorValue clearColor = {
{ 0.4f, 0.6f, 0.9f, 1.0f } // R, G, B, A
};
VkClearValue clearValue = {};
clearValue.color = clearColor;
VkImageSubresourceRange subResourceRange = {};
subResourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
subResourceRange.baseMipLevel = 0;
subResourceRange.levelCount = 1;
subResourceRange.baseArrayLayer = 0;
subResourceRange.layerCount = 1;
VkRenderPassBeginInfo renderPassInfo = {};
renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
renderPassInfo.renderPass = renderPass;
renderPassInfo.renderArea.offset.x = 0;
renderPassInfo.renderArea.offset.y = 0;
renderPassInfo.renderArea.extent.width = swapChainExtent.width;
renderPassInfo.renderArea.extent.height = swapChainExtent.height;
renderPassInfo.clearValueCount = 1;
renderPassInfo.pClearValues = &clearValue;
VkViewport viewport = { 0 };
viewport.height = (float)swapChainExtent.width;
viewport.width = (float)swapChainExtent.height;
viewport.minDepth = (float)0.0f;
viewport.maxDepth = (float)1.0f;
VkRect2D scissor = { 0 };
scissor.extent.width = swapChainExtent.width;
scissor.extent.height = swapChainExtent.height;
scissor.offset.x = 0;
scissor.offset.y = 0;
// Record the command buffer for every swap chain image
for (uint32_t i = 0; i < swapChainImages.size(); i++) {
// Record command buffer
vkBeginCommandBuffer(presentCommandBuffers[i], &beginInfo);
renderPassInfo.framebuffer = fbs[i];
vkCmdBeginRenderPass(presentCommandBuffers[i], &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE);
vkCmdBindPipeline(presentCommandBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
//vkCmdSetViewport(presentCommandBuffers[i], 0, 1, &viewport);
//vkCmdSetScissor(presentCommandBuffers[i], 0, 1, &scissor);
VkDeviceSize offsets[2] = {0, sizeof(float)*2*3};
VkBuffer buffers[2] = {vertexBuffer, vertexBuffer};
vkCmdBindVertexBuffers(presentCommandBuffers[i], 0, 2, buffers, offsets);
float Wcoeff = 1.0f; //1.0f / Wc = 2.0 - Wcoeff
float viewportScaleX = (float)(swapChainExtent.width) * 0.5f * 16.0f;
float viewportScaleY = 1.0f * (float)(swapChainExtent.height) * 0.5f * 16.0f;
float Zs = 1.0f;
uint32_t pushConstants[4];
pushConstants[0] = *(uint32_t*)&Wcoeff;
pushConstants[1] = *(uint32_t*)&viewportScaleX;
pushConstants[2] = *(uint32_t*)&viewportScaleY;
pushConstants[3] = *(uint32_t*)&Zs;
vkCmdPushConstants(presentCommandBuffers[i], pipelineLayout, VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(pushConstants), &pushConstants);
vkCmdDraw(presentCommandBuffers[i], 3, 1, 0, 0);
vkCmdEndRenderPass(presentCommandBuffers[i]);
if (vkEndCommandBuffer(presentCommandBuffers[i]) != VK_SUCCESS) {
std::cerr << "failed to record command buffer" << std::endl;
assert(0);
}
else {
std::cout << "recorded command buffer for image " << i << std::endl;
}
}
}
void draw() {
// Acquire image
uint32_t imageIndex;
VkResult res = vkAcquireNextImageKHR(device, swapChain, UINT64_MAX, imageAvailableSemaphore, VK_NULL_HANDLE, &imageIndex);
if (res != VK_SUCCESS && res != VK_SUBOPTIMAL_KHR) {
std::cerr << "failed to acquire image" << std::endl;
assert(0);
}
std::cout << "acquired image" << std::endl;
// Wait for image to be available and draw
VkSubmitInfo submitInfo = {};
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &imageAvailableSemaphore;
submitInfo.signalSemaphoreCount = 1;
submitInfo.pSignalSemaphores = &renderingFinishedSemaphore;
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &presentCommandBuffers[imageIndex];
if (vkQueueSubmit(presentQueue, 1, &submitInfo, VK_NULL_HANDLE) != VK_SUCCESS) {
std::cerr << "failed to submit draw command buffer" << std::endl;
assert(0);
}
std::cout << "submitted draw command buffer" << std::endl;
// Present drawn image
// Note: semaphore here is not strictly necessary, because commands are processed in submission order within a single queue
VkPresentInfoKHR presentInfo = {};
presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
presentInfo.waitSemaphoreCount = 1;
presentInfo.pWaitSemaphores = &renderingFinishedSemaphore;
presentInfo.swapchainCount = 1;
presentInfo.pSwapchains = &swapChain;
presentInfo.pImageIndices = &imageIndex;
res = vkQueuePresentKHR(presentQueue, &presentInfo);
if (res != VK_SUCCESS) {
std::cerr << "failed to submit present command buffer" << std::endl;
assert(0);
}
std::cout << "submitted presentation command buffer" << std::endl;
}
void CreateRenderPass()
{
VkAttachmentReference attachRef = {};
attachRef.attachment = 0;
attachRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
VkSubpassDescription subpassDesc = {};
subpassDesc.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
subpassDesc.colorAttachmentCount = 1;
subpassDesc.pColorAttachments = &attachRef;
VkAttachmentDescription attachDesc = {};
attachDesc.format = swapchainFormat.format; //
attachDesc.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
attachDesc.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
attachDesc.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
attachDesc.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
attachDesc.initialLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
attachDesc.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
attachDesc.samples = VK_SAMPLE_COUNT_1_BIT;
VkRenderPassCreateInfo renderPassCreateInfo = {};
renderPassCreateInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
renderPassCreateInfo.attachmentCount = 1;
renderPassCreateInfo.pAttachments = &attachDesc;
renderPassCreateInfo.subpassCount = 1;
renderPassCreateInfo.pSubpasses = &subpassDesc;
VkResult res = vkCreateRenderPass(device, &renderPassCreateInfo, NULL, &renderPass);
printf("Created a render pass\n");
}
void CreateFramebuffer()
{
fbs.resize(swapChainImages.size());
VkResult res;
for (uint32_t i = 0; i < swapChainImages.size(); i++) {
VkImageViewCreateInfo ViewCreateInfo = {};
ViewCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
ViewCreateInfo.image = swapChainImages[i];
ViewCreateInfo.format = swapchainFormat.format; //
ViewCreateInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
ViewCreateInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
ViewCreateInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
ViewCreateInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
ViewCreateInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
ViewCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
ViewCreateInfo.subresourceRange.baseMipLevel = 0;
ViewCreateInfo.subresourceRange.levelCount = 1;
ViewCreateInfo.subresourceRange.baseArrayLayer = 0;
ViewCreateInfo.subresourceRange.layerCount = 1;
res = vkCreateImageView(device, &ViewCreateInfo, NULL, &views[i]);
VkFramebufferCreateInfo fbCreateInfo = {};
fbCreateInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
fbCreateInfo.renderPass = renderPass;
fbCreateInfo.attachmentCount = 1;
fbCreateInfo.pAttachments = &views[i];
fbCreateInfo.width = swapChainExtent.width;
fbCreateInfo.height = swapChainExtent.height;
fbCreateInfo.layers = 1;
res = vkCreateFramebuffer(device, &fbCreateInfo, NULL, &fbs[i]);
}
printf("Frame buffers created\n");
}
void CreateShaders()
{
/**
//FS prog reading tex with varyings
0x100049e0203e303e nop nop, r0, r0 ; fmul r0, vary, ra15 //mul by w
0x100248e1213e317e fadd r3, r0, r5 ; fmul r1, vary, ra15 //add interpolation coefficient C, mul by w
0x600208a7019e7340 sig_thread_switch fadd r2, r1, r5 ; nop nop, r0, r0
0x10021e67159e7480 mov tmu0_t, r2 ; nop nop, r0, r0
0x10021e27159e76c0 mov tmu0_s, r3 ; nop nop, r0, r0
0xa00009e7009e7000 load_tmu0 nop nop, r0, r0 ; nop nop, r0, r0
0x190208e7049e7900 fmax r3, r4.8a, r4.8a ; nop nop, r0, r0
0x1b424823849e791b fmax r0, r4.8b, r4.8b ; mov r3.8a, r3
0x1d524863849e7900 fmax r1, r4.8c, r4.8c ; mov r3.8b, r0
0x1f6248a3849e7909 fmax r2, r4.8d, r4.8d ; mov r3.8c, r1
0x117049e3809e7012 nop nop, r0, r0 ; mov r3.8d, r2
0x10020ba7159e76c0 mov tlb_color_all, r3 ; nop nop, r0, r0
0x300009e7009e7000 sig_end nop nop, r0, r0 ; nop nop, r0, r0
0x100009e7009e7000 nop nop, r0, r0 ; nop nop, r0, r0
0x500009e7009e7000 sig_unlock_score nop nop, r0, r0 ; nop nop, r0, r0
/**/
char vs_asm_code[] =
///0x40000000 = 2.0
///uni = 1.0
///rb0 = 2 - 1 = 1
"sig_small_imm ; rx0 = fsub.ws.always(b, a, uni, 0x40000000) ; nop = nop(r0, r0) ;\n"
///set up VPM read for subsequent reads
///0x00201a00: 0000 0000 0010 0000 0001 1010 0000 0000
///addr: 0
///size: 32bit
///packed
///horizontal
///stride=1
///vectors to read = 5
"sig_load_imm ; vr_setup = load32.always(0x00301a00) ; nop = load32.always() ;\n"
///uni = viewportXScale
///r0 = vpm * uni
"sig_none ; nop = nop(r0, r0, vpm_read, uni) ; r0 = fmul.always(a, b) ;\n"
///r1 = r0 * rb0 (1)
"sig_none ; nop = nop(r0, r0, nop, rb0) ; r1 = fmul.always(r0, b) ;\n"
///uni = viewportYScale
///ra0.16a = int(r1), r2 = vpm * uni
"sig_none ; rx0.16a = ftoi.always(r1, r1, vpm_read, uni) ; r2 = fmul.always(a, b) ;\n"
///r3 = r2 * rb0
///r0 = vpm
"sig_none ; rx1 = or.always(a, a, vpm_read, rb0) ; r3 = fmul.always(r2, b) ;\n"
///ra0.16b = int(r3)
///r1 = vpm
"sig_none ; rx0.16b = ftoi.always(r3, r3) ; nop = nop(r0, r0) ;\n"
///set up VPM write for subsequent writes
///0x00001a00: 0000 0000 0000 0000 0001 1010 0000 0000
///addr: 0
///size: 32bit
///horizontal
///stride = 1
"sig_load_imm ; vw_setup = load32.always.ws(0x00001a00) ; nop = load32.always() ;\n"
///shaded vertex format for PSE
/// Ys and Xs
///vpm = ra0
"sig_none ; vpm = or.always(a, a, ra0, nop) ; nop = nop(r0, r0);\n"
/// Zs
///uni = 0.5
///vpm = uni
"sig_none ; vpm = or.always(a, a, uni, nop) ; nop = nop(r0, r0);\n"
/// 1.0 / Wc
///vpm = rb0 (1)
"sig_none ; vpm = or.always(b, b, nop, rb0) ; nop = nop(r0, r0);\n"
///vpm = r0
"sig_none ; vpm.nop = fmax.always.8a(a, a, ra1) ; nop = nop(r0, r0) ; "
"sig_none ; vpm.nop = fmax.always.8b(a, a, ra1) ; nop = nop(r0, r0) ; "
"sig_none ; vpm.nop = fmax.always.8c(a, a, ra1) ; nop = nop(r0, r0) ; "
"sig_none ; vpm.nop = fmax.always.8d(a, a, ra1) ; nop = nop(r0, r0) ; "
///END
"sig_end ; nop = nop(r0, r0) ; nop = nop(r0, r0) ;\n"
"sig_none ; nop = nop(r0, r0) ; nop = nop(r0, r0) ;\n"
"sig_none ; nop = nop(r0, r0) ; nop = nop(r0, r0) ;\n"
"\0";
char cs_asm_code[] =
///uni = 1.0
///r3 = 2.0 - uni
"sig_small_imm ; r3 = fsub.always(b, a, uni, 0x40000000) ; nop = nop(r0, r0);\n"
"sig_load_imm ; vr_setup = load32.always(0x00201a00) ; nop = load32.always() ;\n"
///r2 = vpm
"sig_none ; r2 = or.always(a, a, vpm_read, nop) ; nop = nop(r0, r0);\n"
"sig_load_imm ; vw_setup = load32.always.ws(0x00001a00) ; nop = load32.always() ;\n"
///shaded coordinates format for PTB
/// write Xc
///r1 = vpm, vpm = r2
"sig_none ; r1 = or.always(a, a, vpm_read, nop) ; vpm = v8min.always(r2, r2);\n"
/// write Yc
///uni = viewportXscale
///vpm = r1, r2 = r2 * uni
"sig_none ; vpm = or.always(r1, r1, uni, nop) ; r2 = fmul.always(r2, a);\n"
///uni = viewportYscale
///r1 = r1 * uni
"sig_none ; nop = nop(r0, r0, uni, nop) ; r1 = fmul.always(r1, a);\n"
///r0 = r2 * r3
"sig_none ; nop = nop(r0, r0) ; r0 = fmul.always(r2, r3);\n"
///ra0.16a = r0, r1 = r1 * r3
"sig_none ; rx0.16a = ftoi.always(r0, r0) ; r1 = fmul.always(r1, r3) ;\n"
///ra0.16b = r1
"sig_none ; rx0.16b = ftoi.always(r1, r1) ; nop = nop(r0, r0) ;\n"
///write Zc
///vpm = 0
"sig_small_imm ; vpm = or.always(b, b, nop, 0) ; nop = nop(r0, r0) ;\n"
///write Wc
///vpm = 1.0
"sig_small_imm ; vpm = or.always(b, b, nop, 0x3f800000) ; nop = nop(r0, r0) ;\n"
///write Ys and Xs
///vpm = ra0
"sig_none ; vpm = or.always(a, a, ra0, nop) ; nop = nop(r0, r0) ;\n"
///write Zs
///uni = 0.5
///vpm = uni
"sig_none ; vpm = or.always(a, a, uni, nop) ; nop = nop(r0, r0) ;\n"
///write 1/Wc
///vpm = r3
"sig_none ; vpm = or.always(r3, r3) ; nop = nop(r0, r0) ;\n"
///END
"sig_end ; nop = nop(r0, r0) ; nop = nop(r0, r0) ;\n"
"sig_none ; nop = nop(r0, r0) ; nop = nop(r0, r0) ;\n"
"sig_none ; nop = nop(r0, r0) ; nop = nop(r0, r0) ;\n"
"\0";
//clever: use small immedate -1 interpreted as 0xffffffff (white) to set color to white
//"sig_small_imm ; tlb_color_all = or.always(b, b, nop, -1) ; nop = nop(r0, r0) ;"
//8bit access
//abcd
//BGRA
/**
//rainbow colors
char fs_asm_code[] =
"sig_none ; r1 = itof.always(a, a, x_pix, uni) ; r3 = v8min.always(b, b) ;" //can't use mul pipeline for conversion :(
"sig_load_imm ; r2 = load32.always(0x3a088888) ; nop = load32() ;" //1/1920
"sig_none ; nop = nop(r0, r0) ; r2 = fmul.always(r2, r3);\n"
"sig_none ; r1 = itof.pm.always(b, b, x_pix, y_pix) ; r0.8c = fmul.always(r1, r2) ;"
"sig_load_imm ; r2 = load32.always(0x3a72b9d6) ; nop = load32() ;" //1/1080
"sig_none ; nop = nop(r0, r0) ; r2 = fmul.always(r2, r3);\n"
"sig_none ; nop = nop.pm(r0, r0) ; r0.8b = fmul.always(r1, r2) ;"
"sig_small_imm ; nop = nop.pm(r0, r0, nop, 0) ; r0.8a = v8min.always(b, b) ;"
"sig_small_imm ; nop = nop.pm(r0, r0, nop, 0x3f800000) ; r0.8d = v8min.always(b, b) ;"
"sig_none ; tlb_color_all = or.always(r0, r0) ; nop = nop(r0, r0) ;"
"sig_end ; nop = nop(r0, r0) ; nop = nop(r0, r0) ;"
"sig_none ; nop = nop(r0, r0) ; nop = nop(r0, r0) ;"
"sig_unlock_score ; nop = nop(r0, r0) ; nop = nop(r0, r0) ;"
"\0";
/**/
/**
//display a color
char fs_asm_code[] =
"sig_none ; nop = nop(r0, r0) ; nop = nop(r0, r0) ;"
"sig_load_imm ; r0 = load32.always(0xffa14ccc) ; nop = load32() ;"
"sig_none ; tlb_color_all = or.always(r0, r0) ; nop = nop(r0, r0) ;"
"sig_end ; nop = nop(r0, r0) ; nop = nop(r0, r0) ;"
"sig_none ; nop = nop(r0, r0) ; nop = nop(r0, r0) ;"
"sig_unlock_score ; nop = nop(r0, r0) ; nop = nop(r0, r0) ;"
"\0";
/**/
/**/
//Varyings are interpolated using (A * (x - x0) + B * (y - y0)) * W + C
//Hardware calculates (A * (x - x0) + B * (y - y0)) for us for each varying component
//but we still need to mul by W and add C
//C is loaded into R5 when we read a varying (to be used in next instruction)
//display a varying
char fs_asm_code[] =
///r0 = varyingX * W
"sig_none ; nop = nop(r0, r0, pay_zw, vary) ; r0 = fmul.always(a, b) ;"
///r2 = r0 + r5 (C)
"sig_none ; rx0 = fadd.always(r0, r5, pay_zw, vary) ; r1 = fmul.always(a, b) ;"
"sig_none ; rx1 = fadd.always(r1, r5, pay_zw, vary) ; r2 = fmul.always(a, b) ;"
"sig_none ; rx2 = fadd.always(r2, r5, pay_zw, vary) ; r3 = fmul.always(a, b) ;"
"sig_none ; rx3 = fadd.always(r3, r5) ; nop = nop(r0, r0) ;"
"sig_none ; nop = nop.pm(r0, r0, ra0, nop) ; r0.8a = v8min.always(a, a) ;"
"sig_none ; nop = nop.pm(r0, r0, ra1, nop) ; r0.8b = v8min.always(a, a) ;"
"sig_none ; nop = nop.pm(r0, r0, ra2, nop) ; r0.8c = v8min.always(a, a) ;"
"sig_none ; nop = nop.pm(r0, r0, ra3, nop) ; r0.8d = v8min.always(a, a) ;"
"sig_none ; tlb_color_all = or.always(r0, r0) ; nop = nop(r0, r0) ;"
"sig_end ; nop = nop(r0, r0) ; nop = nop(r0, r0) ;"
"sig_none ; nop = nop(r0, r0) ; nop = nop(r0, r0) ;"
"sig_unlock_score ; nop = nop(r0, r0) ; nop = nop(r0, r0) ;"
"\0";
/**/
char* asm_strings[] =
{
(char*)cs_asm_code, (char*)vs_asm_code, (char*)fs_asm_code, 0
};
VkRpiAssemblyMappingEXT vertexMappings[] = {
//vertex shader uniforms
{
VK_RPI_ASSEMBLY_MAPPING_TYPE_PUSH_CONSTANT,
VK_DESCRIPTOR_TYPE_MAX_ENUM, //descriptor type
0, //descriptor set #
0, //descriptor binding #
0, //descriptor array element #
0, //resource offset
},
{
VK_RPI_ASSEMBLY_MAPPING_TYPE_PUSH_CONSTANT,
VK_DESCRIPTOR_TYPE_MAX_ENUM, //descriptor type
0, //descriptor set #
0, //descriptor binding #
0, //descriptor array element #
4, //resource offset
},
{
VK_RPI_ASSEMBLY_MAPPING_TYPE_PUSH_CONSTANT,
VK_DESCRIPTOR_TYPE_MAX_ENUM, //descriptor type
0, //descriptor set #
0, //descriptor binding #
0, //descriptor array element #
8, //resource offset
},
{
VK_RPI_ASSEMBLY_MAPPING_TYPE_PUSH_CONSTANT,
VK_DESCRIPTOR_TYPE_MAX_ENUM, //descriptor type
0, //descriptor set #
0, //descriptor binding #
0, //descriptor array element #
12, //resource offset
}
};
uint32_t spirv[6];
uint64_t* asm_ptrs[4] = {};
uint32_t asm_sizes[4] = {};
VkRpiAssemblyMappingEXT* asm_mappings[4] = {};
uint32_t asm_mappings_sizes[4] = {};
VkRpiShaderModuleAssemblyCreateInfoEXT shaderModuleCreateInfo = {};
shaderModuleCreateInfo.instructions = asm_ptrs;
shaderModuleCreateInfo.numInstructions = asm_sizes;
shaderModuleCreateInfo.mappings = asm_mappings;
shaderModuleCreateInfo.numMappings = asm_mappings_sizes;
asm_mappings[VK_RPI_ASSEMBLY_TYPE_VERTEX] = vertexMappings;
asm_mappings_sizes[VK_RPI_ASSEMBLY_TYPE_VERTEX] = sizeof(vertexMappings) / sizeof(VkRpiAssemblyMappingEXT);
{ //assemble cs code
asm_sizes[0] = get_num_instructions(cs_asm_code);
uint32_t size = sizeof(uint64_t)*asm_sizes[0];
asm_ptrs[0] = (uint64_t*)malloc(size);
assemble_qpu_asm(cs_asm_code, asm_ptrs[0]);
}
{ //assemble vs code
asm_sizes[1] = get_num_instructions(vs_asm_code);
uint32_t size = sizeof(uint64_t)*asm_sizes[1];
asm_ptrs[1] = (uint64_t*)malloc(size);
assemble_qpu_asm(vs_asm_code, asm_ptrs[1]);
}
{ //assemble fs code
asm_sizes[2] = get_num_instructions(fs_asm_code);
uint32_t size = sizeof(uint64_t)*asm_sizes[2];
asm_ptrs[2] = (uint64_t*)malloc(size);
assemble_qpu_asm(fs_asm_code, asm_ptrs[2]);
}
asm_sizes[3] = 0;
asm_ptrs[3] = 0;
spirv[0] = 0x07230203;
spirv[1] = 0x00010000;
spirv[2] = 0x14E45250;
spirv[3] = 1;
spirv[4] = (uint32_t)&shaderModuleCreateInfo;
//words start here
spirv[5] = 1 << 16;
VkShaderModuleCreateInfo smci = {};
smci.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
smci.codeSize = sizeof(uint32_t)*6;
smci.pCode = spirv;
vkCreateShaderModule(device, &smci, 0, &shaderModule);
for(uint32_t c = 0; c < 4; ++c)
{
free(asm_ptrs[c]);
}
}
#define VERTEX_BUFFER_BIND_ID 0
void CreatePipeline()
{
VkPushConstantRange pushConstantRanges[1];
pushConstantRanges[0].offset = 0;
pushConstantRanges[0].size = 4 * 4; //4 * 32bits
pushConstantRanges[0].stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
VkPipelineLayoutCreateInfo pipelineLayoutCI = {};
pipelineLayoutCI.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
pipelineLayoutCI.setLayoutCount = 0;
pipelineLayoutCI.pushConstantRangeCount = 1;
pipelineLayoutCI.pPushConstantRanges = &pushConstantRanges[0];
vkCreatePipelineLayout(device, &pipelineLayoutCI, 0, &pipelineLayout);
VkPipelineShaderStageCreateInfo shaderStageCreateInfo[2] = {};
shaderStageCreateInfo[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
shaderStageCreateInfo[0].stage = VK_SHADER_STAGE_VERTEX_BIT;
shaderStageCreateInfo[0].module = shaderModule;
shaderStageCreateInfo[0].pName = "main";
shaderStageCreateInfo[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
shaderStageCreateInfo[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT;
shaderStageCreateInfo[1].module = shaderModule;
shaderStageCreateInfo[1].pName = "main";
VkVertexInputBindingDescription vertexInputBindingDescription[2] =
{
{
0,
sizeof(float) * 2,
VK_VERTEX_INPUT_RATE_VERTEX
},
{
1,
sizeof(uint8_t) * 4,
VK_VERTEX_INPUT_RATE_VERTEX
},
};
VkVertexInputAttributeDescription vertexInputAttributeDescriptions[2] =
{
{
0,
0,
VK_FORMAT_R32G32_SFLOAT,
0
},
{
1,
1,
VK_FORMAT_R8G8B8A8_UNORM,
0
}
};
VkPipelineVertexInputStateCreateInfo vertexInputInfo = {};
vertexInputInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
vertexInputInfo.vertexAttributeDescriptionCount = 2;
vertexInputInfo.pVertexAttributeDescriptions = vertexInputAttributeDescriptions;
vertexInputInfo.vertexBindingDescriptionCount = 2;
vertexInputInfo.pVertexBindingDescriptions = vertexInputBindingDescription;
VkPipelineInputAssemblyStateCreateInfo pipelineIACreateInfo = {};
pipelineIACreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
pipelineIACreateInfo.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
VkViewport vp = {};
vp.x = 0.0f;
vp.y = 0.0f;
vp.width = (float)swapChainExtent.width;
vp.height = (float)swapChainExtent.height;
vp.minDepth = 0.0f;
vp.maxDepth = 1.0f;
VkPipelineViewportStateCreateInfo vpCreateInfo = {};
vpCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
vpCreateInfo.viewportCount = 1;
vpCreateInfo.pViewports = &vp;
VkPipelineRasterizationStateCreateInfo rastCreateInfo = {};
rastCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
rastCreateInfo.polygonMode = VK_POLYGON_MODE_FILL;
rastCreateInfo.cullMode = VK_CULL_MODE_NONE;
rastCreateInfo.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
rastCreateInfo.lineWidth = 1.0f;
VkPipelineMultisampleStateCreateInfo pipelineMSCreateInfo = {};
pipelineMSCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
VkPipelineColorBlendAttachmentState blendAttachState = {};
blendAttachState.colorWriteMask = 0xf;
blendAttachState.blendEnable = false;
VkPipelineColorBlendStateCreateInfo blendCreateInfo = {};
blendCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
blendCreateInfo.attachmentCount = 1;
blendCreateInfo.pAttachments = &blendAttachState;
VkPipelineDepthStencilStateCreateInfo depthStencilState = {};
depthStencilState.depthTestEnable = false;
depthStencilState.stencilTestEnable = false;
VkGraphicsPipelineCreateInfo pipelineInfo = {};
pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
pipelineInfo.stageCount = 2;
pipelineInfo.pStages = &shaderStageCreateInfo[0];
pipelineInfo.pVertexInputState = &vertexInputInfo;
pipelineInfo.pInputAssemblyState = &pipelineIACreateInfo;
pipelineInfo.pViewportState = &vpCreateInfo;
pipelineInfo.pRasterizationState = &rastCreateInfo;
pipelineInfo.pMultisampleState = &pipelineMSCreateInfo;
pipelineInfo.pColorBlendState = &blendCreateInfo;
pipelineInfo.renderPass = renderPass;
pipelineInfo.basePipelineIndex = -1;
pipelineInfo.pDepthStencilState = &depthStencilState;
pipelineInfo.layout = pipelineLayout;
VkResult res = vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &pipelineInfo, NULL, &pipeline);
printf("Graphics pipeline created\n");
}
uint32_t getMemoryTypeIndex(VkPhysicalDeviceMemoryProperties deviceMemoryProperties, uint32_t typeBits, VkMemoryPropertyFlags properties)
{
// Iterate over all memory types available for the device used in this example
for (uint32_t i = 0; i < deviceMemoryProperties.memoryTypeCount; i++)
{
if ((typeBits & 1) == 1)
{
if ((deviceMemoryProperties.memoryTypes[i].propertyFlags & properties) == properties)
{
return i;
}
}
typeBits >>= 1;
}
assert(0);
}
void CreateVertexBuffer()
{
unsigned vboSize = sizeof(float) * (2 * 3 + 3); //3 x vec2 + 3
VkMemoryRequirements mr;
{ //create staging buffer
VkBufferCreateInfo ci = {};
ci.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
ci.size = vboSize;
ci.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
VkResult res = vkCreateBuffer(device, &ci, 0, &vertexBuffer);
vkGetBufferMemoryRequirements(device, vertexBuffer, &mr);
VkMemoryAllocateInfo mai = {};
mai.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
mai.allocationSize = mr.size;
mai.memoryTypeIndex = getMemoryTypeIndex(pdmp, mr.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
res = vkAllocateMemory(device, &mai, 0, &vertexBufferMemory);
uint32_t vertices[9];
((float*)vertices)[0] = -1;
((float*)vertices)[1] = 1;
((float*)vertices)[2] = 1;
((float*)vertices)[3] = 1;
((float*)vertices)[4] = 0;
((float*)vertices)[5] = -1;
((uint8_t*)vertices)[6*4 + 0] = 255;
((uint8_t*)vertices)[6*4 + 1] = 0;
((uint8_t*)vertices)[6*4 + 2] = 0;
((uint8_t*)vertices)[6*4 + 3] = 0;
((uint8_t*)vertices)[7*4 + 0] = 0;
((uint8_t*)vertices)[7*4 + 1] = 255;
((uint8_t*)vertices)[7*4 + 2] = 0;
((uint8_t*)vertices)[7*4 + 3] = 0;
((uint8_t*)vertices)[8*4 + 0] = 0;
((uint8_t*)vertices)[8*4 + 1] = 0;
((uint8_t*)vertices)[8*4 + 2] = 255;
((uint8_t*)vertices)[8*4 + 3] = 0;
void* data;
res = vkMapMemory(device, vertexBufferMemory, 0, mr.size, 0, &data);
memcpy(data, vertices, vboSize);
vkUnmapMemory(device, vertexBufferMemory);
res = vkBindBufferMemory(device, vertexBuffer, vertexBufferMemory, 0);
}
printf("Vertex buffer created\n");
}
int main() {
// Note: dynamically loading loader may be a better idea to fail gracefully when Vulkan is not supported
// Create window for Vulkan
//glfwInit();
//glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
//glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE);
//window = glfwCreateWindow(WINDOW_WIDTH, WINDOW_HEIGHT, "The 630 line cornflower blue window", nullptr, nullptr);
// Use Vulkan
setupVulkan();
mainLoop();
cleanup();
return 0;
}
| 18,830 |
1,305 | <filename>src/org/example/source/com/sun/naming/internal/VersionHelper.java
/*
* Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved.
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
package com.sun.naming.internal;
import java.io.InputStream;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.StringTokenizer;
import java.util.Vector;
import javax.naming.NamingEnumeration;
/**
* VersionHelper was used by JNDI to accommodate differences between
* JDK 1.1.x and the Java 2 platform. As this is no longer necessary
* since JNDI's inclusion in the platform, this class currently
* serves as a set of utilities for performing system-level things,
* such as class-loading and reading system properties.
*
* @author <NAME>
* @author <NAME>
*/
public abstract class VersionHelper {
private static VersionHelper helper = null;
final static String[] PROPS = new String[] {
javax.naming.Context.INITIAL_CONTEXT_FACTORY,
javax.naming.Context.OBJECT_FACTORIES,
javax.naming.Context.URL_PKG_PREFIXES,
javax.naming.Context.STATE_FACTORIES,
javax.naming.Context.PROVIDER_URL,
javax.naming.Context.DNS_URL,
// The following shouldn't create a runtime dependence on ldap package.
javax.naming.ldap.LdapContext.CONTROL_FACTORIES
};
public final static int INITIAL_CONTEXT_FACTORY = 0;
public final static int OBJECT_FACTORIES = 1;
public final static int URL_PKG_PREFIXES = 2;
public final static int STATE_FACTORIES = 3;
public final static int PROVIDER_URL = 4;
public final static int DNS_URL = 5;
public final static int CONTROL_FACTORIES = 6;
VersionHelper() {} // Disallow anyone from creating one of these.
static {
helper = new VersionHelper12();
}
public static VersionHelper getVersionHelper() {
return helper;
}
public abstract Class<?> loadClass(String className)
throws ClassNotFoundException;
abstract Class<?> loadClass(String className, ClassLoader cl)
throws ClassNotFoundException;
public abstract Class<?> loadClass(String className, String codebase)
throws ClassNotFoundException, MalformedURLException;
/*
* Returns a JNDI property from the system properties. Returns
* null if the property is not set, or if there is no permission
* to read it.
*/
abstract String getJndiProperty(int i);
/*
* Reads each property in PROPS from the system properties, and
* returns their values -- in order -- in an array. For each
* unset property, the corresponding array element is set to null.
* Returns null if there is no permission to call System.getProperties().
*/
abstract String[] getJndiProperties();
/*
* Returns the resource of a given name associated with a particular
* class (never null), or null if none can be found.
*/
abstract InputStream getResourceAsStream(Class<?> c, String name);
/*
* Returns an input stream for a file in <java.home>/lib,
* or null if it cannot be located or opened.
*
* @param filename The file name, sans directory.
*/
abstract InputStream getJavaHomeLibStream(String filename);
/*
* Returns an enumeration (never null) of InputStreams of the
* resources of a given name associated with a particular class
* loader. Null represents the bootstrap class loader in some
* Java implementations.
*/
abstract NamingEnumeration<InputStream> getResources(
ClassLoader cl, String name)
throws IOException;
/*
* Returns the context class loader associated with the current thread.
* Null indicates the bootstrap class loader in some Java implementations.
*
* @throws SecurityException if the class loader is not accessible.
*/
abstract ClassLoader getContextClassLoader();
static protected URL[] getUrlArray(String codebase)
throws MalformedURLException {
// Parse codebase into separate URLs
StringTokenizer parser = new StringTokenizer(codebase);
Vector<String> vec = new Vector<>(10);
while (parser.hasMoreTokens()) {
vec.addElement(parser.nextToken());
}
String[] url = new String[vec.size()];
for (int i = 0; i < url.length; i++) {
url[i] = vec.elementAt(i);
}
URL[] urlArray = new URL[url.length];
for (int i = 0; i < urlArray.length; i++) {
urlArray[i] = new URL(url[i]);
}
return urlArray;
}
}
| 1,689 |
454 | """Pipeline base class for time series regression problems."""
from evalml.pipelines.time_series_pipeline_base import TimeSeriesPipelineBase
from evalml.problem_types import ProblemTypes
class TimeSeriesRegressionPipeline(TimeSeriesPipelineBase):
"""Pipeline base class for time series regression problems.
Args:
component_graph (ComponentGraph, list, dict): ComponentGraph instance, list of components in order, or dictionary of components.
Accepts strings or ComponentBase subclasses in the list.
Note that when duplicate components are specified in a list, the duplicate component names will be modified with the
component's index in the list. For example, the component graph
[Imputer, One Hot Encoder, Imputer, Logistic Regression Classifier] will have names
["Imputer", "One Hot Encoder", "Imputer_2", "Logistic Regression Classifier"]
parameters (dict): Dictionary with component names as keys and dictionary of that component's parameters as values.
An empty dictionary {} implies using all default values for component parameters. Pipeline-level
parameters such as date_index, gap, and max_delay must be specified with the "pipeline" key. For example:
Pipeline(parameters={"pipeline": {"date_index": "Date", "max_delay": 4, "gap": 2}}).
random_seed (int): Seed for the random number generator. Defaults to 0.
"""
problem_type = ProblemTypes.TIME_SERIES_REGRESSION
"""ProblemTypes.TIME_SERIES_REGRESSION"""
def score(self, X, y, objectives, X_train=None, y_train=None):
"""Evaluate model performance on current and additional objectives.
Args:
X (pd.DataFrame or np.ndarray): Data of shape [n_samples, n_features].
y (pd.Series): True labels of length [n_samples].
objectives (list): Non-empty list of objectives to score on.
X_train (pd.DataFrame, np.ndarray): Data the pipeline was trained on of shape [n_samples_train, n_feautures].
y_train (pd.Series, np.ndarray): Targets used to train the pipeline of shape [n_samples_train].
Returns:
dict: Ordered dictionary of objective scores.
"""
X, y = self._convert_to_woodwork(X, y)
X_train, y_train = self._convert_to_woodwork(X_train, y_train)
objectives = self.create_objectives(objectives)
y_predicted = self.predict_in_sample(X, y, X_train, y_train)
return self._score_all_objectives(
X, y, y_predicted, y_pred_proba=None, objectives=objectives
)
| 939 |
388 | // -*- mode:java; encoding:utf-8 -*-
// vim:set fileencoding=utf-8:
// @homepage@
package example;
import java.awt.*;
import java.awt.geom.Path2D;
import java.util.stream.Stream;
import javax.swing.*;
public final class MainPanel extends JPanel {
private MainPanel() {
super();
JRadioButton r1 = makeRadioButton("red", new ColorIcon(Color.RED));
r1.setSelectedIcon(new SelectedIcon(r1.getIcon(), Color.GREEN));
JRadioButton r2 = makeRadioButton("green", new ColorIcon(Color.GREEN));
r2.setSelectedIcon(new SelectedIcon(r2.getIcon(), Color.BLUE));
JRadioButton r3 = makeRadioButton("blue", new ColorIcon(Color.BLUE));
r3.setSelectedIcon(new SelectedIcon(r3.getIcon(), Color.RED));
ButtonGroup bg1 = new ButtonGroup();
Stream.of(r1, r2, r3).forEach(r -> {
bg1.add(r);
add(r);
});
ClassLoader cl = Thread.currentThread().getContextClassLoader();
JRadioButton r4 = makeRadioButton("test1.jpg", new ImageIcon(cl.getResource("example/test1.jpg")));
r4.setSelectedIcon(new SelectedIcon(r4.getIcon(), Color.GREEN));
JRadioButton r5 = makeRadioButton("test2.jpg", new ImageIcon(cl.getResource("example/test2.jpg")));
r5.setSelectedIcon(new SelectedIcon(r5.getIcon(), Color.BLUE));
JRadioButton r6 = makeRadioButton("test3.jpg", new ImageIcon(cl.getResource("example/test3.jpg")));
r6.setSelectedIcon(new SelectedIcon(r6.getIcon(), Color.RED));
ButtonGroup bg2 = new ButtonGroup();
Stream.of(r4, r5, r6).forEach(r -> {
bg2.add(r);
add(r);
});
setPreferredSize(new Dimension(320, 240));
}
private static JRadioButton makeRadioButton(String text, Icon icon) {
JRadioButton radio = new JRadioButton(text, icon);
radio.setVerticalAlignment(SwingConstants.BOTTOM);
radio.setVerticalTextPosition(SwingConstants.BOTTOM);
radio.setHorizontalAlignment(SwingConstants.CENTER);
radio.setHorizontalTextPosition(SwingConstants.CENTER);
return radio;
}
public static void main(String[] args) {
EventQueue.invokeLater(MainPanel::createAndShowGui);
}
private static void createAndShowGui() {
try {
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
} catch (ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException ex) {
ex.printStackTrace();
Toolkit.getDefaultToolkit().beep();
}
JFrame frame = new JFrame("@title@");
frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
frame.getContentPane().add(new MainPanel());
frame.pack();
frame.setLocationRelativeTo(null);
frame.setVisible(true);
}
}
class ColorIcon implements Icon {
private final Color color;
protected ColorIcon(Color color) {
this.color = color;
}
@Override public void paintIcon(Component c, Graphics g, int x, int y) {
Graphics2D g2 = (Graphics2D) g.create();
g2.translate(x, y);
g2.setPaint(color);
g2.fillRect(0, 0, getIconWidth(), getIconHeight());
g2.dispose();
}
@Override public int getIconWidth() {
return 64;
}
@Override public int getIconHeight() {
return 48;
}
}
class SelectedIcon implements Icon {
private final Icon icon;
private final Color color;
protected SelectedIcon(Icon icon, Color color) {
this.icon = icon;
this.color = color;
}
@Override public void paintIcon(Component c, Graphics g, int x, int y) {
Graphics2D g2 = (Graphics2D) g.create();
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g2.translate(x, y);
icon.paintIcon(c, g2, 0, 0);
Path2D triangle = new Path2D.Double();
triangle.moveTo(getIconWidth(), getIconHeight() / 2d);
triangle.lineTo(getIconWidth(), getIconHeight());
triangle.lineTo(getIconWidth() - getIconHeight() / 2d, getIconHeight());
triangle.closePath();
g2.setPaint(color);
g2.fill(triangle);
g2.setStroke(new BasicStroke(3f));
g2.drawRect(0, 0, getIconWidth(), getIconHeight());
g2.setPaint(Color.WHITE);
Font f = g2.getFont();
g2.drawString("✔", getIconWidth() - f.getSize(), getIconHeight() - 3);
g2.dispose();
}
@Override public int getIconWidth() {
return icon.getIconWidth();
}
@Override public int getIconHeight() {
return icon.getIconHeight();
}
}
| 1,620 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.