content
stringlengths 10
4.9M
|
|---|
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/trace_event/heap_profiler_allocation_register.h"
#include "base/process/process_metrics.h"
#include "base/trace_event/heap_profiler_allocation_context.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace base {
namespace trace_event {
class AllocationRegisterTest : public testing::Test {
public:
static const uint32_t kNumBuckets = AllocationRegister::kNumBuckets;
static const uint32_t kNumCells = AllocationRegister::kNumCells;
// Returns the number of cells that the |AllocationRegister| can store per
// system page.
size_t GetNumCellsPerPage() {
return GetPageSize() / sizeof(AllocationRegister::Cell);
}
uint32_t GetHighWaterMark(const AllocationRegister& reg) {
return reg.next_unused_cell_;
}
};
// Iterates over all entries in the allocation register and returns the bitwise
// or of all addresses stored in it.
uintptr_t OrAllAddresses(const AllocationRegister& reg) {
uintptr_t acc = 0;
for (auto i : reg)
acc |= reinterpret_cast<uintptr_t>(i.address);
return acc;
}
// Iterates over all entries in the allocation register and returns the sum of
// the sizes of the entries.
size_t SumAllSizes(const AllocationRegister& reg) {
size_t sum = 0;
for (auto i : reg)
sum += i.size;
return sum;
}
TEST_F(AllocationRegisterTest, InsertRemove) {
AllocationRegister reg;
AllocationContext ctx = AllocationContext::Empty();
EXPECT_EQ(0u, OrAllAddresses(reg));
reg.Insert(reinterpret_cast<void*>(1), 0, ctx);
EXPECT_EQ(1u, OrAllAddresses(reg));
reg.Insert(reinterpret_cast<void*>(2), 0, ctx);
EXPECT_EQ(3u, OrAllAddresses(reg));
reg.Insert(reinterpret_cast<void*>(4), 0, ctx);
EXPECT_EQ(7u, OrAllAddresses(reg));
reg.Remove(reinterpret_cast<void*>(2));
EXPECT_EQ(5u, OrAllAddresses(reg));
reg.Remove(reinterpret_cast<void*>(4));
EXPECT_EQ(1u, OrAllAddresses(reg));
reg.Remove(reinterpret_cast<void*>(1));
EXPECT_EQ(0u, OrAllAddresses(reg));
}
TEST_F(AllocationRegisterTest, DoubleFreeIsAllowed) {
AllocationRegister reg;
AllocationContext ctx = AllocationContext::Empty();
reg.Insert(reinterpret_cast<void*>(1), 0, ctx);
reg.Insert(reinterpret_cast<void*>(2), 0, ctx);
reg.Remove(reinterpret_cast<void*>(1));
reg.Remove(reinterpret_cast<void*>(1)); // Remove for the second time.
reg.Remove(reinterpret_cast<void*>(4)); // Remove never inserted address.
EXPECT_EQ(2u, OrAllAddresses(reg));
}
TEST_F(AllocationRegisterTest, DoubleInsertOverwrites) {
// TODO(ruuda): Although double insert happens in practice, it should not.
// Find out the cause and ban double insert if possible.
AllocationRegister reg;
AllocationContext ctx = AllocationContext::Empty();
StackFrame frame1 = "Foo";
StackFrame frame2 = "Bar";
ctx.backtrace.frames[0] = frame1;
reg.Insert(reinterpret_cast<void*>(1), 11, ctx);
auto elem = *reg.begin();
EXPECT_EQ(frame1, elem.context.backtrace.frames[0]);
EXPECT_EQ(11u, elem.size);
EXPECT_EQ(reinterpret_cast<void*>(1), elem.address);
ctx.backtrace.frames[0] = frame2;
reg.Insert(reinterpret_cast<void*>(1), 13, ctx);
elem = *reg.begin();
EXPECT_EQ(frame2, elem.context.backtrace.frames[0]);
EXPECT_EQ(13u, elem.size);
EXPECT_EQ(reinterpret_cast<void*>(1), elem.address);
}
// Check that even if more entries than the number of buckets are inserted, the
// register still behaves correctly.
TEST_F(AllocationRegisterTest, InsertRemoveCollisions) {
size_t expected_sum = 0;
AllocationRegister reg;
AllocationContext ctx = AllocationContext::Empty();
// By inserting 100 more entries than the number of buckets, there will be at
// least 100 collisions.
for (uintptr_t i = 1; i <= kNumBuckets + 100; i++) {
size_t size = i % 31;
expected_sum += size;
reg.Insert(reinterpret_cast<void*>(i), size, ctx);
// Don't check the sum on every iteration to keep the test fast.
if (i % (1 << 14) == 0)
EXPECT_EQ(expected_sum, SumAllSizes(reg));
}
EXPECT_EQ(expected_sum, SumAllSizes(reg));
for (uintptr_t i = 1; i <= kNumBuckets + 100; i++) {
size_t size = i % 31;
expected_sum -= size;
reg.Remove(reinterpret_cast<void*>(i));
if (i % (1 << 14) == 0)
EXPECT_EQ(expected_sum, SumAllSizes(reg));
}
EXPECT_EQ(expected_sum, SumAllSizes(reg));
}
// The previous tests are not particularly good for testing iterators, because
// elements are removed and inserted in the same order, meaning that the cells
// fill up from low to high index, and are then freed from low to high index.
// This test removes entries in a different order, to ensure that the iterator
// skips over the freed cells properly. Then insert again to ensure that the
// free list is utilised properly.
TEST_F(AllocationRegisterTest, InsertRemoveRandomOrder) {
size_t expected_sum = 0;
AllocationRegister reg;
AllocationContext ctx = AllocationContext::Empty();
uintptr_t generator = 3;
uintptr_t prime = 1013;
uint32_t initial_water_mark = GetHighWaterMark(reg);
for (uintptr_t i = 2; i < prime; i++) {
size_t size = i % 31;
expected_sum += size;
reg.Insert(reinterpret_cast<void*>(i), size, ctx);
}
// This should have used a fresh slot for each of the |prime - 2| inserts.
ASSERT_EQ(prime - 2, GetHighWaterMark(reg) - initial_water_mark);
// Iterate the numbers 2, 3, ..., prime - 1 in pseudorandom order.
for (uintptr_t i = generator; i != 1; i = (i * generator) % prime) {
size_t size = i % 31;
expected_sum -= size;
reg.Remove(reinterpret_cast<void*>(i));
EXPECT_EQ(expected_sum, SumAllSizes(reg));
}
ASSERT_EQ(0u, expected_sum);
// Insert |prime - 2| entries again. This should use cells from the free list,
// so the |next_unused_cell_| index should not change.
for (uintptr_t i = 2; i < prime; i++)
reg.Insert(reinterpret_cast<void*>(i), 0, ctx);
ASSERT_EQ(prime - 2, GetHighWaterMark(reg) - initial_water_mark);
// Inserting one more entry should use a fresh cell again.
reg.Insert(reinterpret_cast<void*>(prime), 0, ctx);
ASSERT_EQ(prime - 1, GetHighWaterMark(reg) - initial_water_mark);
}
// Check that the process aborts due to hitting the guard page when inserting
// too many elements.
#if GTEST_HAS_DEATH_TEST
TEST_F(AllocationRegisterTest, OverflowDeathTest) {
AllocationRegister reg;
AllocationContext ctx = AllocationContext::Empty();
uintptr_t i;
// Fill up all of the memory allocated for the register. |kNumCells| minus 1
// elements are inserted, because cell 0 is unused, so this should fill up
// the available cells exactly.
for (i = 1; i < kNumCells; i++) {
reg.Insert(reinterpret_cast<void*>(i), 0, ctx);
}
// Adding just one extra element might still work because the allocated memory
// is rounded up to the page size. Adding a page full of elements should cause
// overflow.
const size_t cells_per_page = GetNumCellsPerPage();
ASSERT_DEATH(for (size_t j = 0; j < cells_per_page; j++) {
reg.Insert(reinterpret_cast<void*>(i + j), 0, ctx);
}, "");
}
#endif
} // namespace trace_event
} // namespace base
|
/* $Id: krnlmod-darwin.cpp 68675 2017-09-06 10:08:59Z vboxsync $ */
/** @file
* IPRT - Kernel module, Darwin.
*/
/*
* Copyright (C) 2017 Oracle Corporation
*
* This file is part of VirtualBox Open Source Edition (OSE), as
* available from http://www.virtualbox.org. This file is free software;
* you can redistribute it and/or modify it under the terms of the GNU
* General Public License (GPL) as published by the Free Software
* Foundation, in version 2 as it comes in the "COPYING" file of the
* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
*
* The contents of this file may alternatively be used under the terms
* of the Common Development and Distribution License Version 1.0
* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
* VirtualBox OSE distribution, in which case the provisions of the
* CDDL are applicable instead of those of the GPL.
*
* You may elect to license modified versions of this file under the
* terms and conditions of either the GPL or the CDDL or both.
*/
/*********************************************************************************************************************************
* Header Files *
*********************************************************************************************************************************/
#define LOG_GROUP RTLOGGROUP_SYSTEM
#include <iprt/krnlmod.h>
#include <iprt/asm.h>
#include <iprt/assert.h>
#include <iprt/err.h>
#include <iprt/mem.h>
#include <iprt/string.h>
#include <iprt/types.h>
#include <CoreFoundation/CoreFoundation.h>
#include <IOKit/IOKitLib.h>
/**
* Internal kernel information record state.
*/
typedef struct RTKRNLMODINFOINT
{
/** Reference counter. */
volatile uint32_t cRefs;
/** The dictionary containing our data. */
CFDictionaryRef hDictKext;
} RTKRNLMODINFOINT;
/** Pointer to the internal kernel module information record. */
typedef RTKRNLMODINFOINT *PRTKRNLMODINFOINT;
/** Pointer to a const internal kernel module information record. */
typedef const RTKRNLMODINFOINT *PCRTKRNLMODINFOINT;
/**
* The declarations are not exposed so we have to define them ourselves.
*/
extern "C"
{
extern CFDictionaryRef OSKextCopyLoadedKextInfo(CFArrayRef, CFArrayRef);
}
#ifndef kOSBundleRetainCountKey
# define kOSBundleRetainCountKey CFSTR("OSBundleRetainCount")
#endif
#ifndef kOSBundleLoadSizeKey
# define kOSBundleLoadSizeKey CFSTR("OSBundleLoadSize")
#endif
#ifndef kOSBundleLoadAddressKey
# define kOSBundleLoadAddressKey CFSTR("OSBundleLoadAddress")
#endif
/**
* Returns the kext information dictionary structure matching the given name.
*
* @returns Pointer to the matching module information record on success or NULL if not found.
* @param pszName The name to look for.
*/
static CFDictionaryRef rtKrnlModDarwinGetKextInfoByName(const char *pszName)
{
CFDictionaryRef hDictKext = NULL;
CFStringRef hKextName = CFStringCreateWithCString(kCFAllocatorDefault, pszName, kCFStringEncodingUTF8);
if (hKextName)
{
CFArrayRef hArrKextIdRef = CFArrayCreate(kCFAllocatorDefault, (const void **)&hKextName, 1, &kCFTypeArrayCallBacks);
if (hArrKextIdRef)
{
CFDictionaryRef hLoadedKexts = OSKextCopyLoadedKextInfo(hArrKextIdRef, NULL /* all info */);
if (hLoadedKexts)
{
if (CFDictionaryGetCount(hLoadedKexts) > 0)
{
hDictKext = (CFDictionaryRef)CFDictionaryGetValue(hLoadedKexts, hKextName);
CFRetain(hDictKext);
}
CFRelease(hLoadedKexts);
}
CFRelease(hArrKextIdRef);
}
CFRelease(hKextName);
}
return hDictKext;
}
/**
* Destroy the given kernel module information record.
*
* @returns nothing.
* @param pThis The record to destroy.
*/
static void rtKrnlModInfoDestroy(PRTKRNLMODINFOINT pThis)
{
CFRelease(pThis->hDictKext);
RTMemFree(pThis);
}
RTDECL(int) RTKrnlModQueryLoaded(const char *pszName, bool *pfLoaded)
{
AssertPtrReturn(pszName, VERR_INVALID_POINTER);
AssertPtrReturn(pfLoaded, VERR_INVALID_POINTER);
CFDictionaryRef hDictKext = rtKrnlModDarwinGetKextInfoByName(pszName);
*pfLoaded = hDictKext != NULL;
if (hDictKext)
CFRelease(hDictKext);
return VINF_SUCCESS;
}
RTDECL(int) RTKrnlModLoadedQueryInfo(const char *pszName, PRTKRNLMODINFO phKrnlModInfo)
{
AssertPtrReturn(pszName, VERR_INVALID_POINTER);
AssertPtrReturn(phKrnlModInfo, VERR_INVALID_POINTER);
int rc = VINF_SUCCESS;
CFDictionaryRef hDictKext = rtKrnlModDarwinGetKextInfoByName(pszName);
if (hDictKext)
{
PRTKRNLMODINFOINT pThis = (PRTKRNLMODINFOINT)RTMemAllocZ(sizeof(RTKRNLMODINFOINT));
if (pThis)
{
pThis->cRefs = 1;
pThis->hDictKext = hDictKext;
*phKrnlModInfo = pThis;
}
else
rc = VERR_NO_MEMORY;
}
else
rc = VERR_NOT_FOUND;
return rc;
}
RTDECL(uint32_t) RTKrnlModLoadedGetCount(void)
{
uint32_t cLoadedKexts = 0;
CFDictionaryRef hLoadedKexts = OSKextCopyLoadedKextInfo(NULL, NULL /* all info */);
if (hLoadedKexts)
{
cLoadedKexts = CFDictionaryGetCount(hLoadedKexts);
CFRelease(hLoadedKexts);
}
return cLoadedKexts;
}
RTDECL(int) RTKrnlModLoadedQueryInfoAll(PRTKRNLMODINFO pahKrnlModInfo, uint32_t cEntriesMax,
uint32_t *pcEntries)
{
AssertReturn(VALID_PTR(pahKrnlModInfo) || cEntriesMax == 0, VERR_INVALID_PARAMETER);
int rc = VINF_SUCCESS;
CFDictionaryRef hLoadedKexts = OSKextCopyLoadedKextInfo(NULL, NULL /* all info */);
if (hLoadedKexts)
{
uint32_t cLoadedKexts = CFDictionaryGetCount(hLoadedKexts);
if (cLoadedKexts <= cEntriesMax)
{
CFDictionaryRef *pahDictKext = (CFDictionaryRef *)RTMemTmpAllocZ(cLoadedKexts * sizeof(CFDictionaryRef));
if (pahDictKext)
{
CFDictionaryGetKeysAndValues(hLoadedKexts, NULL, (const void **)pahDictKext);
for (uint32_t i = 0; i < cLoadedKexts; i++)
{
PRTKRNLMODINFOINT pThis = (PRTKRNLMODINFOINT)RTMemAllocZ(sizeof(RTKRNLMODINFOINT));
if (RT_LIKELY(pThis))
{
pThis->cRefs = 1;
pThis->hDictKext = pahDictKext[i];
CFRetain(pThis->hDictKext);
pahKrnlModInfo[i] = pThis;
}
else
{
rc = VERR_NO_MEMORY;
/* Rollback. */
while (i-- > 0)
{
CFRelease(pahKrnlModInfo[i]->hDictKext);
RTMemFree(pahKrnlModInfo[i]);
}
}
}
if ( RT_SUCCESS(rc)
&& pcEntries)
*pcEntries = cLoadedKexts;
RTMemTmpFree(pahDictKext);
}
else
rc = VERR_NO_MEMORY;
}
else
{
rc = VERR_BUFFER_OVERFLOW;
if (pcEntries)
*pcEntries = cLoadedKexts;
}
CFRelease(hLoadedKexts);
}
else
rc = VERR_NOT_SUPPORTED;
return rc;
}
RTDECL(uint32_t) RTKrnlModInfoRetain(RTKRNLMODINFO hKrnlModInfo)
{
PRTKRNLMODINFOINT pThis = hKrnlModInfo;
AssertPtrReturn(pThis, UINT32_MAX);
uint32_t cRefs = ASMAtomicIncU32(&pThis->cRefs);
AssertMsg(cRefs > 1 && cRefs < _1M, ("%#x %p\n", cRefs, pThis));
return cRefs;
}
RTDECL(uint32_t) RTKrnlModInfoRelease(RTKRNLMODINFO hKrnlModInfo)
{
PRTKRNLMODINFOINT pThis = hKrnlModInfo;
if (!pThis)
return 0;
AssertPtrReturn(pThis, UINT32_MAX);
uint32_t cRefs = ASMAtomicDecU32(&pThis->cRefs);
AssertMsg(cRefs < _1M, ("%#x %p\n", cRefs, pThis));
if (cRefs == 0)
rtKrnlModInfoDestroy(pThis);
return cRefs;
}
RTDECL(uint32_t) RTKrnlModInfoGetRefCnt(RTKRNLMODINFO hKrnlModInfo)
{
PRTKRNLMODINFOINT pThis = hKrnlModInfo;
AssertPtrReturn(pThis, 0);
uint32_t cRefCnt = 0;
CFNumberRef hRetainCnt = (CFNumberRef)CFDictionaryGetValue(pThis->hDictKext,
kOSBundleRetainCountKey);
if (hRetainCnt)
CFNumberGetValue(hRetainCnt, kCFNumberSInt32Type, &cRefCnt);
return cRefCnt;
}
RTDECL(const char *) RTKrnlModInfoGetName(RTKRNLMODINFO hKrnlModInfo)
{
PRTKRNLMODINFOINT pThis = hKrnlModInfo;
AssertPtrReturn(pThis, NULL);
const char *pszName = NULL;
CFStringRef hBundleId = (CFStringRef)CFDictionaryGetValue(pThis->hDictKext,
kCFBundleIdentifierKey);
if (hBundleId)
pszName = CFStringGetCStringPtr(hBundleId, kCFStringEncodingUTF8);
return pszName;
}
RTDECL(const char *) RTKrnlModInfoGetFilePath(RTKRNLMODINFO hKrnlModInfo)
{
PRTKRNLMODINFOINT pThis = hKrnlModInfo;
AssertPtrReturn(pThis, NULL);
return NULL;
}
RTDECL(size_t) RTKrnlModInfoGetSize(RTKRNLMODINFO hKrnlModInfo)
{
PRTKRNLMODINFOINT pThis = hKrnlModInfo;
AssertPtrReturn(pThis, 0);
size_t cbKrnlMod = 0;
CFNumberRef hKrnlModSize = (CFNumberRef)CFDictionaryGetValue(pThis->hDictKext,
kOSBundleLoadSizeKey);
if (hKrnlModSize)
{
uint32_t cbTmp = 0;
CFNumberGetValue(hKrnlModSize, kCFNumberSInt32Type, &cbTmp);
cbKrnlMod = cbTmp;
}
return cbKrnlMod;
}
RTDECL(RTR0UINTPTR) RTKrnlModInfoGetLoadAddr(RTKRNLMODINFO hKrnlModInfo)
{
PRTKRNLMODINFOINT pThis = hKrnlModInfo;
AssertPtrReturn(pThis, 0);
RTR0UINTPTR uKrnlModLoadAddr = 0;
CFNumberRef hKrnlModLoadAddr = (CFNumberRef)CFDictionaryGetValue(pThis->hDictKext,
kOSBundleLoadAddressKey);
if (hKrnlModLoadAddr)
{
uint64_t uAddrTmp = 0;
CFNumberGetValue(hKrnlModLoadAddr, kCFNumberSInt64Type, &uAddrTmp);
uKrnlModLoadAddr = uAddrTmp;
}
return uKrnlModLoadAddr;
}
RTDECL(int) RTKrnlModInfoQueryRefModInfo(RTKRNLMODINFO hKrnlModInfo, uint32_t idx,
PRTKRNLMODINFO phKrnlModInfoRef)
{
RT_NOREF3(hKrnlModInfo, idx, phKrnlModInfoRef);
return VERR_NOT_IMPLEMENTED;
}
|
/**
* Creates a list of allowed attribute values for an existing attribute value list key.
*
* @param request the information needed to create the allowed attribute values
*
* @return the newly created allowed attribute values
*/
@NamespacePermission(fields = "#request.attributeValueListKey.namespace", permissions = NamespacePermissionEnum.WRITE)
@Override
public AllowedAttributeValuesInformation createAllowedAttributeValues(AllowedAttributeValuesCreateRequest request)
{
validateAllowedAttributeValuesCreateRequest(request);
AttributeValueListEntity attributeValueListEntity = attributeValueListDaoHelper.getAttributeValueListEntity(request.getAttributeValueListKey());
Map<String, AllowedAttributeValueEntity> allowedAttributeValueEntityMap =
getAllowedAttributeValueEntityMap(attributeValueListEntity.getAllowedAttributeValues());
for (String allowedAttributeValue : request.getAllowedAttributeValues())
{
if (allowedAttributeValueEntityMap.containsKey(allowedAttributeValue))
{
throw new AlreadyExistsException(String
.format("Allowed attribute value \"%s\" already exists in \"%s\" attribute value list.", allowedAttributeValue,
attributeValueListEntity.getName()));
}
}
Collection<AllowedAttributeValueEntity> createdAllowedAttributeValueEntities = new ArrayList<>();
for (String allowedAttributeValue : request.getAllowedAttributeValues())
{
AllowedAttributeValueEntity allowedAttributeValueEntity = new AllowedAttributeValueEntity();
createdAllowedAttributeValueEntities.add(allowedAttributeValueEntity);
allowedAttributeValueEntity.setAttributeValueList(attributeValueListEntity);
allowedAttributeValueEntity.setAllowedAttributeValue(allowedAttributeValue);
allowedAttributeValueDao.saveAndRefresh(allowedAttributeValueEntity);
}
allowedAttributeValueDao.saveAndRefresh(attributeValueListEntity);
return createAllowedAttributeValuesInformationFromEntities(attributeValueListEntity, createdAllowedAttributeValueEntities);
} |
def response(self):
while True:
packet, metadata = self.recv(self.response_handle)
if not packet:
return
client = (packet.dst_addr, packet.dst_port)
server = self.client_server_map.get(client, None)
if server:
packet.src_addr, packet.src_port = server
else:
print("Warning: Previously unseen connection from proxy to %s:%s." % client)
packet = self.driver.update_packet_checksums(packet)
self.response_handle.send((packet.raw, metadata)) |
package downloads
import (
"net/http"
"github.com/gin-gonic/gin"
)
func Index(c *gin.Context) {
results, err := app.DB.Download.Active()
if err != nil {
c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
for _, d := range results {
m, err := app.DB.Medium.FindByID(d.MediumId)
if err != nil {
app.Log.Errorf("could not find medium: %s", d.MediumId)
continue
}
app.Log.Infof("found %s: %s", m.ID, m.Title)
}
c.JSON(http.StatusOK, results)
}
|
def explore_clusters_vs_y(dfclus, y):
import pandas as pd
df_ = pd.concat([dfclus, y], axis=1)
s_ = df_.apply(lambda c: c.value_counts(normalize=True)).unstack().dropna()
s_.name = 'size'
s_.index.names = ['index', 'idxmax']
df = \
(df_
.apply(lambda c: df_.groupby(c)['y'].mean())
.agg(['max', 'idxmax'])
.T
.drop('y')
.reset_index()
.set_index(['index', 'idxmax'])
.join(s_.to_frame())
.round(2)
.reset_index()
.rename(columns={'index': 'K', 'idxmax': 'Clus', 'max': 'y_mean'})
)
return df |
<filename>maliit-plugin-chinese/openautomata/pyzyautomata.h
// Copyright (c) 2017-2019 LG Electronics, 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.
//
// SPDX-License-Identifier: Apache-2.0
#ifndef PYZY_AUTOMATA_H
#define PYZY_AUTOMATA_H
#include <QEvent>
#include <QObject>
#include <QString>
#include <QStringList>
#include <QDebug>
#include <dlfcn.h>
#include "automata.h"
typedef void* (INIT_CONTEXT)(const std::string&, const std::string&);
typedef bool (INSERT_CHAR)(void*,char);
typedef bool (REMOVE_CHAR)(void*);
typedef bool (HAS_CANDIDATE)(void*,int);
typedef bool (SELECT_CANDIDATE)(void*,int);
typedef int (GET_CANDIDATES_SIZE)(void*);
typedef const std::string& (GET_CANDIDATE)(void*, int);
typedef const std::string& (REST_TEXT)(void*);
typedef const std::string& (SELECTED_TEXT)(void*);
typedef const std::string& (CONVERSION_TEXT)(void*);
typedef const std::string& (AUXILIARY_TEXT)(void*);
typedef const std::string& (COMMIT_TEXT)(void*);
typedef void (RESET_CONTEXT)(void*);
typedef void (CLOSE)(void*);
class PyzyAutomata : public Automata
{
Q_OBJECT
public:
PyzyAutomata();
~PyzyAutomata();
bool setLanguage (const QString &language);
QString getLanguage();
void suggestionSelected(int index);
void strokeComponentSelected(int index);
QString getPreedit();
QString getCommit();
bool processKeyEvent(Qt::Key keycode, Qt::KeyboardModifiers modifiers);
QStringList getSuggestionList();
QStringList getStrokeComponentList();
int getStrokeComponentCount();
void shifted (bool shift);
bool isShifted();
bool isNextSuggestionsAvailable();
bool isPreviousSuggestionsAvailable();
void nextSuggestions();
void previousSuggestions();
void reset();
bool isDirectInput(Qt::Key keycode);
bool isComposing();
int getCandidatesNum();
quint32 chineseSymbolKeyMapping(Qt::Key keycode);
private:
void init();
void *pyzy_lib_handle;
void *context;
INIT_CONTEXT *initContext;
INSERT_CHAR *insertChar;
REMOVE_CHAR *removeChar;
HAS_CANDIDATE *hasCandidate;
SELECT_CANDIDATE *selectCandidate;
GET_CANDIDATES_SIZE *getCandidatesSize;
GET_CANDIDATE *getCandidate;
REST_TEXT *restText;
SELECTED_TEXT *selectedText;
CONVERSION_TEXT *conversionText;
AUXILIARY_TEXT *auxiliaryText;
COMMIT_TEXT *commitText;
RESET_CONTEXT *resetContext;
CLOSE *close;
bool m_shift;
QString m_language;
int m_cur_page;
};
#endif //PYZY_AUTOMATA_H
|
#include <iostream>
using namespace std;
#include<bits/stdc++.h>
int main() {
int n,k,x;
cin>>n>>k>>x;
int freq[1500]={0};
for(int i=0;i<n;i++)
{
int num;
cin>>num;
freq[num]++;
}
int temp[1500]={0};
while(k--)
{
for(int i=0;i<1500;i++)
{
temp[i]=freq[i];
}
int parity=0;
for(int i=0;i<1500;i++)
{
if(freq[i]>0)
{
int change_val=(i^x);
int changes=freq[i]/2;
if(parity==0)
{
changes+=(freq[i]&1);
}
temp[i]-=changes;
temp[change_val]+=changes;
parity^=(freq[i]&1);
}
}
for(int i=0;i<1500;i++)
freq[i]=temp[i];
}
int mini=INT_MAX;
int maxi=INT_MIN;
for(int i=0;i<1500;i++)
{
if(freq[i]>0)
{
mini=min(i,mini);
maxi=max(i,maxi);
}
}
cout<<maxi<<" "<<mini;
}
|
So, the government interferes in the market by incentivizing its citizens to buy hybrid and electric with big ol’ tax credits. It’ll be great for consumers and the environment, they say! You’ll save money and the air, it will be sweet with good intentions. But then people actually bought those electric and hybrid cars, car manufacturers responded to government mandates and consumer pushes for increased gas mileage, and the economy and gas prices dictated that a bunch of people start watching how much they drive. And, now you’ve got a revenue problem, what with far less money coming in the form of gas taxes.
What’s a state government to do? Well, certainly not remove its grimy hands from the mix for half a second to see what the natural state of the market might bring. Certainly not start making rational decisions about how to use this declining revenue as efficiently as possible. Certainly not stop raiding infrastructure funds for whatever they damn well please before coming to citizens for more taxes (Hi, Maryland Gov. Martin O’Malley). No, no, no, now they gotta tax those green cars that they got you to buy with those tax incentives in the first place! Sorry, suckahs! Shoulda known any deal with the devil was bound to burn up:
SAN FRANCISCO (Bloomberg) — Hybrid and electric cars are sparing the environment. Critics say they’re hurting the roads. The popularity of these fuel-efficient vehicles is being blamed for a drop in gasoline taxes that pay for local highway and bridge maintenance, with three states enacting rules to make up the losses with added fees on the cars and at least five others weighing similar legislation. “The intent is that people who use the roads pay for them,” said Arizona state Senator Steve Farley, a Democrat from Tucson who wrote a bill to tax electric cars. “Just because we have somebody who is getting out of doing it because they have an alternative form of fuel, that doesn’t mean they shouldn’t pay for the roads.”
I’m somewhat sympathetic to the notion that, because gas taxes pay for roads, it’s unfair for those who aren’t buying gas to get what critics call a literal free ride. This problem is more pronounced with bike riders who argue for reconfiguration of entire cities’ roads without throwing a whole bunch in the pot. But the larger point is how elaborately stupid, counterproductive, and at odds with itself idiotic governments become in using our money to push for one policy with subsidized products, only to turn around and complain that all those subsidies are costing them money. Um, yes, that’s what we were saying years ago when you started subsidizing these cars with thousands of our dollars and lecturing us about how awesome it was going to be. STEP AWAY FROM THE RUBE GOLDBERG MACHINES IN YOUR MINDS. YOU DON’T KNOW WHAT YOU’RE DOING.
Here’s what the tax structure looks like at the moment in states trying this. The prices are low-ish now, but please don’t be silly enough to think they’re not going up:
In Washington state, electric-car owners this year began paying a $100 annual fee. Virginia in April approved a $64 annual fee on hybrid and electric cars. In New Jersey, Senator Jim Whelan, a Democrat from Atlantic City, has proposed a $50 annual fee on electric and compressed natural-gas cars that would be deposited into a state fund for road and bridge maintenance… In Arizona, Farley’s measure, which has stalled, would impose a tax on electric cars of 1 cent per mile driven on the state’s highways, amounting to about $120 annually per car, he said. Texas lawmakers considered a similar bill this year. In Indiana, lawmakers created a committee to study a local road impact fee on electric and hybrid cars to be paid at registration. North Carolina’s Senate on May 23 approved a budget plan that includes a $100 fee for electric cars and $50 for hybrid cars, said Amy Auth, deputy chief of staff for Phil Berger, Senate president pro tempore. The plan has gone to the House for review, she said.
I look forward to the taxing of non-smokers to make up for all that lost tobacco tax revenue, too. |
package seedu.address.logic.parser.client;
import static seedu.address.commons.core.Messages.MESSAGE_INVALID_COMMAND_FORMAT;
import static seedu.address.logic.parser.CliSyntax.PREFIX_ADDRESS;
import static seedu.address.logic.parser.CliSyntax.PREFIX_EMAIL;
import static seedu.address.logic.parser.CliSyntax.PREFIX_GENDER;
import static seedu.address.logic.parser.CliSyntax.PREFIX_NAME;
import static seedu.address.logic.parser.CliSyntax.PREFIX_PHONE;
import static seedu.address.logic.parser.CliSyntax.PREFIX_TAG;
import java.util.Set;
import seedu.address.logic.commands.client.AddClientCommand;
import seedu.address.logic.parser.AddCommandParser;
import seedu.address.logic.parser.ArgumentMultimap;
import seedu.address.logic.parser.ArgumentTokenizer;
import seedu.address.logic.parser.ParserUtil;
import seedu.address.logic.parser.exceptions.ParseException;
import seedu.address.model.person.Email;
import seedu.address.model.person.Gender;
import seedu.address.model.person.Name;
import seedu.address.model.person.Phone;
import seedu.address.model.person.client.Address;
import seedu.address.model.person.client.Client;
import seedu.address.model.tag.Tag;
/**
* Parses input arguments and creates a new AddCommand object
*/
public class AddClientCommandParser extends AddCommandParser<AddClientCommand> {
/**
* Parses the given {@code String} of arguments in the context of the AddCommand
* and returns an AddCommand object for execution.
* @throws ParseException if the user input does not conform the expected format
*/
@Override
public AddClientCommand parse(String args) throws ParseException {
ArgumentMultimap argMultimap =
ArgumentTokenizer.tokenize(args, PREFIX_NAME, PREFIX_PHONE, PREFIX_EMAIL, PREFIX_GENDER, PREFIX_ADDRESS,
PREFIX_TAG);
if (!arePrefixesPresent(argMultimap, PREFIX_NAME, PREFIX_PHONE, PREFIX_EMAIL, PREFIX_GENDER, PREFIX_ADDRESS)
|| !argMultimap.getPreamble().isEmpty()) {
throw new ParseException(String.format(MESSAGE_INVALID_COMMAND_FORMAT, AddClientCommand.MESSAGE_USAGE));
}
Name name = ParserUtil.parseName(argMultimap.getValue(PREFIX_NAME).get());
Phone phone = ParserUtil.parsePhone(argMultimap.getValue(PREFIX_PHONE).get());
Email email = ParserUtil.parseEmail(argMultimap.getValue(PREFIX_EMAIL).get());
Gender gender = ParserUtil.parseGender(argMultimap.getValue(PREFIX_GENDER).get());
Address address = ParserUtil.parseAddress(argMultimap.getValue(PREFIX_ADDRESS).get());
Set<Tag> tagList = ParserUtil.parseTags(argMultimap.getAllValues(PREFIX_TAG));
Client client = new Client(name, phone, email, gender, address, tagList);
return new AddClientCommand(client);
}
}
|
Original article by Fulvio Vassallo Paleologo published by Il lavoro culturale on 10 October 2013.
After the enormous tragedy in the seas around Lampedusa, some consideration of responsibility for the ‘reception’ system in Italy is in order.
The pictures taken by a RAI correspondent who spent the night at Lampedusa’s Contrada Imbriacola initial reception and emergency centre [here some images, from minute 1.10] have been seen all around the world. The Minister for the Interior, Alfano, and the managers of the centre can no longer say that the centre is only experiencing overcrowding and that the Italian reception system is working.
Officials, using the 1995 Puglia law, have put together a myriad informal (and illegal) detention centres – improvised shelters such as schools and gyms, and also industrial sheds and tents erected in a fish market. For many migrants, it is imperative to get out of Italy without being fingerprinted, in order to enter a country with an asylum procedure that is really able to welcome and integrate them. This year, almost 5,000 Syrians arriving in Sicily fled to countries in Northern Europe to submit an application for asylum and find a decent reception. Many were beaten as they tried to escape or because they refused to be fingerprinted.
And the survivors of the Lampedusa tragedy know this. They are afraid of being transferred to facilities such as the Pozzallo CPSA where there have been serious abuses of migrants, some unaccompanied minors.
Once again, Lampedusa is providing the same poor reception, a reception which has been complained about since 2003 and which is documented by video and reports readily available on the net. This happens again and again, a recurrent emergency as international crises erupt.
Now it’s almost exclusively potential asylum-seekers who arrive – ‘potential’ because really none of them want to apply for asylum and stay in Italy where, as is well known, the procedures can last for years. In fact, in Italy asylum-seekers do not have work or housing and are systematically denied the possibility of integration which other European countries provide. Once again, the Lampedusa initial reception centre illustrates the much larger and deep-rooted problem of the Italian reception system.
It was only in 2008 that the “Lampedusa model” (an integrated system of fast transfers and second reception centres, created by State Regional Prefect Morcone and developed into the Praesidium project, in agreement with the Ministry of the Interior) made it possible to ensure the rapid transit of 30,000 survivors from the island (fewer people than this have arrived this year), with a shorter maximum stay of 72 hours, and then rapid transfer to second reception centres throughout Italy.
Now we see a degrading and disheartening situation affecting the survivors of the most serious shipwreck tragedy that has ever occurred in the Mediterranean. And the representatives of the Praesidium, who live with this situation every day, are no longer able to influence the decisions of the Ministry of the Interior. On the contrary: most do not report what is happening, even with simple communications, as was the case until 30 April this year.
It is journalists and parliamentarians who have been able to uncover the inhuman and degrading treatment suffered by immigrants detained in the initial reception centres (Centri di Prima Accoglienza, CPA). In fact, in Lampedusa’s CPA, no-one is allowed inside, not even the Mayor of Lampedusa. It is often used as a “closed centre”, even though it’s a building you can easily go in and out of, despite continual repair of the barbed wire fence surrounding it. Outside, it looks like a big cage at the bottom of a ditch; inside, there are not enough beds. Women and children often have to share sleeping areas with men. [The lack of beds means that many people also sleep outside.]
This is a situation we have complained about for years and which many have ignored until Lampedusa attracted the mainstream media’s spotlight. This time, with so many dead, no-one could ignore what was happening and had also to consider the unacceptable conditions in which those rescued are being held. The criminal investigations to which the “survivors” were subjected show all too clearly the immigration law’s unnecessary harassment, that is, the Bossi-Fini law and the complementary 2009 Maroni decree which introduced the crime of illegal immigration.
The Contrada Imbriacola initial reception and aid centre should be emptied and renovated – there are still signs of the fire that destroyed part of it in 2011. As a matter of urgency, the refugees should be transferred to proper shelters or to requisitioned hotels, helped by professionals such as counsellors, lawyers, psychologists and doctors. They should not be deported to the Pozzallo reception centre (CPSA) which, when it is overcrowded as it is now, has similar conditions to those of Lampedusa. And they should certainly not be deported to the Mineo mega-reception centre (CARA) where 3,000 people are sinking in a place beyond time and history. Other centres with the appropriate expertise to provide a properly decentralised reception are needed. This takes money and professionalism. This subject, which is not only and always part of public order, has to be removed from the sphere of State regional prefects and prosecutors.
The recurring and clearly unacceptable conditions of the Italian reception centres (CPSA) in Sicily (Pozzallo and Lampedusa) are outlined in a report coordinated by ASGI “The right to protection”.
They will be able to clean up and clear the Contrada Imbriacola centre ahead of Mr Barroso’s visit to Lampedusa with Deputy Prime Minister Alfano (9 October) but they will not be able to hide the shame for which they are responsible.
Related articles:
[en] Riots close Italy’s immigrant detention centers
Immigrants detention centers in Italy
Immigration Policies in Italy
The Revolts of Migrants in Lampedusa and Pozzallo
Advertisements |
package org.jglr.sbm.visitors;
import jdk.internal.org.objectweb.asm.ByteVector;
import org.jglr.flows.io.ByteArray;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.channels.ByteChannel;
public class ModuleWriter implements ModuleVisitor {
protected final HeaderWriter headerWriter;
protected CodeWriter codeWriter;
public ModuleWriter() {
headerWriter = new HeaderWriter();
codeWriter = new CodeWriter();
}
@Override
public HeaderVisitor visitHeader() throws IOException {
return headerWriter;
}
@Override
public CodeVisitor visitCode() throws IOException {
return codeWriter;
}
public byte[] toBytes() {
ByteArray resultBuffer = new ByteArray();
resultBuffer.setByteOrder(ByteOrder.BIG_ENDIAN);
resultBuffer.putUnsignedInt(0x07230203);
resultBuffer.putArray(headerWriter.toBytes());
resultBuffer.putArray(codeWriter.toBytes());
return resultBuffer.backingArray();
}
}
|
#include "../../../../../src/pdf/api/qpdfsearchresult_p.h"
|
/*
* Copyright (c) 2011 <NAME>
*
* All Rights Reserved.
*
* Distributed under the BSD Software License (see license.txt)
*/
package com.beatofthedrum.alacdecoder;
class SampleDuration {
int sample_byte_size = 0;
int sample_duration = 0;
}
|
/**
* Checks for foreign key violations by executing a PRAGMA foreign_key_check.
*/
public static void foreignKeyCheck(@NonNull SupportSQLiteDatabase db,
@NonNull String tableName) {
Cursor cursor = db.query("PRAGMA foreign_key_check(`" + tableName + "`)");
try {
if (cursor.getCount() > 0) {
String errorMsg = processForeignKeyCheckFailure(cursor);
throw new IllegalStateException(errorMsg);
}
} finally {
cursor.close();
}
} |
<reponame>pcarver/rmd
package proc
import (
"bufio"
"fmt"
"io/ioutil"
"os"
"path/filepath"
"strconv"
"strings"
"syscall"
"unsafe"
"github.com/intel/rmd/lib/util"
"golang.org/x/sys/unix"
)
const (
// CPUInfoPath is the patch to cpuinfo
CPUInfoPath = "/proc/cpuinfo"
// MountInfoPath is the mount info path
MountInfoPath = "/proc/self/mountinfo"
// ResctrlPath is the patch to resctrl
ResctrlPath = "/sys/fs/resctrl"
// MbaInfoPath is the MBA path of
MbaInfoPath = "/sys/fs/resctrl/info/MB"
)
// rdt_a, cat_l3, cdp_l3, cqm, cqm_llc, cqm_occup_llc
// cqm_mbm_total, cqm_mbm_local
func parseCPUInfoFile(flag string) (bool, error) {
f, err := os.Open(CPUInfoPath)
if err != nil {
return false, err
}
defer f.Close()
s := bufio.NewScanner(f)
for s.Scan() {
if err := s.Err(); err != nil {
return false, err
}
text := s.Text()
flags := strings.Split(text, " ")
for _, f := range flags {
if f == flag {
return true, nil
}
}
}
return false, nil
}
// IsRdtAvailable returns RDT feature available or not
func IsRdtAvailable() (bool, error) {
return parseCPUInfoFile("rdt_a")
}
// IsCqmAvailable returns CMT feature available or not
func IsCqmAvailable() (bool, error) {
return parseCPUInfoFile("cqm")
}
// IsCdpAvailable returns CDP feature available or not
func IsCdpAvailable() (bool, error) {
return parseCPUInfoFile("cdp_l3")
}
// IsMbaAvailable returns MBA feature available or not
var IsMbaAvailable = func() (bool, error) {
return parseCPUInfoFile("mba")
}
// we can use shell command: "mount -l -t resctrl"
var findMountDir = func(mountdir string) (string, error) {
f, err := os.Open(MountInfoPath)
if err != nil {
return "", err
}
defer f.Close()
s := bufio.NewScanner(f)
for s.Scan() {
text := s.Text()
if strings.Contains(text, mountdir) {
// http://man7.org/linux/man-pages/man5/proc.5.html
// text = strings.Replace(text, " - ", " ", -1)
// fields := strings.Split(text, " ")[4:]
return text, nil
}
}
return "", fmt.Errorf("Can not found the mount entry: %s", mountdir)
}
// IsEnableRdt returns if RDT is enabled or not
func IsEnableRdt() bool {
mount, err := findMountDir(ResctrlPath)
if err != nil {
return false
}
return len(mount) > 0
}
// IsEnableCdp returns if CDP is enabled or not
func IsEnableCdp() bool {
var flag = "cdp"
mount, err := findMountDir(ResctrlPath)
if err != nil {
return false
}
return strings.Contains(mount, flag)
}
// IsEnableCat returns if CAT is enabled or not
func IsEnableCat() bool {
var flag = "cdp"
mount, err := findMountDir(ResctrlPath)
if err != nil {
return false
}
return !strings.Contains(mount, flag) && len(mount) > 0
}
// IsEnableMba returns if MBA is enabled or not
var IsEnableMba = func() (bool, error) {
_, err := findMountDir(ResctrlPath)
if err != nil {
return false, err
}
if stat, err := os.Stat(MbaInfoPath); err == nil {
if stat.IsDir() {
return true, nil
}
return false, nil
}
return false, err
}
// Process struct with pid and command line
type Process struct {
Pid int
CmdLine string
}
// ListProcesses returns all process on the host
var ListProcesses = func() map[string]Process {
processes := make(map[string]Process)
files, _ := filepath.Glob("/proc/[0-9]*/cmdline")
for _, file := range files {
listfs := strings.Split(file, "/")
if pid, err := strconv.Atoi(listfs[2]); err == nil {
cmd, _ := ioutil.ReadFile(file)
cmdString := strings.Join(strings.Split(string(cmd), "\x00"), " ")
processes[listfs[2]] = Process{pid, cmdString}
}
}
return processes
}
// GetCPUAffinity returns the affinity of a given task id
func GetCPUAffinity(Pid string) (*util.Bitmap, error) {
// each uint is 64 bits
// max support 16 * 64 cpus
var mask [16]uintptr
pid, err := strconv.Atoi(Pid)
if err != nil {
return nil, err
}
_, _, ierr := syscall.RawSyscall(
unix.SYS_SCHED_GETAFFINITY,
uintptr(pid),
uintptr(len(mask)*8),
uintptr(unsafe.Pointer(&mask[0])),
)
// util.Bitmap.Bits accept 32 bit int type, need to covert it
var bits []int
for _, i := range mask {
val := uint(i)
// FIXME: what's the hell, find low 32 bits
bits = append(bits, int((val<<32)>>32))
bits = append(bits, int(val>>32))
}
if ierr != 0 {
return nil, ierr
}
// this is so hacking to construct a Bitmap,
// Bitmap shouldn't expose detail to other package at all
return &util.Bitmap{
// Need to set correctly and carefully, this is the total cpu
// number
Len: 16 * 64,
Bits: bits,
}, nil
}
// SetCPUAffinity set a process/thread's CPU affinity
//func SetCPUAffinity(Pid string, affinity []int) error {
func SetCPUAffinity(Pid string, cpus *util.Bitmap) error {
var mask [16]uintptr
pid, err := strconv.Atoi(Pid)
if err != nil {
return err
}
for idx, bit := range cpus.Bits {
ubit := uintptr(bit)
mask[idx/2] |= ubit
}
_, _, ierr := syscall.RawSyscall(unix.SYS_SCHED_SETAFFINITY, uintptr(pid), uintptr(len(mask)*8), uintptr(unsafe.Pointer(&mask[0])))
if ierr != 0 {
return ierr
}
return nil
}
|
<reponame>markhliu99/CAI
#include "problem_description.hpp"
#include "expression_helpers.hpp"
#include <iostream>
#include <cstdlib>
#include <vector>
#include <cstdio>
#include <fstream>
#include <sstream>
#include <stdexcept>
#include <set>
#include <string>
#include <map>
#include <set>
#include "nlohmann/json.hpp"
#include <iostream>
#pragma warning(disable: 4996)
using namespace std;
using nlohmann::json;
using namespace CAI;
typedef std::runtime_error SRE;
// Need to initialize Coefficient
Term::Term()
{
Operation = "";
Coefficient = 1;
Var = NULL;
Constant = 0;
Information_Vars.resize(2);
}
Term::Term(Term* t)
{
unsigned int i,j;
Operation = t->Operation;
Coefficient = t->Coefficient;
Information_Vars.resize(2);
for(i = 0; i < t->Entropy_Of.size(); i++)
Entropy_Of.push_back(t->Entropy_Of[i]);
for(i = 0; i < t->Given_Vars.size(); i++)
Given_Vars.push_back(t->Given_Vars[i]);
for(i = 0; i < t->Information_Vars.size(); i++)
for(j = 0; j < t->Information_Vars[i].size(); j++)
Information_Vars[i].push_back(t->Information_Vars[i][j]);
Var = t->Var;
Constant = t->Constant;
}
Bound::Bound()
{
cp = '\0';
LHS = NULL;
Type = "";
RHS = 0;
}
Bound* Bound::Form_For_Printing() const
{
Bound* b;
unsigned int i;
// This will have a memory leak;
b = new Bound;
b->cp = cp;
b->Type = Type;
b->RHS = RHS;
b->LHS = new Expression(LHS);
if(b->LHS->Terms.size() && b->LHS->Terms.front()->Coefficient < 0)
{
for(i = 0; i < b->LHS->Terms.size(); i += 2)
b->LHS->Terms[i]->Coefficient *= -1;
if(b->Type == "<=")
b->Type = ">=";
else if(b->Type ==">=")
b->Type = "<=";
if(b->RHS != 0)
b->RHS *= -1;
}
b->LHS = b->LHS->Form_For_Printing();
return b;
}
Cmd_Line_Modifier::Cmd_Line_Modifier()
{
}
Cmd_Line_Modifier::Cmd_Line_Modifier(std::string k, char a, nlohmann::json jsn)
{
Key = k;
Action = a;
j = jsn;
}
// Keeping this minimal
Problem_Description::Problem_Description()
{
Clear();
Objective = NULL;
LP_display = 0; //false
}
// Utility function to call delete on every element of a vector.
template<typename T>
void Delete_Vector_Contents(vector<T>& vec)
{
unsigned int i;
for(i = 0; i < vec.size(); ++i)
delete vec[i];
}
// Delete all the things.
void Problem_Description::Delete_Everything()
{
Delete_Vector_Contents(All_Variables_V);
Delete_Vector_Contents(All_Terms_V);
Delete_Vector_Contents(All_Expression_V);
Delete_Vector_Contents(All_Bounds_V);
Delete_Vector_Contents(Dependencies);
Delete_Vector_Contents(Independences);
Delete_Vector_Contents(Symmetries);
Delete_Vector_Contents(Cmd_Line_Modifiers);
// These two are already deleted in All_Expression_V
/* Delete_Vector_Contents(Queries); */
/* Delete_Vector_Contents(Sensitivities); */
}
// Just call Delete_Everything()
Problem_Description::~Problem_Description()
{
Delete_Everything();
}
// Delete, then clear
void Problem_Description::Clear()
{
Delete_Everything();
All_Variables_V.clear();
All_Variables_M.clear();
All_Expression_V.clear();
All_Bounds_V.clear();
All_Terms_V.clear();
RandomV.clear();
RandomM.clear();
AdditionalV.clear();
AdditionalM.clear();
Dependencies.clear();
Independences.clear();
Constant_Bounds.clear();
Bounds_To_Prove.clear();
Symmetries.clear();
Queries.clear();
Sensitivities.clear();
Equivalences2d.clear();
Cmd_Line_Modifiers.clear();
}
// Check whether the symmetry relation input forms a group.
void Problem_Description::Check_Symmetry_Group() const
{
unsigned int i, j, k;
char buf[20];
string key;
nlohmann::json ej;
vector <int> sequence;
if (Symmetries.size())
{
sequence.resize(RandomV.size());
// Current permutation is the ith row.
for(i = 1; i < Symmetries.size(); i++)
{
/* cout << i << endl; */
// Permute jth row using ith row.
for(j = 0; j < Symmetries.size(); j++)
{
key = "";
for(k = 0; k < RandomV.size(); k++) {
sequence[k] = Symmetries[j]->Order[Symmetries[i]->Order[k]->Index]->Index;
sprintf(buf, "%d ", sequence[k]);
key += buf;
}
if (SymmetryM.find(key) == SymmetryM.end()) {
ej = json::array();
for (k = 0; k < sequence.size(); k++) {
ej.push_back(RandomV[sequence[k]]->Name);
}
throw SRE((string) "Bad Symmetry -- missing permutation " + ej.dump());
}
}
}
}
fprintf(stdout,"Symmetries have been successfully checked.\n");
}
// Variables must be alphanumeric and can't start with a numeral
void Problem_Description::Check_Valid_Variable_Name(const std::string& s)
{
if(!s.size())
throw SRE((string) "Problem_Description::Is_Valid_Variable_Name(): Variable name has size zero.");
if(s.find_first_not_of(LegalChars_Variables) != std::string::npos)
throw SRE((string) "Problem_Description::Is_Valid_Variable_Name(): Variable name isn't alphanumeric. s = \"" + s + (string) "\"");
if(IllegalBeginningChars_Variables.find(s[0]) != std::string::npos)
throw SRE((string) "Problem_Description::Is_Valid_Variable_Name(): Variable name starts with an illegal starting (but otherwise legal) character. s = \"" + s + (string) "\"");
if(All_Variables_M.count(s))
throw SRE((string) "Problem_Description::Is_Valid_Variable_Name(): Variable \"" + s + (string) "\" already exists.");
}
nlohmann::json Variable::As_Json() const
{
nlohmann::json j;
j = Name;
return j;
}
nlohmann::json Term::As_Json() const
{
nlohmann::json j;
nlohmann::json j2;
unsigned int i;
if(Operation == "+" || Operation == "-")
{
j = Operation;
return j;
}
else if(Operation == "C")
{
j = Constant;
return j;
}
else if(Operation == "V")
{
if(Coefficient == 1)
{
j = Var->As_Json();
return j;
}
else
{
j = nlohmann::json::array();
j.push_back(Coefficient);
j.push_back(Var->As_Json());
return j;
}
}
else if(Operation == "H")
{
j = nlohmann::json::array();
j.push_back("H");
j2 = nlohmann::json::array();
for(i = 0; i < Entropy_Of.size(); i++)
j2.push_back(Entropy_Of[i]->As_Json());
j.push_back(j2);
j2 = nlohmann::json::array();
for(i = 0; i < Given_Vars.size(); i++)
j2.push_back(Given_Vars[i]->As_Json());
j.push_back(j2);
if(Coefficient == 1)
return j;
else
{
j2 = nlohmann::json::array();
j2.push_back(Coefficient);
j2.push_back(j);
return j2;
}
}
else if(Operation == "I")
{
j = nlohmann::json::array();
j.push_back("I");
j2 = nlohmann::json::array();
for(i = 0; i < Information_Vars.at(0).size(); i++)
j2.push_back(Information_Vars.at(0).at(i)->As_Json());
j.push_back(j2);
j2 = nlohmann::json::array();
for(i = 0; i < Information_Vars.at(1).size(); i++)
j2.push_back(Information_Vars.at(1).at(i)->As_Json());
j.push_back(j2);
j2 = nlohmann::json::array();
for(i = 0; i < Given_Vars.size(); i++)
j2.push_back(Given_Vars.at(i)->As_Json());
j.push_back(j2);
if(Coefficient == 1)
return j;
else
{
j2 = nlohmann::json::array();
j2.push_back(Coefficient);
j2.push_back(j);
return j2;
}
}
else
throw SRE((string) "Term::As_Json(): Somehow a Term happened to have an operation not in {\"+\",\"-\",\"C\",\"V\",\"H\"}. Operation = " + Operation);
}
Expression::Expression()
{
}
Expression::Expression(Expression* old)
{
for(unsigned int i = 0; i < old->Terms.size(); i++)
Terms.push_back(new Term(old->Terms[i]));
}
nlohmann::json Expression::As_Json() const
{
nlohmann::json j;
unsigned int i;
j = nlohmann::json::array();
for(i = 0; i < Terms.size(); i++)
j.push_back(Terms[i]->As_Json());
return j;
}
Expression* Expression::Form_For_Printing()
{
Expression* exp;
unsigned int i;
exp = new Expression;
// Adding this line removes a memory leak but makes a lot of disgusting changes
/* All_Expression_V.push_back(exp); */
for(i = 0; i < Terms.size(); i++)
exp->Terms.push_back(new Term(Terms[i]));
for(i = 0; i < exp->Terms.size() - 1; i++)
if(exp->Terms[i]->Operation == "+" && exp->Terms[i+1]->Coefficient < 0)
{
exp->Terms[i]->Operation = "-";
exp->Terms[i+1]->Coefficient *= -1;
}
return exp;
}
nlohmann::json Dependency::As_Json() const
{
nlohmann::json j;
unsigned int i;
j["dependent"] = nlohmann::json::array();
for(i = 0; i < Dependent_Vars.size(); i++)
j["dependent"].push_back(Dependent_Vars[i]->As_Json());
j["given"] = nlohmann::json::array();
for(i = 0; i < Given_Vars.size(); i++)
j["given"].push_back(Given_Vars[i]->As_Json());
return j;
}
nlohmann::json Independence::As_Json() const
{
nlohmann::json j;
nlohmann::json j1;
unsigned int i;
unsigned int k;
j["independent"] = nlohmann::json::array();
for(i = 0; i < Independent_Vars_Vecs.size(); i++)
{
if(Independent_Vars_Vecs[i].size() == 1)
j["independent"].push_back(Independent_Vars_Vecs[i].front()->As_Json());
else
{
j1 = nlohmann::json::array();
for(k = 0; k < Independent_Vars_Vecs[i].size(); k++)
j1.push_back(Independent_Vars_Vecs[i][k]->As_Json());
j["independent"].push_back(j1);
}
}
j["given"] = nlohmann::json::array();
for(i = 0; i < Given_Vars.size(); i++)
j["given"].push_back(Given_Vars[i]->As_Json());
return j;
}
nlohmann::json Bound::As_Json() const
{
nlohmann::json j;
nlohmann::json jtmp;
Bound* b;
b = Form_For_Printing();
j["LHS"] = b->LHS->As_Json();
jtmp = b->Type;
j["type"] = jtmp;
jtmp = b->RHS;
j["RHS"] = jtmp;
return j;
}
nlohmann::json Symmetry::As_Json() const
{
nlohmann::json j;
unsigned int i;
j = nlohmann::json::array();
for(i = 0; i < Order.size(); i++)
j.push_back(Order[i]->As_Json());
return j;
}
nlohmann::json Problem_Description::As_Json()
{
nlohmann::json j;
nlohmann::json j2;
unsigned int i;
unsigned int k;
j["RV"] = nlohmann::json::array();
for(i = 0; i < RandomV.size(); i++)
j["RV"].push_back(RandomV[i]->As_Json());
j["AL"] = nlohmann::json::array();
for(i = 0; i < AdditionalV.size(); i++)
j["AL"].push_back(AdditionalV[i]->As_Json());
if(Objective != NULL)
j["O"] = Expression_Json_To_String(Objective->Form_For_Printing()->As_Json());
j["D"] = nlohmann::json::array();
for(i = 0; i < Dependencies.size(); i++)
j["D"].push_back(Dependencies[i]->As_Json());
j["I"] = nlohmann::json::array();
for(i = 0; i < Independences.size(); i++)
j["I"].push_back(Independences[i]->As_Json());
j["S"] = nlohmann::json::array();
for(i = 0; i < Symmetries.size(); i++)
j["S"].push_back(Symmetries[i]->As_Json());
j["EQ"] = nlohmann::json::array();
for(i = 0; i < Equivalences2d.size(); i++)
{
j2 = nlohmann::json::array();
for(k = 0; k < Equivalences2d[i].size(); ++k)
j2.push_back(Equivalences2d[i][k]);
j["EQ"].push_back(j2);
}
j["BC"] = nlohmann::json::array();
for(i = 0; i < Constant_Bounds.size(); i++)
j["BC"].push_back(Bound_Json_To_String(Constant_Bounds[i]->As_Json()));
j["BP"] = nlohmann::json::array();
for(i = 0; i < Bounds_To_Prove.size(); i++)
j["BP"].push_back(Bound_Json_To_String(Bounds_To_Prove[i]->As_Json()));
// sensitivity analysis: each can be any linear combinations of the information measures and additional LP variables
j["SE"] = nlohmann::json::array();
for (i = 0; i < Sensitivities.size(); i++)
j["SE"].push_back(Expression_Json_To_String(Sensitivities[i]->As_Json()));
//Queries: each can be any linear combinations of the information measures and additional LP variables
j["QU"] = nlohmann::json::array();
for (i = 0; i < Queries.size(); i++)
j["QU"].push_back(Expression_Json_To_String(Queries[i]->As_Json()));
return j;
}
void Variable::From_Json(const nlohmann::json &j)
{
if(!j.is_string())
throw SRE((string) "Variable::From_Json(): j isn't a string. j = \n" + j.dump(4));
Name = static_cast<std::string const&>(j);
}
void Term::From_Json(const nlohmann::json& j, const std::map<std::string,Variable*>& All_Variables_M)
{
std::string s;
std::map<std::string, Variable*>::const_iterator mit;
nlohmann::json jeo;
nlohmann::json jg;
nlohmann::json::const_iterator jit;
if(j.is_string())
{
s = static_cast<std::string const&>(j);
if(s == "+" || s == "-")
Operation = s;
else
{
if((mit = All_Variables_M.find(s)) == All_Variables_M.end())
throw SRE((string) "Term::From_Json(): Unrecognized variable json. j = \n" + j.dump(4));
if(mit->second->RL != 'L')
throw SRE((string) "Term::From_Json(): Trying to use an RV as a term; only ALs allowed. j = \n" + j.dump(4));
Operation = "V";
Var = mit->second;
Coefficient = 1;
}
}
else if(j.is_number())
{
Operation = "C";
Constant = j;
}
else if(j.is_array() && j.size())
{
if(j.at(0).is_string())
{
if(j.at(0) == "H")
{
if(j.size() < 2 || !j.at(1).is_array() || (j.size() == 3 && !j.at(2).is_array()) || j.size() > 3)
throw SRE((string) "Term::From_Json(): Term is an entropy term but isn't of the form [\"H\",[],[]]. j = \n" + j.dump(4));
Operation = "H";
jeo = j.at(1);
if(!jeo.size())
throw SRE((string) "Term::From_Json(): Entropy term without anything left of the |. j = \n" + j.dump(4));
for(jit = jeo.begin(); jit != jeo.end(); ++jit)
{
if(!(*jit).is_string())
throw SRE((string) "Term::From_Json(): There's an entropy entry that's not a string. j = \n" + j.dump(4));
s = static_cast<std::string const&>(*jit);
if((mit = All_Variables_M.find(s)) == All_Variables_M.end())
throw SRE((string) "Term::From_Json(): Unrecognized variable json. j = \n" + j.dump(4));
if(mit->second->RL != 'R')
throw SRE((string) "Term::From_Json(): Trying to use an AL in an entropy term; only RVs allowed. j = \n" + j.dump(4));
Entropy_Of.push_back(mit->second);
}
if(j.size() == 3)
{
jg = j.at(2);
for(jit = jg.begin(); jit != jg.end(); ++jit)
{
if(!(*jit).is_string())
throw SRE((string) "Term::From_Json(): There's an entropy entry that's not a string. j = \n" + j.dump(4));
s = static_cast<std::string const&>(*jit);
if((mit = All_Variables_M.find(s)) == All_Variables_M.end())
throw SRE((string) "Term::From_Json(): Unrecognized variable json. j = \n" + j.dump(4));
if(mit->second->RL != 'R')
throw SRE((string) "Term::From_Json(): Trying to use an AL in an entropy term; only RVs allowed. j = \n" + j.dump(4));
Given_Vars.push_back(mit->second);
}
}
}
else if(j.at(0) == "I")
{
if(j.size() < 3 || !j.at(1).is_array() || !j.at(2).is_array() || (j.size() == 4 && !j.at(3).is_array()) || j.size() > 4)
throw SRE((string) "Expression_Json_To_String(): Term is an information term but isn't of the form [\"I\",[],[],[]]. j = \n" + j.dump(4));
Operation = "I";
Information_Vars.resize(2);
jeo = j.at(1);
if(!jeo.size())
throw SRE((string) "Term::From_Json(): Information term with empty 2nd element (ie nothing left of ;). j = \n" + j.dump(4));
for(jit = jeo.begin(); jit != jeo.end(); ++jit)
{
if(!(*jit).is_string())
throw SRE((string) "Term::From_Json(): There's an information entry that's not a string. j = \n" + j.dump(4));
s = static_cast<std::string const&>(*jit);
if((mit = All_Variables_M.find(s)) == All_Variables_M.end())
throw SRE((string) "Term::From_Json(): Unrecognized variable json. j = \n" + j.dump(4));
if(mit->second->RL != 'R')
throw SRE((string) "Term::From_Json(): Trying to use an AL in an information term; only RVs allowed. j = \n" + j.dump(4));
Information_Vars[0].push_back(mit->second);
}
jeo = j.at(2);
if(!jeo.size())
throw SRE((string) "Term::From_Json(): Information term with empty 3rd element (ie nothing right of ;). j = \n" + j.dump(4));
for(jit = jeo.begin(); jit != jeo.end(); ++jit)
{
if(!(*jit).is_string())
throw SRE((string) "Term::From_Json(): There's an information entry that's not a string. j = \n" + j.dump(4));
s = static_cast<std::string const&>(*jit);
if((mit = All_Variables_M.find(s)) == All_Variables_M.end())
throw SRE((string) "Term::From_Json(): Unrecognized variable json. j = \n" + j.dump(4));
if(mit->second->RL != 'R')
throw SRE((string) "Term::From_Json(): Trying to use an AL in an information term; only RVs allowed. j = \n" + j.dump(4));
Information_Vars[1].push_back(mit->second);
}
if(j.size() == 4)
{
jg = j.at(3);
for(jit = jg.begin(); jit != jg.end(); ++jit)
{
if(!(*jit).is_string())
throw SRE((string) "Term::From_Json(): There's an entropy entry that's not a string. j = \n" + j.dump(4));
s = static_cast<std::string const&>(*jit);
if((mit = All_Variables_M.find(s)) == All_Variables_M.end())
throw SRE((string) "Term::From_Json(): Unrecognized variable json. j = \n" + j.dump(4));
if(mit->second->RL != 'R')
throw SRE((string) "Term::From_Json(): Trying to use an AL in an information term; only RVs allowed. j = \n" + j.dump(4));
Given_Vars.push_back(mit->second);
}
}
}
else
{
throw SRE((string) "Term::From_Json(): Term is an array starting with a string that isn't \"H\" or \"I\". j = \n" + j.dump(4));
}
}
else if(j.at(0).is_number())
{
if(j.size() != 2)
throw SRE((string) "Term::From_Json(): j = \n" + j.dump(4));
if(j.at(1).is_string() && (j.at(1) == "+" || j.at(1) == "-"))
throw SRE((string) "Term::From_Json(): There's a term which is just a coefficient before a \"+\" or a \"-\". j = \n" + j.dump(4));
if(j.at(1).is_array() || j.at(1).is_string())
{
From_Json(j.at(1), All_Variables_M);
Coefficient = j.at(0);
}
else
throw SRE((string) "Term::From_Json(): There's a term which is a coefficient followed by something that's not a string or an array. j = \n" + j.dump(4));
}
else
throw SRE((string) "Term::From_Json(): Term is an array that doesn't start with a number or with \"H\". j = \n" + j.dump(4));
}
else
throw SRE((string) "Term::From_Json(): Term isn't a string, array with positive size, or number. j = \n" + j.dump(4));
}
void Expression::From_Json(const nlohmann::json& j, std::vector<Term*>& All_Terms_V, const std::map<std::string,Variable*>& All_Variables_M)
{
nlohmann::json::const_iterator jit;
Term* t;
unsigned int i;
if(!j.is_array())
throw SRE((string) "Expression::From_Json(): j is not an array. j = \n" + j.dump(4));
if((j.size() % 2) != 1)
throw SRE((string) "Expression::From_Json(): j has even size. Size should be odd; every other field should be \"+\" or \"-\". j = \n" + j.dump(4));
for(jit = j.begin(); jit != j.end(); ++jit)
{
t = new Term;
t->From_Json(*jit, All_Variables_M);
Terms.push_back(t);
All_Terms_V.push_back(t);
}
for(i = 0; i < Terms.size(); i++)
{
if((i % 2 == 0 && (Terms[i]->Operation == "-" || Terms[i]->Operation == "+"))
|| (i % 2 == 1 && (Terms[i]->Operation != "-" && Terms[i]->Operation != "+")))
throw SRE((string) "Expression::From_Json(): This Expression doesn't contain \"+\" and \"-\" in (only) every odd-numbered slot (0-indexed). j = \n" + j.dump(4));
if(Terms[i]->Operation == "-")
{
Terms[i+1]->Coefficient *= -1;
Terms[i]->Operation = "+";
}
}
}
void From_Json_Array_To_Variable_Vector(const nlohmann::json& j, std::vector<Variable*>& vec, const std::map<std::string, Variable*>& VarMap)
{
nlohmann::json::const_iterator it;
set<Variable*> s;
if(!j.is_array())
throw SRE((string) "From_Json_Array_To_Variable_Vector(): j isn't an array. j = \n" + j.dump(4));
for(it = j.begin(); it != j.end(); ++it)
{
if(!(*it).is_string())
throw SRE((string) "From_Json_Array_To_Variable_Vector(): element of j isn't a string. j = \n" + j.dump(4) + (string) "\nelement = \n" + (*it).dump(4));
if(VarMap.find(*it) == VarMap.end())
throw SRE((string) "From_Json_Array_To_Variable_Vector(): j contains variable " + (*it).dump(4) + (string) " which isn't found. j = \n" + j.dump(4));
vec.push_back(VarMap.find(*it)->second);
}
// Make sure nothing's repeated.
for(unsigned int i = 0; i < vec.size(); i++)
s.insert(vec[i]);
if(vec.size() != s.size())
throw SRE((string) "From_Json_Array_To_Variable_Vector(): There's a repeated Variable here. j = \n" + j.dump(4));
}
void From_Json_Array_To_Variable_Vector_Ind(const nlohmann::json& j, std::vector<std::vector<Variable*> >& vec, const std::map<std::string, Variable*>& VarMap)
{
nlohmann::json::const_iterator it;
nlohmann::json::const_iterator it2;
if(!j.is_array())
throw SRE((string) "From_Json_Array_To_Variable_Vector(): j isn't an array. j = \n" + j.dump(4));
for(it = j.begin(); it != j.end(); ++it)
{
vec.resize(vec.size() + 1);
if((*it).is_string())
{
if(VarMap.find(*it) == VarMap.end())
throw SRE((string) "From_Json_Array_To_Variable_Vector(): j contains variable " + (*it).dump(4) + (string) " which isn't found. j = \n" + j.dump(4));
vec.back().push_back(VarMap.find(*it)->second);
}
else if((*it).is_array())
{
for(it2 = (*it).begin(); it2 != (*it).end(); ++it2)
{
if(VarMap.find(*it2) == VarMap.end())
throw SRE((string) "From_Json_Array_To_Variable_Vector(): j contains variable " + (*it2).dump(4) + (string) " which isn't found. j = \n" + j.dump(4));
vec.back().push_back(VarMap.find(*it2)->second);
}
}
else
{
throw SRE((string) "From_Json_Array_To_Variable_Vector(): element of j isn't a string or an array. j = \n" + j.dump(4) + (string) "\nelement = \n" + (*it).dump(4));
}
}
}
void Check_All_Vars_RV(const std::vector<Variable*>& vec, std::string Calling_Function_Name, const nlohmann::json& j)
{
for(unsigned int i = 0; i < vec.size(); i++)
if(vec[i]->RL != 'R')
throw SRE(Calling_Function_Name + vec[i]->Name + " isn't an RV. j = \n" + j.dump(4));
}
void Check_All_Vars_RV_Ind(const std::vector<std::vector<Variable*> >& vec, std::string Calling_Function_Name, const nlohmann::json& j)
{
for(unsigned int i = 0; i < vec.size(); i++)
for(unsigned int k = 0; j < vec[i].size(); k++)
if(vec[i][k]->RL != 'R')
throw SRE(Calling_Function_Name + vec[i][k]->Name + " isn't an RV. j = \n" + j.dump(4));
}
void Dependency::From_Json(const nlohmann::json &j, const std::map<std::string, Variable*>& All_Variables_M)
{
if(!j.is_object())
throw SRE((string) "Dependency::From_Json(): j is not an object. j = \n" + j.dump(4));
if(j.find("dependent") == j.end() || j.find("given") == j.end())
throw SRE((string) "Dependency::From_Json(): j isn't of the form {\"dependent\" : [] , \"given\" : []}. j = \n" + j.dump(4));
From_Json_Array_To_Variable_Vector(j["dependent"], Dependent_Vars, All_Variables_M);
From_Json_Array_To_Variable_Vector(j["given"], Given_Vars, All_Variables_M);
if(!Dependent_Vars.size() || !Given_Vars.size())
throw SRE((string) "Dependency::From_Json(): Dependency has either no dependent or no given. Neither list can have size 0. j = \n" + j.dump(4));
Check_All_Vars_RV(Dependent_Vars, "Dependency::From_Json(): ", j);
Check_All_Vars_RV(Given_Vars, "Dependency::From_Json(): ", j);
}
void Independence::From_Json(const nlohmann::json &j, const std::map<std::string, Variable*>& All_Variables_M)
{
if(!j.is_object())
throw SRE((string) "Independence::From_Json(): j is not an object. j = \n" + j.dump(4));
if(j.find("independent") == j.end() || j.find("given") == j.end())
throw SRE((string) "Independence::From_Json(): j isn't of the form {\"independent\" : [] , \"given\" : []}. j = \n" + j.dump(4));
From_Json_Array_To_Variable_Vector_Ind(j["independent"], Independent_Vars_Vecs, All_Variables_M);
From_Json_Array_To_Variable_Vector(j["given"], Given_Vars, All_Variables_M);
if(Independent_Vars_Vecs.size() < 2)
throw SRE((string) "Independency::From_Json(): Independence has independent list of size less than 2. j = \n" + j.dump(4));
Check_All_Vars_RV_Ind(Independent_Vars_Vecs, "Independence::From_Json(): ", j);
Check_All_Vars_RV(Given_Vars, "Independence::From_Json(): ", j);
}
void Bound::From_Json(const nlohmann::json& j, std::vector<Term*>& All_Terms_V, const std::map<std::string,Variable*>& All_Variables_M)
{
unsigned int i;
if(!j.is_object())
throw SRE((string) "Bound::From_Json(): j is not an object. j = \n" + j.dump(4));
if(j.find("LHS") == j.end() || j.find("type") == j.end() || j.find("RHS") == j.end())
throw SRE((string) "Bound::From_Json(): j isn't of the form {\"LHS\" : [] , \"type\" : \"\" , \"RHS\" : number}. j = \n" + j.dump(4));
LHS = new Expression;
LHS->From_Json(j["LHS"], All_Terms_V, All_Variables_M);
if(!j["type"].is_string())
throw SRE((string) "Bound::From_Json(): j[\"type\"] isn't a string. j = \n" + j.dump(4));
Type = static_cast<std::string const&>(j["type"]);
if(Type != "<=" && Type != "=" && Type != ">=")
throw SRE((string) "Bound::From_Json(): Type must be in {\"<=\",\"=\",\">=\"}. j = \n" + j.dump(4));
if(!j["RHS"].is_number())
throw SRE((string) "Bound::From_Json(): RHS isn't a number. j = \n" + j.dump(4));
RHS = j["RHS"];
// For compatability with C_Style, change all <= to >=
if(Type == "<=")
{
Type = ">=";
for(i = 0; i < LHS->Terms.size(); i++)
if(LHS->Terms[i]->Operation != "+" && LHS->Terms[i]->Operation != "-")
LHS->Terms[i]->Coefficient *= -1;
if(RHS != 0)
RHS *= -1;
}
}
void Symmetry::From_Json(const nlohmann::json &j, const std::map<std::string, Variable*>& RandomM)
{
if(!j.is_array())
throw SRE((string) "Symmetry::From_Json(): j is not an array. j = \n" + j.dump(4));
From_Json_Array_To_Variable_Vector(j, Order, RandomM);
if(Order.size() != RandomM.size())
throw SRE((string) "Symmetry::From_Json(): Symmetry size doesn't equal number or RVs. j = \n" + j.dump(4));
}
void Problem_Description::From_Json(const nlohmann::json &j)
{
if(!j.is_object())
throw SRE((string) "Problem_Description::From_Json(): j is not a json::object. j = \n" + j.dump(4));
// Make sure all keys are valid
for(nlohmann::json::const_iterator it = j.begin(); it != j.end(); ++it)
{
if(it.key() != "RV"
&& it.key() != "AL"
&& it.key() != "O"
&& it.key() != "D"
&& it.key() != "I"
&& it.key() != "S"
&& it.key() != "BC"
&& it.key() != "BP"
&& it.key() != "EQ"
&& it.key() != "QU"
&& it.key() != "SE"
&& it.key() != "CMD"
&& it.key() != "OPT"
)
throw SRE("Problem_Description::From_Json(): Bad key: " + static_cast<std::string const&>(it.key()));
}
if(j.find("RV") != j.end())
Key_RV(j["RV"]);
if(j.find("AL") != j.end())
Key_AL(j["AL"]);
if(j.find("O") != j.end())
Key_O(j["O"]);
if(j.find("D") != j.end())
Key_D(j["D"]);
if(j.find("I") != j.end())
Key_I(j["I"]);
if(j.find("S") != j.end())
Key_S(j["S"]);
if(j.find("BC") != j.end())
Key_BC(j["BC"]);
if(j.find("BP") != j.end())
Key_BP(j["BP"]);
if(j.find("EQ") != j.end())
Key_EQ(j["EQ"]);
if(j.find("QU") != j.end())
Key_QU(j["QU"]);
if(j.find("SE") != j.end())
Key_SE(j["SE"]);
if(j.find("CMD") != j.end())
Cmd_Line_Modifiers.push_back(new Cmd_Line_Modifier("CMD",'+',j["CMD"]));
if(j.find("OPT") != j.end())
Cmd_Line_Modifiers.push_back(new Cmd_Line_Modifier("CMD",'+',j["OPT"]));
Check_Equivalence();
}
void Problem_Description::Key_RV(const nlohmann::json& j)
{
nlohmann::json::const_iterator it;
Variable* v;
if(RandomV.size())
throw SRE("Key_RV(): Only one command allowed per type. Multiple RV commands found.");
if(!j.is_array())
throw SRE((string) "Problem_Description::Key_RV(): j isn't an array. j = \n" + j.dump(4));
for(it = j.begin(); it != j.end(); ++it)
{
v = new Variable;
v->From_Json(*it);
Check_Valid_Variable_Name(v->Name);
v->RL = 'R';
All_Variables_V.push_back(v);
All_Variables_M[v->Name] = v;
v->Index = RandomV.size();
RandomV.push_back(v);
RandomM[v->Name] = v;
}
}
void Problem_Description::Key_AL(const nlohmann::json& j)
{
nlohmann::json::const_iterator it;
Variable* v;
if(AdditionalV.size())
throw SRE("Key_AL(): Only one command allowed per type. Multiple AL commands found.");
if(!j.is_array())
throw SRE((string) "Problem_Description::Key_AL(): j isn't an array. j = \n" + j.dump(4));
for(it = j.begin(); it != j.end(); ++it)
{
v = new Variable;
v->From_Json(*it);
Check_Valid_Variable_Name(v->Name);
v->RL = 'L';
All_Variables_V.push_back(v);
All_Variables_M[v->Name] = v;
v->Index = AdditionalV.size();
AdditionalV.push_back(v);
AdditionalM[v->Name] = v;
}
}
void Problem_Description::Key_O(const nlohmann::json& j)
{
nlohmann::json j1;
std::string s;
if(Objective)
throw SRE("Key_O(): Only one command allowed per type. Multiple O commands found.");
Objective = new Expression;
if(j.is_string())
{
s = static_cast<std::string const&>(j);
j1 = Expression_String_To_Json(s);
Objective->From_Json(j1, All_Terms_V, All_Variables_M);
}
else
{
Objective->From_Json(j, All_Terms_V, All_Variables_M);
}
All_Expression_V.push_back(Objective);
}
void Problem_Description::Key_D(const nlohmann::json& j)
{
nlohmann::json::const_iterator it;
Dependency* d;
if(Dependencies.size())
throw SRE("Key_D(): Only one command allowed per type. Multiple D commands found.");
if(!j.is_array())
throw SRE((string) "Problem_Description::Key_D(): j isn't an array. j = \n" + j.dump(4));
for(it = j.begin(); it != j.end(); ++it)
{
d = new Dependency;
d->From_Json(*it, All_Variables_M);
Dependencies.push_back(d);
}
}
void Problem_Description::Key_I(const nlohmann::json& j)
{
nlohmann::json::const_iterator it;
Independence* ind;
if(Independences.size())
throw SRE("Key_I(): Only one command allowed per type. Multiple I commands found.");
if(!j.is_array())
throw SRE((string) "Problem_Description::Key_I(): j isn't an array. j = \n" + j.dump(4));
for(it = j.begin(); it != j.end(); ++it)
{
ind = new Independence;
ind->From_Json(*it, All_Variables_M);
Independences.push_back(ind);
}
}
void Problem_Description::Check_First_Symmetry_Matches_RV_List()
{
for(unsigned int i = 0; i < Symmetries[0]->Order.size(); ++i)
if(Symmetries[0]->Order[i] != RandomV[i])
throw SRE("Problem_Description::Check_First_Symmetry_Matches_RV_List(): The first symmetry listed isn't a copy of the RV line.");
}
void Problem_Description::Key_S(const nlohmann::json& j)
{
nlohmann::json::const_iterator it;
Symmetry* s;
char buf[20];
size_t i;
if(Symmetries.size())
throw SRE("Key_S(): Only one command allowed per type. Multiple S commands found.");
if(!j.is_array())
throw SRE((string) "Problem_Description::Key_S(): j isn't an array. j = \n" + j.dump(4));
for(it = j.begin(); it != j.end(); ++it)
{
s = new Symmetry;
s->From_Json(*it, RandomM);
Symmetries.push_back(s);
for (i = 0; i < s->Order.size(); i++) {
sprintf(buf, "%d ", s->Order[i]->Index);
s->Key += buf;
}
if (SymmetryM.find(s->Key) != SymmetryM.end())
throw SRE((string) "Problem_Description::Duplicate Symmetry " + it->dump());
SymmetryM[s->Key] = s;
}
if(Symmetries.size())
{
Check_First_Symmetry_Matches_RV_List();
/* Check_Symmetry_Group(); */
}
}
void Problem_Description::Key_EQ(const nlohmann::json& j)
{
if(Equivalences2d.size())
throw SRE("Key_EQ(): Only one command allowed per type. Multiple EQ commands found.");
if(!j.is_array())
throw SRE("Key_EQ(): Needs to be an array of arrays of strings. j = " + j.dump(4));
for(nlohmann::json::const_iterator it = j.begin(); it != j.end(); ++it)
{
if(!(*it).is_array())
throw SRE("Key_EQ(): Needs to be an array of arrays of strings. j = " + j.dump(4));
Equivalences2d.resize(Equivalences2d.size() + 1);
for(nlohmann::json::const_iterator it2 = (*it).begin(); it2 != (*it).end(); ++it2)
{
if(!(*it2).is_string())
throw SRE("Key_EQ(): Needs to be an array of arrays of strings. j = " + j.dump(4));
Equivalences2d.back().push_back(*it2);
}
}
}
void Problem_Description::Key_BC(const nlohmann::json& j)
{
nlohmann::json::const_iterator it;
nlohmann::json j1;
std::string s;
Bound* b;
if(Constant_Bounds.size())
throw SRE("Key_BC(): Only one command allowed per type. Multiple BC commands found.");
if(!j.is_array())
throw SRE((string) "Problem_Description::Key_BC(): j isn't an array. j = \n" + j.dump(4));
for(it = j.begin(); it != j.end(); ++it)
{
b = new Bound;
if((*it).is_string())
{
s = static_cast<std::string const&>(*it);
j1 = Bound_String_To_Json(s);
}
else
{
j1 = *it;
}
b->From_Json(j1, All_Terms_V, All_Variables_M);
All_Bounds_V.push_back(b);
All_Expression_V.push_back(b->LHS);
b->cp = 'C';
Constant_Bounds.push_back(b);
}
}
void Problem_Description::Key_BP(const nlohmann::json& j)
{
nlohmann::json::const_iterator it;
nlohmann::json j1;
std::string s;
Bound* b;
if(Bounds_To_Prove.size())
throw SRE("Key_BP(): Only one command allowed per type. Multiple BP commands found.");
if(!j.is_array())
throw SRE((string) "Problem_Description::Key_BP(): j isn't an array. j = \n" + j.dump(4));
for(it = j.begin(); it != j.end(); ++it)
{
b = new Bound;
if((*it).is_string())
{
s = static_cast<std::string const&>(*it);
j1 = Bound_String_To_Json(s);
}
else
{
j1 = *it;
}
b->From_Json(j1, All_Terms_V, All_Variables_M);
All_Bounds_V.push_back(b);
All_Expression_V.push_back(b->LHS);
b->cp = 'P';
Bounds_To_Prove.push_back(b);
}
}
void Problem_Description::Key_QU(const nlohmann::json& j)
{
nlohmann::json::const_iterator it;
nlohmann::json j1;
std::string s;
Expression* e;
if (Queries.size())
throw SRE("Key_QU(): Only one command allowed per type. Multiple QU commands found.");
if (!j.is_array())
throw SRE((string)"Problem_Description::Key_QU(): j isn't an array. j = \n" + j.dump(4));
for (it = j.begin(); it != j.end(); ++it)
{
e = new Expression;
if ((*it).is_string())
{
s = static_cast<std::string const&>(*it);
j1 = Expression_String_To_Json(s);
}
else
{
j1 = *it;
}
e->From_Json(j1, All_Terms_V, All_Variables_M);
Queries.push_back(e);
All_Expression_V.push_back(e);
}
}
void Problem_Description::Key_SE(const nlohmann::json& j)
{
nlohmann::json::const_iterator it;
nlohmann::json j1;
std::string s;
Expression* e;
if (Sensitivities.size())
throw SRE("Key_SE(): Only one command allowed per type. Multiple SE commands found.");
if (!j.is_array())
throw SRE((string)"Problem_Description::Key_SE(): j isn't an array. j = \n" + j.dump(4));
for (it = j.begin(); it != j.end(); ++it)
{
e = new Expression;
if ((*it).is_string())
{
s = static_cast<std::string const&>(*it);
j1 = Expression_String_To_Json(s);
}
else
{
j1 = *it;
}
e->From_Json(j1, All_Terms_V, All_Variables_M);
Sensitivities.push_back(e);
All_Expression_V.push_back(e);
}
}
void Problem_Description::Get_Cmd_Line_Modifiers(char** argv, int argc, int startindex)
{
int i;
json j;
for(i = startindex; i < argc; i++)
{
try
{
j = json::parse(argv[i]);
}
catch(...)
{
throw SRE("Get_Cmd_Line_Modifiers(): Error parsing argv[" + std::to_string(i) + "] to json");
}
if(!j.is_object())
throw SRE("Get_Cmd_Line_Modifiers(): argv[" + std::to_string(i) + "] isn't a json object");
if(j.find("RV") != j.end())
{
if(!j["RV"].is_array()) throw SRE("Get_Cmd_Line_Modifiers(): argv[" + std::to_string(i) + "]'s RV's val should be an array");
Cmd_Line_Modifiers.push_back(new Cmd_Line_Modifier("RV",'R',j["RV"]));
}
if(j.find("+RV") != j.end())
{
if(!j["+RV"].is_array()) throw SRE("Get_Cmd_Line_Modifiers(): argv[" + std::to_string(i) + "]'s +RV's val should be an array");
Cmd_Line_Modifiers.push_back(new Cmd_Line_Modifier("RV",'+',j["+RV"]));
}
if(j.find("AL") != j.end())
{
if(!j["AL"].is_array()) throw SRE("Get_Cmd_Line_Modifiers(): argv[" + std::to_string(i) + "]'s AL's val should be an array");
Cmd_Line_Modifiers.push_back(new Cmd_Line_Modifier("AL",'R',j["AL"]));
}
if(j.find("+AL") != j.end())
{
if(!j["+AL"].is_array()) throw SRE("Get_Cmd_Line_Modifiers(): argv[" + std::to_string(i) + "]'s +AL's val should be an array");
Cmd_Line_Modifiers.push_back(new Cmd_Line_Modifier("AL",'+',j["+AL"]));
}
if(j.find("O") != j.end())
{
if(!j["O"].is_array() && !j["O"].is_string()) throw SRE("Get_Cmd_Line_Modifiers(): argv[" + std::to_string(i) + "]'s O's val should be an array or a string");
Cmd_Line_Modifiers.push_back(new Cmd_Line_Modifier("O",'R',j["O"]));
}
if(j.find("+O") != j.end())
{
throw SRE("Get_Cmd_Line_Modifiers(): Can't add an objective function, you can only replace it");
}
if(j.find("D") != j.end())
{
if(!j["D"].is_array()) throw SRE("Get_Cmd_Line_Modifiers(): argv[" + std::to_string(i) + "]'s D's val should be an array");
Cmd_Line_Modifiers.push_back(new Cmd_Line_Modifier("D",'R',j["D"]));
}
if(j.find("+D") != j.end())
{
if(!j["+D"].is_array()) throw SRE("Get_Cmd_Line_Modifiers(): argv[" + std::to_string(i) + "]'s +D's val should be an array");
Cmd_Line_Modifiers.push_back(new Cmd_Line_Modifier("D",'+',j["+D"]));
}
if(j.find("I") != j.end())
{
if(!j["I"].is_array()) throw SRE("Get_Cmd_Line_Modifiers(): argv[" + std::to_string(i) + "]'s I's val should be an array");
Cmd_Line_Modifiers.push_back(new Cmd_Line_Modifier("I",'R',j["I"]));
}
if(j.find("+I") != j.end())
{
if(!j["+I"].is_array()) throw SRE("Get_Cmd_Line_Modifiers(): argv[" + std::to_string(i) + "]'s +I's val should be an array");
Cmd_Line_Modifiers.push_back(new Cmd_Line_Modifier("I",'+',j["+I"]));
}
if(j.find("S") != j.end())
{
if(!j["S"].is_array()) throw SRE("Get_Cmd_Line_Modifiers(): argv[" + std::to_string(i) + "]'s S's val should be an array");
Cmd_Line_Modifiers.push_back(new Cmd_Line_Modifier("S",'R',j["S"]));
}
if(j.find("+S") != j.end())
{
if(!j["+S"].is_array()) throw SRE("Get_Cmd_Line_Modifiers(): argv[" + std::to_string(i) + "]'s +S's val should be an array");
Cmd_Line_Modifiers.push_back(new Cmd_Line_Modifier("S",'+',j["+S"]));
}
if(j.find("BC") != j.end())
{
if(!j["BC"].is_array()) throw SRE("Get_Cmd_Line_Modifiers(): argv[" + std::to_string(i) + "]'s BC's val should be an array");
Cmd_Line_Modifiers.push_back(new Cmd_Line_Modifier("BC",'R',j["BC"]));
}
if(j.find("+BC") != j.end())
{
if(!j["+BC"].is_array()) throw SRE("Get_Cmd_Line_Modifiers(): argv[" + std::to_string(i) + "]'s +BC's val should be an array");
Cmd_Line_Modifiers.push_back(new Cmd_Line_Modifier("BC",'+',j["+BC"]));
}
if(j.find("BP") != j.end())
{
if(!j["BP"].is_array()) throw SRE("Get_Cmd_Line_Modifiers(): argv[" + std::to_string(i) + "]'s BP's val should be an array");
Cmd_Line_Modifiers.push_back(new Cmd_Line_Modifier("BP",'R',j["BP"]));
}
if(j.find("+BP") != j.end())
{
if(!j["+BP"].is_array()) throw SRE("Get_Cmd_Line_Modifiers(): argv[" + std::to_string(i) + "]'s +BP's val should be an array");
Cmd_Line_Modifiers.push_back(new Cmd_Line_Modifier("BP",'+',j["+BP"]));
}
if(j.find("EQ") != j.end())
{
if(!j["EQ"].is_array()) throw SRE("Get_Cmd_Line_Modifiers(): argv[" + std::to_string(i) + "]'s EQ's val should be an array of arrays of strings");
Cmd_Line_Modifiers.push_back(new Cmd_Line_Modifier("EQ",'R',j["EQ"]));
}
if(j.find("+EQ") != j.end())
{
throw SRE("Get_Cmd_Line_Modifiers(): Only EQ allowed, no +EQ");
}
if(j.find("QU") != j.end())
{
if(!j["QU"].is_array()) throw SRE("Get_Cmd_Line_Modifiers(): argv[" + std::to_string(i) + "]'s QU's val should be an array");
Cmd_Line_Modifiers.push_back(new Cmd_Line_Modifier("QU",'R',j["QU"]));
}
if(j.find("+QU") != j.end())
{
if(!j["QU"].is_array()) throw SRE("Get_Cmd_Line_Modifiers(): argv[" + std::to_string(i) + "]'s QU's val should be an array");
Cmd_Line_Modifiers.push_back(new Cmd_Line_Modifier("QU",'+',j["QU"]));
}
if(j.find("SE") != j.end())
{
if(!j["SE"].is_array()) throw SRE("Get_Cmd_Line_Modifiers(): argv[" + std::to_string(i) + "]'s SE's val should be an array");
Cmd_Line_Modifiers.push_back(new Cmd_Line_Modifier("SE",'R',j["SE"]));
}
if(j.find("+SE") != j.end())
{
if(!j["SE"].is_array()) throw SRE("Get_Cmd_Line_Modifiers(): argv[" + std::to_string(i) + "]'s SE's val should be an array");
Cmd_Line_Modifiers.push_back(new Cmd_Line_Modifier("SE",'+',j["SE"]));
}
if(j.find("CMD") != j.end())
{
throw SRE("Get_Cmd_Line_Modifiers(): Only +CMD allowed, no CMD");
}
if(j.find("+CMD") != j.end())
{
if(!j["+CMD"].is_array()) throw SRE("Get_Cmd_Line_Modifiers(): argv[" + std::to_string(i) + "]'s +CMD's val should be an array");
Cmd_Line_Modifiers.push_back(new Cmd_Line_Modifier("CMD",'+',j["+CMD"]));
}
if (j.find("OPT") != j.end())
{
throw SRE("Get_Cmd_Line_Modifiers(): Only +OPT allowed, no OPT");
}
if (j.find("+OPT") != j.end())
{
if (!j["+OPT"].is_array()) throw SRE("Get_Cmd_Line_Modifiers(): argv[" + std::to_string(i) + "]'s +OPT's val should be an array");
Cmd_Line_Modifiers.push_back(new Cmd_Line_Modifier("OPT", '+', j["+OPT"]));
}
}
}
void Problem_Description::Run_Cmd_Line_Modifier_Commands()
{
unsigned int i;
string s;
Cmd_Line_Modifier* clm;
nlohmann::json::iterator it;
for(i = 0; i < Cmd_Line_Modifiers.size(); i++)
{
clm = Cmd_Line_Modifiers[i];
if(clm->Key == "CMD")
{
for(it = clm->j.begin(); it != clm->j.end(); ++it)
{
if(!(*it).is_string())
throw SRE("Problem_Description::Run_Cmd_Line_Modifier_Commands(): entry in +CMD isn't string");
s = static_cast<std::string const&>(*it);
if(s == "SER")
{
std::vector<std::string> sv;
sv.push_back("SER");
Command_SER(this,sv,0);
}
else if(s == "DESTROY")
{
throw SRE("Problem_Description::Run_Cmd_Line_Modifier_Commands(): DESTROY not allowed to be added with +CMD on command line");
}
else if(s == "PDC")
{
Problem_Description_C_Style* pdc = As_Problem_Description_C_Style();
Print_Problem_Description_C_Style(pdc);
}
else if(s == "DESER")
{
throw SRE("Problem_Description::Run_Cmd_Line_Modifier_Commands(): DESER not allowed to be added with +CMD on command line");
}
else if(s == "CS")
{
if(Symmetries.size())
Check_Symmetry_Group();
}
else if (s == "LP_DISP")
{
LP_display = 1;
}
}
}
}
}
void Problem_Description::Modify_Json_From_Cmd_Line_Before_From_Json(nlohmann::json& j)
{
unsigned int i;
Cmd_Line_Modifier* clm;
nlohmann::json::iterator it;
if(!j.is_object())
throw SRE("Problem_Description::Modify_Json_From_Cmd_Line_Before_From_Json(): j isn't object. j = \n" + j.dump(4));
for(i = 0; i < Cmd_Line_Modifiers.size(); i++)
{
clm = Cmd_Line_Modifiers[i];
if(clm->Key != "CMD")
{
if(clm->Action == 'R')
j[clm->Key] = clm->j;
else if(clm->Action == '+')
{
if(j.find(clm->Key) == j.end())
j[clm->Key] = nlohmann::json::array();
for(it = clm->j.begin(); it != clm->j.end(); ++it)
j[clm->Key].push_back(*it);
}
}
}
}
void Get_Expression_Into_Map(std::map<unsigned int, double>& pos_val_m, Expression* e, unsigned int numrvs)
{
unsigned int i;
unsigned int j;
unsigned int entropy_of_set;
unsigned int entropy_of_set_A;
unsigned int entropy_of_set_B;
unsigned int entropy_of_set_C;
unsigned int given_set;
std::map<unsigned int, double>::iterator mit;
std::map<unsigned int, double>::iterator mit2;
pos_val_m.clear();
for(i = 0; i < e->Terms.size(); i += 2)
{
if(e->Terms[i]->Operation == "H")
{
entropy_of_set = 0;
given_set = 0;
for(j = 0; j < e->Terms[i]->Entropy_Of.size(); j++)
entropy_of_set |= (1 << e->Terms[i]->Entropy_Of[j]->Index);
for(j = 0; j < e->Terms[i]->Given_Vars.size(); j++)
given_set |= (1 << e->Terms[i]->Given_Vars[j]->Index);
pos_val_m[entropy_of_set | given_set] += e->Terms[i]->Coefficient;
if(given_set)
pos_val_m[given_set] += (-1 * e->Terms[i]->Coefficient);
}
else if (e->Terms[i]->Operation == "I")
{
// I(A;B) = H(A) + H(B) - H(A,B)
// I(A;B|C) = H(A,C) + H(B,C) - H(C) - H(A,B,C)
// A = Information_Vars[0]
// B = Information_Vars[1]
// C = Given_Vars
if(e->Terms[i]->Information_Vars.size() != 2)
throw SRE("Get_Expression_Into_Map(): Somehow Information_Vars.size() != 2. (This exception should be impossible to hit.)");
entropy_of_set_A = 0;
for(j = 0; j < e->Terms[i]->Information_Vars[0].size(); j++)
entropy_of_set_A |= (1 << e->Terms[i]->Information_Vars[0][j]->Index);
entropy_of_set_B = 0;
for(j = 0; j < e->Terms[i]->Information_Vars[1].size(); j++)
entropy_of_set_B |= (1 << e->Terms[i]->Information_Vars[1][j]->Index);
entropy_of_set_C = 0;
for(j = 0; j < e->Terms[i]->Given_Vars.size(); j++)
entropy_of_set_C |= (1 << e->Terms[i]->Given_Vars[j]->Index);
// H(A,C)
pos_val_m[entropy_of_set_A | entropy_of_set_C] += e->Terms[i]->Coefficient;
// H(B,C)
pos_val_m[entropy_of_set_B | entropy_of_set_C] += e->Terms[i]->Coefficient;
// -H(C)
if(entropy_of_set_C)
pos_val_m[entropy_of_set_C] += (-1 * e->Terms[i]->Coefficient);
// -H(A,B,C)
pos_val_m[entropy_of_set_A | entropy_of_set_B | entropy_of_set_C] += (-1 * e->Terms[i]->Coefficient);
}
else if (e->Terms[i]->Operation == "V")
pos_val_m[(1 << numrvs) + e->Terms[i]->Var->Index] += e->Terms[i]->Coefficient;
else
throw SRE("Problem_Description::Get_Expression_Into_Map(): Somehow one of the terms in the Expression has Operation that isn't in {\"H\",\"V\"}.");
}
// Erase entries with coefficient 0.
// This sometimes is necessary when terms are combined.
for(mit = pos_val_m.begin(); mit != pos_val_m.end(); )
{
if(mit->second == 0)
{
mit2 = mit;
++mit;
pos_val_m.erase(mit2);
}
else
++mit;
}
}
void Get_Map_Into_C_Style_Expression(const std::map<unsigned int, double>& pos_val_m, unsigned int* list_pos, double* list_value)
{
unsigned int i = 0;
std::map<unsigned int, double>::const_iterator mit;
for(mit = pos_val_m.begin(); mit != pos_val_m.end(); ++mit,++i)
{
list_pos[i] = mit->first;
list_value[i] = mit->second;
}
}
// All 5 lists are size num_constantbounds
// numitems is as in the objective function
// list_pos is as in the objective function
// list_value is as in the objective function
// list_type is (int)0 for >= and (int)2 for =
// all <= are changed to >= with negation
// list_rhs is just a constant
void FillBounds(const std::vector<Bound*>& BoundVec, unsigned int** list_pos, double** list_value, char* list_type, double* list_rhs, int* list_num_items, unsigned int numrvs)
{
unsigned int i;
Bound* b;
std::map<unsigned int, double> pos_val_m;
for(i = 0; i < BoundVec.size(); i++)
{
b = BoundVec[i];
if(b->Type == ">=")
list_type[i] = 0;
else if(b->Type == "=")
list_type[i] = 2;
else
throw SRE((string) "FillBounds(): Somehow BoundVec[i]->Type isn't in {\"<=\",\">=\",\"=\"}, or, if \"<=\", it got past the part of the code that should've changed it to \">=\", . Type = " + b->Type);
list_rhs[i] = b->RHS;
Get_Expression_Into_Map(pos_val_m, b->LHS, numrvs);
list_num_items[i] = (int) pos_val_m.size();
list_pos[i] = (unsigned int*)calloc(list_num_items[i], sizeof(unsigned int));
list_value[i] = (double*)calloc(list_num_items[i], sizeof(double));
Get_Map_Into_C_Style_Expression(pos_val_m, list_pos[i], list_value[i]);
}
}
// All 3 lists are size num_constantbounds (very similar to FillBounds)
// numitems is as in the objective function
// list_pos is as in the objective function
// list_value is as in the objective function
void FillExpressions(const std::vector<Expression*>& ExoressionVec, unsigned int** list_pos, double** list_value, int* list_num_items, unsigned int numrvs)
{
unsigned int i;
Expression* b;
std::map<unsigned int, double> pos_val_m;
for (i = 0; i < ExoressionVec.size(); i++)
{
b = ExoressionVec[i];
Get_Expression_Into_Map(pos_val_m, b, numrvs);
list_num_items[i] = (int)pos_val_m.size();
list_pos[i] = (unsigned int*)calloc(list_num_items[i], sizeof(unsigned int));
list_value[i] = (double*)calloc(list_num_items[i], sizeof(double));
Get_Map_Into_C_Style_Expression(pos_val_m, list_pos[i], list_value[i]);
}
}
void Problem_Description::Check_Valid_For_C_Style()
{
if(RandomV.size() > MAXNUMVARS_C_STYLE)
throw SRE((string) "Check_Valid_For_C_Style(): RandomV.size() is " + std::to_string(RandomV.size()) + (string)" but it shouldn't be bigger than " + std::to_string(MAXNUMVARS_C_STYLE));
if(Independences.size() > MAXINDPITEMS_C_STYLE)
throw SRE((string) "Check_Valid_For_C_Style(): Independences.size() is " + std::to_string(Independences.size()) + (string)" but it shouldn't be bigger than " + std::to_string(MAXINDPITEMS_C_STYLE));
if(Objective)
for(unsigned int i = 0; i < Objective->Terms.size(); i++)
if(Objective->Terms[i]->Operation == "C")
throw SRE((string) "Check_Valid_For_C_Style(): The Objective funtion has a Term which is a Constant. That's not allowed when converting to C style.");
}
void Problem_Description::Print_Old_Format(std::ostream& fout)
{
unsigned int i;
unsigned int j;
unsigned int z;
Dependency* dep;
Independence* ind;
Symmetry* sym;
// RV
if(RandomV.size())
{
fout << "Random variables:" << endl;
fout << RandomV.front()->Name;
for(i = 1; i < RandomV.size(); i++)
fout << ", " << RandomV[i]->Name;
fout << endl << endl;
}
// AL
if(AdditionalV.size())
{
fout << "Additional LP variables:" << endl;
fout << AdditionalV.front()->Name;
for(i = 1; i < AdditionalV.size(); i++)
fout << ", " << AdditionalV[i]->Name;
fout << endl << endl;
}
// O
if(Objective)
{
fout << "Objective:" << endl;
fout << Expression_Json_To_String(Objective->Form_For_Printing()->As_Json());
fout << endl << endl;
}
// D
if(Dependencies.size())
{
fout << "Dependency:" << endl;
for(i = 0; i < Dependencies.size(); i++)
{
dep = Dependencies[i];
if(dep->Dependent_Vars.size() && dep->Given_Vars.size())
{
fout << dep->Dependent_Vars.front()->Name;
for(j = 1; j < dep->Dependent_Vars.size(); j++)
fout << "," << dep->Dependent_Vars[j]->Name;
fout << ": ";
fout << dep->Given_Vars.front()->Name;
for(j = 1; j < dep->Given_Vars.size(); j++)
fout << ", " << dep->Given_Vars[j]->Name;
fout << endl;
}
}
fout << endl << endl;
}
// I
if(Independences.size())
{
fout << "Conditional independence:" << endl;
for(i = 0; i < Independences.size(); i++)
{
ind = Independences[i];
if(ind->Independent_Vars_Vecs.size())
{
fout << ind->Independent_Vars_Vecs.front().front()->Name;
for(z = 1; z < ind->Independent_Vars_Vecs.front().size(); z++)
fout << "," << ind->Independent_Vars_Vecs.front()[z]->Name;
for(j = 1; j < ind->Independent_Vars_Vecs.size(); j++)
{
fout << ";";
fout << ind->Independent_Vars_Vecs[j].front()->Name;
for(z = 1; z < ind->Independent_Vars_Vecs[j].size(); z++)
fout << "," << ind->Independent_Vars_Vecs[j][z]->Name;
}
if(ind->Given_Vars.size())
{
fout << "|" << ind->Given_Vars.front()->Name;
for(j = 1; j < ind->Given_Vars.size(); j++)
fout << "," << ind->Given_Vars[j];
}
fout << endl;
}
}
fout << endl << endl;
}
// BC
if(Constant_Bounds.size())
{
fout << "Constant bounds:" << endl;
for(i = 0; i < Constant_Bounds.size(); i++)
fout << Bound_Json_To_String(Constant_Bounds[i]->Form_For_Printing()->As_Json()) << endl;
fout << endl << endl;
}
// S
if(Symmetries.size())
{
fout << "Symmetry:" << endl;
for(i = 0; i < Symmetries.size(); i++)
{
sym = Symmetries[i];
if(sym->Order.size())
{
fout << sym->Order.front()->Name;
for(j = 1; j < sym->Order.size(); j++)
fout << "," << sym->Order[j]->Name;
fout << endl;
}
}
fout << endl << endl;
}
// EQ
// Commented out because this will break the old tool
/* if(Equivalence != "")
{
fout << "Equivalence classes (not part of the old CAI tool)" << endl;
fout << Equivalence << endl;
fout << endl;
} */
if ( Queries.size())
{
fout << "Queries:" << endl;
for (i = 0; i < Queries.size(); i++)
fout << Expression_Json_To_String(Queries[i]->Form_For_Printing()->As_Json()) << endl;
fout << endl << endl;
}
if (Sensitivities.size())
{
fout << "Sensitivities:" << endl;
for (i = 0; i < Sensitivities.size(); i++)
fout << Expression_Json_To_String(Sensitivities[i]->Form_For_Printing()->As_Json()) << endl;
fout << endl << endl;
}
// BP
if(Bounds_To_Prove.size())
{
fout << "Bounds to prove:" << endl;
for(i = 0; i < Bounds_To_Prove.size(); i++)
fout << Bound_Json_To_String(Bounds_To_Prove[i]->Form_For_Printing()->As_Json()) << endl;
fout << endl << endl;
}
// end
fout << "end" << endl;
}
Problem_Description_C_Style* Problem_Description::As_Problem_Description_C_Style()
{
Problem_Description_C_Style* pdc;
unsigned int i;
unsigned int j;
unsigned int k;
unsigned int num_to_or;
std::map<unsigned int, double> pos_val_m;
Check_Valid_For_C_Style();
pdc = new Problem_Description_C_Style;
// RVs
// list_rvs is just a list of the names
pdc->num_rvs = RandomV.size();
if(RandomV.size())
{
pdc->list_rvs = (char**) calloc(pdc->num_rvs, sizeof(char*));
for(i = 0; i < RandomV.size(); i++)
{
pdc->list_rvs[i] = (char*) calloc(RandomV[i]->Name.size() + 1, sizeof(char));
strcpy(pdc->list_rvs[i], RandomV[i]->Name.c_str());
}
}
// ALs
// list_add_LPvars is just a list of the names
pdc->num_add_LPvars = AdditionalV.size();
if(AdditionalV.size())
{
pdc->list_add_LPvars = (char**) calloc(pdc->num_add_LPvars, sizeof(char*));
for(i = 0; i < AdditionalV.size(); i++)
{
pdc->list_add_LPvars[i] = (char*) calloc(AdditionalV[i]->Name.size() + 1, sizeof(char));
strcpy(pdc->list_add_LPvars[i], AdditionalV[i]->Name.c_str());
}
}
// Objective
// list_pos and list_value are both have size num_items.
// list_pos[i] and list_value[i] correspond.
// list_value[i] is the coefficient for the term represented by list_pos[i].
// for all i < (1 << numrvs), list_pos[i] represents H(set represented by the bits of i)
// Coeff*H(setA|setB) is represented equivalently as Coeff*H(setA U setB) - Coeff*H(setB)
// for all i >= (1 << numrvs), i represents AL with index (i - (1 << numrvs))
// num_items is the number of distince sets and ALs ended up with
if(Objective)
{
Get_Expression_Into_Map(pos_val_m, Objective, RandomV.size());
pdc->num_items_in_objective = (int) pos_val_m.size();
pdc->list_pos_in_objective = (unsigned int*)calloc(pdc->num_items_in_objective, sizeof(unsigned int));
pdc->list_value_in_objective = (double*)calloc(pdc->num_items_in_objective, sizeof(double));
Get_Map_Into_C_Style_Expression(pos_val_m, pdc->list_pos_in_objective, pdc->list_value_in_objective);
}
// Dependencies
// list_dependency is an array of size 2*num_dependency.
// For each pair, [2*i] is a binary list of all vars in Dependent_Vars and Given_Vars
// and [2*i+1] is a binary list of all vars in Given_Vars only
pdc->num_dependency = Dependencies.size();
if(Dependencies.size())
{
pdc->list_dependency = (int*)calloc(2 * pdc->num_dependency, sizeof(int));
for(i = 0; i < Dependencies.size(); i++)
{
for(j = 0; j < Dependencies[i]->Dependent_Vars.size(); j++)
{
pdc->list_dependency[i*2] |= (1 << Dependencies[i]->Dependent_Vars[j]->Index);
}
for(j = 0; j < Dependencies[i]->Given_Vars.size(); j++)
{
pdc->list_dependency[i*2] |= (1 << Dependencies[i]->Given_Vars[j]->Index);
pdc->list_dependency[i*2+1] |= (1 << Dependencies[i]->Given_Vars[j]->Index);
}
}
}
// Independences
// list_independence, list_type_independence, and list_num_items_in_independence are all size num_independence
// list_independence[i] has size list_num_items_in_independence[i]
//
// if type is 0, size is n+1.
// The first n are (1 << index) of corresponding var.
// list[n] is all those ORd together.
// if type is 1, size is n+2.
// The first n are (1 << index) of corresponding var ORd together with list[n].
// list[n] is (1 << index) for ALL the "given" list.
// list[n+1] is all those ORd together.
pdc->num_independence = Independences.size();
if(Independences.size())
{
pdc->list_independence = (unsigned int**)calloc(pdc->num_independence, sizeof(unsigned int*));
pdc->list_num_items_in_independence = (int*)calloc(pdc->num_independence, sizeof(int));
pdc->list_type_independence = (char*)calloc(pdc->num_independence, sizeof(char));
for(i = 0; i < Independences.size(); i++)
{
if(Independences[i]->Given_Vars.size())
{
pdc->list_type_independence[i] = 1;
pdc->list_num_items_in_independence[i] = Independences[i]->Independent_Vars_Vecs.size() + 2;
}
else
{
pdc->list_type_independence[i] = 0;
pdc->list_num_items_in_independence[i] = Independences[i]->Independent_Vars_Vecs.size() + 1;
}
pdc->list_independence[i] = (unsigned int*)calloc(pdc->list_num_items_in_independence[i], sizeof(unsigned int));
// HERE BRENT
for(j = 0; j < Independences[i]->Independent_Vars_Vecs.size(); j++)
{
num_to_or = (1 << Independences[i]->Independent_Vars_Vecs[j].front()->Index);
for(unsigned int zz = 1; zz < Independences[i]->Independent_Vars_Vecs[j].size(); zz++)
num_to_or ^= Independences[i]->Independent_Vars_Vecs[j][zz]->Index;
pdc->list_independence[i][j] |= num_to_or;
pdc->list_independence[i][pdc->list_num_items_in_independence[i]-1] |= num_to_or;
}
for(j = 0; j < Independences[i]->Given_Vars.size(); j++)
for(k = 0; k < (unsigned int) pdc->list_num_items_in_independence[i]; k++)
pdc->list_independence[i][k] |= (1 << Independences[i]->Given_Vars[j]->Index);
}
}
// Constant Bounds
pdc->num_constantbounds = Constant_Bounds.size();
if(pdc->num_constantbounds)
{
pdc->list_pos_constantbounds = (unsigned int**)calloc(pdc->num_constantbounds, sizeof(unsigned int*));
pdc->list_value_constantbounds = (double**)calloc(pdc->num_constantbounds, sizeof(double*));
pdc->list_type_constantbounds = (char*)calloc(pdc->num_constantbounds, sizeof(char));
pdc->list_rhs = (double*)calloc(pdc->num_constantbounds, sizeof(double));
pdc->list_num_items_in_constantbounds = (int*)calloc(pdc->num_constantbounds, sizeof(int));
FillBounds(Constant_Bounds, pdc->list_pos_constantbounds, pdc->list_value_constantbounds, pdc->list_type_constantbounds, pdc->list_rhs, pdc->list_num_items_in_constantbounds, RandomV.size());
}
// Bounds to Prove
pdc->num_bounds = Bounds_To_Prove.size();
if(pdc->num_bounds)
{
pdc->list_pos_bounds = (unsigned int**)calloc(pdc->num_bounds, sizeof(unsigned int*));
pdc->list_value_bounds = (double**)calloc(pdc->num_bounds, sizeof(double*));
pdc->list_type_bounds = (char*)calloc(pdc->num_bounds, sizeof(char));
pdc->list_rhs_2prove = (double*)calloc(pdc->num_bounds, sizeof(double));
pdc->list_num_items_in_bounds = (int*)calloc(pdc->num_bounds, sizeof(int));
FillBounds(Bounds_To_Prove, pdc->list_pos_bounds, pdc->list_value_bounds, pdc->list_type_bounds, pdc->list_rhs_2prove, pdc->list_num_items_in_bounds, RandomV.size());
}
// sensititivies
pdc->num_sensitivities = Sensitivities.size();
if (pdc->num_sensitivities)
{
pdc->list_pos_sensitivities = (unsigned int**)calloc(pdc->num_sensitivities, sizeof(unsigned int*));
pdc->list_value_sensitivities = (double**)calloc(pdc->num_sensitivities, sizeof(double*));
pdc->list_num_items_in_sensitivities = (int*)calloc(pdc->num_sensitivities, sizeof(int));
FillExpressions(Sensitivities, pdc->list_pos_sensitivities, pdc->list_value_sensitivities, pdc->list_num_items_in_sensitivities, RandomV.size());
}
// queries
pdc->num_queries =Queries.size();
if (pdc->num_queries)
{
pdc->list_pos_queries = (unsigned int**)calloc(pdc->num_queries, sizeof(unsigned int*));
pdc->list_value_queries = (double**)calloc(pdc->num_queries, sizeof(double*));
pdc->list_num_items_in_queries = (int*)calloc(pdc->num_queries, sizeof(int));
FillExpressions(Queries, pdc->list_pos_queries, pdc->list_value_queries, pdc->list_num_items_in_queries, RandomV.size());
}
// Symmetries
// Each row is a permutation of indices
pdc->num_symmetrymap = Symmetries.size();
if(Symmetries.size())
{
pdc->list_symmetry = (char**)calloc(pdc->num_symmetrymap, sizeof(char*));
for(i = 0; i < Symmetries.size(); i++)
{
pdc->list_symmetry[i] = (char*)calloc(pdc->num_rvs, sizeof(char));
for(j = 0; j < Symmetries[i]->Order.size(); j++)
pdc->list_symmetry[i][j] = Symmetries[i]->Order[j]->Index;
}
}
// Equivalence classes
if(Equivalences2d.size() && Equivalences2d.front().size())
pdc->equivalences = Equivalences2d;
return pdc;
}
void CAI::Initialize_Problem_Description_C_Style(Problem_Description_C_Style* PD)
{
PD->num_constantbounds = 0;
PD->num_dependency = 0;
PD->num_independence = 0;
PD->num_items_in_objective = 0;
PD->num_rvs = 0;
PD->num_symmetrymap = 0;
PD->num_add_LPvars = 0;
PD->num_bounds = 0;
// do not reuse PD structure without releasing existing memory allocation
PD->list_rvs = NULL;
PD->list_add_LPvars = NULL;
PD->list_dependency = NULL;
PD->list_independence = NULL;
PD->list_num_items_in_independence = NULL;
PD->list_type_independence = NULL;
PD->list_pos_in_objective = NULL;
PD->list_value_in_objective = NULL;
PD->list_pos_constantbounds = NULL;
PD->list_value_constantbounds = NULL;
PD->list_type_constantbounds = NULL;
PD->list_num_items_in_constantbounds = NULL;
PD->list_rhs = NULL;
PD->list_pos_bounds = NULL;
PD->list_value_bounds = NULL;
PD->list_type_bounds = NULL;
PD->list_num_items_in_bounds = NULL;
PD->list_rhs_2prove = NULL;
PD->list_pos_queries = NULL;
PD->list_value_queries = NULL;
PD->list_num_items_in_queries = NULL;
PD->list_pos_sensitivities = NULL;
PD->list_value_sensitivities = NULL;
PD->list_num_items_in_sensitivities = NULL;
PD->list_symmetry = NULL;
PD->equivalences.clear();
}
void CAI::Free_Problem_Description_C_Style(Problem_Description_C_Style* PD)
{
if (PD->num_rvs > 0) {
for (int i = 0; i < PD->num_rvs; i++)
free(PD->list_rvs[i]);
free(PD->list_rvs);
}
if (PD->num_add_LPvars > 0) {
for (int i = 0; i < PD->num_add_LPvars; i++)
free(PD->list_add_LPvars[i]);
free(PD->list_add_LPvars);
}
free(PD->list_pos_in_objective);
free(PD->list_value_in_objective);
if (PD->num_dependency > 0)
free(PD->list_dependency);
if (PD->num_independence > 0) {
for (int i = 0; i < PD->num_independence; i++)
free(PD->list_independence[i]);
free(PD->list_independence);
free(PD->list_num_items_in_independence);
free(PD->list_type_independence);
}
if (PD->num_symmetrymap > 0) {
for (int i = 0; i < PD->num_symmetrymap; i++)
free(PD->list_symmetry[i]);
free(PD->list_symmetry);
}
if (PD->num_constantbounds > 0) {
for (int i = 0; i < PD->num_constantbounds; i++) {
free(PD->list_pos_constantbounds[i]);
free(PD->list_value_constantbounds[i]);
}
free(PD->list_pos_constantbounds);
free(PD->list_value_constantbounds);
free(PD->list_num_items_in_constantbounds);
free(PD->list_type_constantbounds);
free(PD->list_rhs);
}
if (PD->num_bounds > 0) {
for (int i = 0; i < PD->num_bounds; i++) {
free(PD->list_pos_bounds[i]);
free(PD->list_value_bounds[i]);
}
free(PD->list_pos_bounds);
free(PD->list_value_bounds);
free(PD->list_num_items_in_bounds);
free(PD->list_type_bounds);
free(PD->list_rhs_2prove);
}
if (PD->num_sensitivities > 0) {
for (int i = 0; i < PD->num_sensitivities; i++) {
free(PD->list_pos_sensitivities[i]);
free(PD->list_value_sensitivities[i]);
}
free(PD->list_pos_sensitivities);
free(PD->list_value_sensitivities);
free(PD->list_num_items_in_sensitivities);
}
if (PD->num_queries > 0) {
for (int i = 0; i < PD->num_queries; i++) {
free(PD->list_pos_queries[i]);
free(PD->list_value_queries[i]);
}
free(PD->list_pos_queries);
free(PD->list_value_queries);
free(PD->list_num_items_in_queries);
}
PD->list_rvs = NULL;
PD->list_add_LPvars = NULL;
PD->list_pos_in_objective = NULL;
PD->list_value_in_objective = NULL;
PD->list_dependency = NULL;
PD->list_type_independence = NULL;
PD->list_independence = NULL;
PD->list_num_items_in_independence = NULL;
PD->list_type_constantbounds = NULL;
PD->list_pos_constantbounds = NULL;
PD->list_value_constantbounds = NULL;
PD->list_rhs = NULL;
PD->list_num_items_in_constantbounds = NULL;
PD->list_type_bounds = NULL;
PD->list_pos_bounds = NULL;
PD->list_value_bounds = NULL;
PD->list_rhs_2prove = NULL;
PD->list_num_items_in_bounds = NULL;
PD->list_symmetry = NULL;
PD->num_rvs = 0;
PD->num_add_LPvars = 0;
PD->num_items_in_objective = 0;
PD->num_dependency = 0;
PD->num_independence = 0;
PD->num_constantbounds = 0;
PD->num_symmetrymap = 0;
PD->num_bounds = 0;
PD->list_pos_sensitivities = NULL;
PD->list_value_sensitivities = NULL;
PD->list_num_items_in_sensitivities = NULL;
PD->list_pos_queries = NULL;
PD->list_value_queries = NULL;
PD->list_num_items_in_queries = NULL;
PD->equivalences.clear();
}
// All 5 lists are size num_constantbounds
// numitems is as in the objective function
// list_pos is as in the objective function
// list_value is as in the objective function
// list_type is (int)0 for >= and (int)2 for =
// all <= are changed to >= with negation
// list_rhs is just a constant
void PrintBound(int numbounds, int* list_numitems, unsigned int** list_pos, double** list_value, char* list_type, double* list_rhs)
{
int i, j;
cout << "numbounds:" << endl << "\t" << numbounds << endl;
cout << "list_numitems:" << endl;
for(i = 0; i < numbounds; i++)
cout << "\t" << list_numitems[i] << endl;
cout << "list_pos:" << endl;
for(i = 0; i < numbounds; i++)
{
cout << "\t";
for(j = 0; j < list_numitems[i]; j++)
cout << list_pos[i][j] << ", ";
cout << endl;
}
cout << "list_value:" << endl;
for(i = 0; i < numbounds; i++)
{
cout << "\t";
for(j = 0; j < list_numitems[i]; j++)
cout << list_value[i][j] << ", ";
cout << endl;
}
cout << "list_type:" << endl;
for(i = 0; i < numbounds; i++)
cout << "\t" << (int)list_type[i] << endl;
cout << "list_rhs:" << endl;
for(i = 0; i < numbounds; i++)
cout << "\t" << list_rhs[i] << endl;
}
// All 3 lists are size num_constantbounds
// numitems is as in the objective function
// list_pos is as in the objective function
// list_value is as in the objective function
void PrintExpression(int numexpressions, int* list_numitems, unsigned int** list_pos, double** list_value)
{
int i, j;
cout << "numexpressions:" << endl << "\t" << numexpressions << endl;
cout << "list_numitems:" << endl;
for (i = 0; i < numexpressions; i++)
cout << "\t" << list_numitems[i] << endl;
cout << "list_pos:" << endl;
for (i = 0; i < numexpressions; i++)
{
cout << "\t";
for (j = 0; j < list_numitems[i]; j++)
cout << list_pos[i][j] << ", ";
cout << endl;
}
cout << "list_value:" << endl;
for (i = 0; i < numexpressions; i++)
{
cout << "\t";
for (j = 0; j < list_numitems[i]; j++)
cout << list_value[i][j] << ", ";
cout << endl;
}
}
void CAI::Print_Problem_Description_C_Style(Problem_Description_C_Style* PD)
{
int i,j;
// RVs are self-explanatory
cout << "RVs" << endl;
cout << "num_rvs:" << endl << "\t" << PD->num_rvs << endl;
cout << "list_rvs:" << endl << "\t";
for(int i = 0; i < PD->num_rvs; i++)
cout << PD->list_rvs[i] << ", ";
cout << endl;
cout << endl;
// ALs are self-explanatory
cout << "ALs" << endl;
cout << "num_add_LPvars:" << endl << "\t" << PD->num_add_LPvars << endl;
cout << "list_add_LPvars:" << endl << "\t";
for(i = 0; i < PD->num_add_LPvars; i++)
cout << PD->list_add_LPvars[i] << ", ";
cout << endl;
cout << endl;
// Objective
// list_pos and list_value are both have size num_items.
// list_pos[i] and list_value[i] correspond.
// list_value[i] is the coefficient for the term represented by list_pos[i].
// for all i < (1 << numrvs), list_pos[i] represents H(set represented by the bits of i)
// Coeff*H(setA|setB) is represented equivalently as Coeff*H(setA U setB) - Coeff*H(setB)
// for all i >= (1 << numrvs), i represents AL with index (i - (1 << numrvs))
// num_items is the number of distince sets and ALs ended up with
cout << "Objective" << endl;
cout << "num_items_in_objective:" << endl << "\t" << PD->num_items_in_objective << endl;
cout << "list_pos_in_objective:" << endl << "\t";
for(i = 0; i < PD->num_items_in_objective; i ++)
cout << PD->list_pos_in_objective[i] << ", ";
cout << endl;
cout << "list_value_in_objective:" << endl << "\t";
for(i = 0; i < PD->num_items_in_objective; i ++)
cout << PD->list_value_in_objective[i] << ", ";
cout << endl << endl;
// Dependencies
// list_dependency is an array of size 2*num_dependency.
// For each pair, [2*i] is a binary list of all vars in Dependent_Vars and Given_Vars
// and [2*i+1] is a binary list of all vars in Given_Vars only
cout << "Dependencies" << endl;
cout << "num_dependency:" << endl << "\t" << PD->num_dependency << endl;
cout << "list_dependency:" << endl;
for(i = 0; i < PD->num_dependency; i++)
cout << "\t" << PD->list_dependency[i*2] << " " << PD->list_dependency[i*2+1] << endl;
cout << endl;
// Independences
// list_independence, list_type_independence, and list_num_items_in_independence are all size num_independence
// list_independence[i] has size list_num_items_in_independence[i]
//
// if type is (int)0, size is n+1.
// The first n are (1 << index) of corresponding var.
// list[n] is all those ORd together.
// if type is (int)1, size is n+2.
// The first n are (1 << index) of corresponding var ORd together with list[n].
// list[n] is (1 << index) for ALL the "given" list.
// list[n+1] is all those ORd together.
cout << "Independences" << endl;
cout << "num_independence:" << endl << "\t" << PD->num_independence << endl;
cout << "list_independence:" << endl;
for(i = 0; i < PD->num_independence; i++)
{
cout << "\t";
for(j = 0; j < PD->list_num_items_in_independence[i]; j++)
cout << PD->list_independence[i][j] << ", ";
cout << endl;
}
cout << "list_type_independence:" << endl;
for(i = 0; i < PD->num_independence; i++)
cout << "\t" << (int)PD->list_type_independence[i] << endl;
cout << "list_num_items_in_independence:" << endl;
for(i = 0; i < PD->num_independence; i++)
cout << "\t" << PD->list_num_items_in_independence[i] << endl;
cout << endl;
cout << "Constant Bounds" << endl;
PrintBound(PD->num_constantbounds, PD->list_num_items_in_constantbounds, PD->list_pos_constantbounds, PD->list_value_constantbounds, PD->list_type_constantbounds, PD->list_rhs);
cout << endl << endl;
cout << "Bounds to Prove" << endl;
PrintBound(PD->num_bounds, PD->list_num_items_in_bounds, PD->list_pos_bounds, PD->list_value_bounds, PD->list_type_bounds, PD->list_rhs_2prove);
cout << endl << endl;
cout << "Sensitivities" << endl;
PrintExpression(PD->num_sensitivities, PD->list_num_items_in_sensitivities, PD->list_pos_sensitivities, PD->list_value_sensitivities);
cout << endl << endl;
cout << "Queries" << endl;
PrintExpression(PD->num_sensitivities, PD->list_num_items_in_sensitivities, PD->list_pos_sensitivities, PD->list_value_sensitivities);
cout << endl << endl;
// Symmetries
// Each row is a permutation of indices
cout << "Symmetries" << endl;
cout << "num_symmetrymap:" << endl << "\t" << PD->num_symmetrymap << endl;
for(i = 0; i < PD->num_symmetrymap; i++)
{
cout << "\t";
for(j = 0; j < PD->num_rvs; j++)
cout << (int)PD->list_symmetry[i][j] << ", ";
cout << endl;
}
// Equivalence classes
if (PD->equivalences.size() != 0) {
cout << endl;
cout << "Equivalence classes (not part of the old PD files, BTW)\n";
for (i = 0; i < (int) PD->equivalences.size(); i++) {
cout << "\t";
for (j = 0; j < (int) PD->equivalences.size(); j++) {
cout << PD->equivalences[i][j] << " ";
}
cout << endl;
}
}
}
// Reading from file to create Problem_Description
int CAI::Get_Command(std::istream& Input_Stream, Problem_Description* pd)
{
istringstream ss;
vector <string> sv;
string s, l;
json j1, j2;
/* streampos onelineback; */
/* onelineback = Input_Stream.tellg(); */
if (!getline(Input_Stream, l))
return 0;
sv.clear();
ss.clear();
ss.str(l);
while (ss >> s) sv.push_back(s);
// Do nothing for empty lines
if (sv.size() == 0)
{
}
// Ignore comments
else if (sv[0][0] == '#')
{
}
// Print commands
else if (sv[0] == "?")
{
print_commands(stdout);
}
// Quit
else if (sv[0] == "Q")
{
return 0;
}
/* Process lines */
else if (sv[0] == "PD")
{
if(!read_json(sv, 1, j1, Input_Stream)) throw SRE((string) "Get_Command(): Invalid json.");
pd->Modify_Json_From_Cmd_Line_Before_From_Json(j1);
pd->From_Json(j1);
}
else if(sv[0] == "CMD" || sv[0] == "OPT")
{
if(!read_json(sv, 1, j1, Input_Stream)) throw SRE((string) "Get_Command(): Invalid CMD or OPT.");
if(!j1.is_array()) throw SRE((string) "Get_Command(): CMD or OPT arg must be a json array.");
pd->Cmd_Line_Modifiers.push_back(new Cmd_Line_Modifier("CMD",'+',j1));
}
// This is the same as PD but without the PD
// Commenting this out on 20200709
/* else if (sv[0][0] == '{')
{
if(!read_json(sv, 0, j1, Input_Stream))
{
Input_Stream.seekg(onelineback);
if(!read_json(sv, 1, j1, Input_Stream))
throw SRE((string) "Get_Command(): Invalid json on {.");
}
pd->Modify_Json_From_Cmd_Line_Before_From_Json(j1);
pd->From_Json(j1);
} */
else if (sv[0] == "RV")
{
if(!read_json(sv, 1, j1, Input_Stream)) throw SRE((string) "Get_Command(): Invalid json.");
pd->Key_RV(j1);
}
else if (sv[0] == "AL")
{
if(!read_json(sv, 1, j1, Input_Stream)) throw SRE((string) "Get_Command(): Invalid json.");
pd->Key_AL(j1);
}
else if (sv[0] == "O")
{
if(!read_json(sv, 1, j1, Input_Stream)) throw SRE((string) "Get_Command(): Invalid json.");
pd->Key_O(j1);
}
else if (sv[0] == "D")
{
if(!read_json(sv, 1, j1, Input_Stream)) throw SRE((string) "Get_Command(): Invalid json.");
pd->Key_D(j1);
}
else if (sv[0] == "I")
{
if(!read_json(sv, 1, j1, Input_Stream)) throw SRE((string) "Get_Command(): Invalid json.");
pd->Key_I(j1);
}
else if (sv[0] == "BC")
{
if(!read_json(sv, 1, j1, Input_Stream)) throw SRE((string) "Get_Command(): Invalid json.");
pd->Key_BC(j1);
}
else if (sv[0] == "S")
{
if(!read_json(sv, 1, j1, Input_Stream)) throw SRE((string) "Get_Command(): Invalid json.");
pd->Key_S(j1);
}
else if (sv[0] == "EQ")
{
if(!read_json(sv, 1, j1, Input_Stream)) throw SRE((string) "Get_Command(): Invalid json.");
pd->Key_EQ(j1);
}
else if (sv[0] == "QU")
{
if(!read_json(sv, 1, j1, Input_Stream)) throw SRE((string) "Get_Command(): Invalid json.");
pd->Key_QU(j1);
}
else if (sv[0] == "SE")
{
if(!read_json(sv, 1, j1, Input_Stream)) throw SRE((string) "Get_Command(): Invalid json.");
pd->Key_SE(j1);
}
else if (sv[0] == "BP")
{
if(!read_json(sv, 1, j1, Input_Stream)) throw SRE((string) "Get_Command(): Invalid json.");
pd->Key_BP(j1);
}
else if (sv[0] == "PDC")
{
Problem_Description_C_Style* pdc = pd->As_Problem_Description_C_Style();
Print_Problem_Description_C_Style(pdc);
}
else if (sv[0] == "DESTROY")
{
delete pd;
pd = new Problem_Description;
}
else if (sv[0] == "DESER")
{
Command_DESER(pd,sv);
}
else if (sv[0] == "CS")
{
pd->Check_Symmetry_Group();
}
else if (sv[0] == "SER")
{
Command_SER(pd,sv,0);
}
else if (sv[0] == "POF")
{
Command_SER(pd,sv,1);
}
else
{
throw SRE((string) "Get_Command(): Invalid command \"" + sv[0] + "\". Use '?' to print a list of commands.");
}
return 1;
}
void CAI::Command_SER(Problem_Description* pd, vector<std::string>& sv, int old_style)
{
ofstream fout;
if(sv.size() != 1 && sv.size() != 3)
throw SRE((string) "Command_SER(): Too many arguments to SER.\nSER [-a|-t file],\nwhere a is append and t is truncate.\n");
if(sv.size() == 1)
{
/* cout << "PD" << endl << pd->As_Json().dump(4) << endl; */
if(old_style)
pd->Print_Old_Format(cout);
else
cout << "PD" << endl << PD_Json_Pretty_Print(pd->As_Json()) << endl;
}
else
{
if(sv[1] == "-a")
fout.open(sv[2].c_str(), ios::out | ios::app);
else if(sv[1] == "-t")
fout.open(sv[2].c_str(), ios::out | ios::trunc);
else
throw SRE((string) "Command_SER(): Bad argument to SER.\nSER [-a|-t file],\nwhere a is append and t is truncate.\n");
if(!fout.is_open())
throw SRE((string) "Command_SER(): Couldn't open file \"" + sv[2].c_str() + (string) "\".");
/* fout << "PD" << endl << pd->As_Json().dump(4) << endl; */
if(old_style)
pd->Print_Old_Format(fout);
else
fout << "PD" << endl << PD_Json_Pretty_Print(pd->As_Json()) << endl;
fout.close();
}
}
void CAI::Command_DESER(Problem_Description* pd, vector<std::string>& sv)
{
unsigned int i;
std::ifstream ifs;
if(sv.size() <= 1)
return;
if(sv[1] == "-")
{
while(Get_Command(cin, pd));
}
else
{
for(i = 1; i < sv.size(); ++i)
{
ifs.clear();
ifs.open(sv[i],std::ifstream::in);
if(!ifs.is_open())
throw SRE((string) "Command_DESER(): Couldn't open file " + sv[i]);
while(Get_Command(ifs, pd));
ifs.close();
}
}
}
void CAI::Read_Problem_Description_From_File(Problem_Description* pd, std::string filename)
{
std::vector<std::string> v;
nlohmann::json j;
if(filename == "-")
{
while(Get_Command(cin, pd));
}
else
{
v.resize(2);
v[1] = filename;
Command_DESER(pd, v);
}
pd->Run_Cmd_Line_Modifier_Commands();
}
void Problem_Description::Check_Equivalence() const
{
for(unsigned int i = 0; i < Equivalences2d.size(); ++i)
for(unsigned int k = 0; k < Equivalences2d[i].size(); ++k)
if (Equivalences2d[i][k].size() != RandomV.size())
throw SRE("Problem_Description::Check_Equivalence(): Error in problem description file -- equivalence class specification string's size must equal |RV|. Equivalences[" + std::to_string(i) + "] doesn't.");
//printf("Check_Equivalence() succeeded\n");
}
// Reads json from vector or continues
// reading json from Input_Stream.
bool CAI::read_json(const std::vector <std::string> &sv, size_t starting_field, nlohmann::json &rv, std::istream& Input_Stream)
{
string s;
size_t i;
rv.clear();
if (starting_field < sv.size()) {
s = sv[starting_field];
for (i = starting_field+1; i < sv.size(); i++) {
s += " ";
s += sv[i];
}
try {
rv = json::parse(s);
} catch (...) {
return false;
}
return true;
}
try {
Input_Stream >> rv;
getline(Input_Stream, s);
return true;
} catch (...) {
return false;
}
}
void CAI::print_commands(FILE *f)
{
fprintf(f, "For commands that take a single json, either put it all on the line with the command,\n");
fprintf(f, "or it can be multiple lines, starting on the line after the command.\n");
fprintf(f, "\n");
fprintf(f, "PD json - Give entire problem description in one json\n");
fprintf(f, "\n");
fprintf(f, "RV json_variable_array - Add random variable(s)\n");
fprintf(f, "AL json_variable_array - Add additional linear variable(s) \n");
fprintf(f, "O json_expression_array - Add objective function\n");
fprintf(f, "D json_array - Add dependency\n");
fprintf(f, "I json_array - Add independence\n");
fprintf(f, "BC json_array - Add constant bounds\n");
fprintf(f, "S json_array - Add symmetry\n");
fprintf(f, "EQ string - Add equivalence classes\n");
fprintf(f, "QU string - Add query expressions\n");
fprintf(f, "SE string - Add sensitivity analysis\n");
fprintf(f, "BP json_array - Add bounds to prove\n");
fprintf(f, "\n");
fprintf(f, "PDC - Print the problem description after initial processing.\n");
fprintf(f, "LP_DISP - Print intermediate output in LP optimization.\n");
fprintf(f, "\n");
fprintf(f, "DESTROY - Call the destructor, then create a new one.\n");
fprintf(f, "DESER files - Deserialize.\n");
fprintf(f, "SER [-a|-t file] - Serialize.\n");
fprintf(f, "\n");
fprintf(f, "Q - Quit.\n");
fprintf(f, "? - Print commands.\n");
}
|
// calc takes the mass of a "module" as input and returns the fuel required.
// This is calculated by taking the mass, dividing by 3, rounding down, and then
// subtracting 2.
func calc(mass int) int {
s1 := mass / 3
fuel := s1 - 2
return int(fuel)
} |
/**
* @author Sebsa
* @since Before 0.1.0
*
* A abstract class used by all type of assets.
* An Amber Asset is an asset wich contains data loaded from files.
*/
public abstract class Asset {
/**
* The name of the asset used for finding and indexing assets
*/
public String name;
/**
* The file wich the asset is loaded from
* May be null if its an internal asset
*/
public File file;
/**
* Wether the asset is saved within the jar
*/
public boolean internal = false;
/**
* A big font used in rendering
*/
private static Font bigFont = new Font(new java.awt.Font("OpenSans", java.awt.Font.PLAIN, 24));
/**
* @param r The maximum area the asset will be rendered in
* Renders a GUI representation of the asset and its data
*/
public void render(Rect r) {
if(bigFont.getStringWidth(name) > r.width) {
GUI.label(name, 0, 0);
} else {
GUI.label(name, 0, 0, Color.white(), bigFont);
}
GUI.label(this.getClass().getSimpleName(), 0, 26);
}
} |
def convert_key(self, key : tuple):
x, y, z = [int(i) for i in key]
if x not in range(16):
raise KeyError(f'Invalid chunk-relative x {x} (must be 0-15)')
elif y not in range(256):
raise KeyError(f'Invalid chunk-relative y {y} (must be 0-255)')
elif z not in range(16):
raise KeyError(f'Invalid chunk-relative z {z} (must be 0-15)')
return x, y, z |
#include <stdio.h>
#include <stdlib.h>
#include<string.h>>
int main()
{
char a[1005],b[1005];
int ans=0,s=0,j,l,i,k=0,z;
gets (a);
l=strlen(a);
if (a[1]=='}')
{
printf("0");
return 0;
ans=1;
}
if (ans==0)
{
ans=1;
b[0]=a[1];
s=1;
for (i=4;i<l;i=i+3)
{
b[s]=a[i];
s++;
for (j=0;j<s-1;j++)
{
if (a[i]==b[j])
{
z=0;
break;
}
else
{
z=1;
}
}
if (z==1)
ans++;
}
}
printf("%d",ans);
return 0;
}
|
/**
* Deletes files on Hadoop file system.
* @since 0.10.0
*/
public final class HadoopDelete {
static final Logger LOG = LoggerFactory.getLogger(HadoopDelete.class);
private HadoopDelete() {
return;
}
/**
* Program entry.
* @param args paths to delete
*/
public static void main(String... args) {
int status = exec(args);
if (status != 0) {
System.exit(status);
}
}
static int exec(String... args) {
if (args.length == 0) {
LOG.warn("there are no files to delete");
return -1;
}
boolean sawError = false;
Configuration conf = new Configuration();
for (String arg : args) {
try {
delete(conf, new Path(arg));
} catch (IOException e) {
LOG.error(MessageFormat.format(
"failed to delete file: {0}",
arg), e);
sawError = true;
}
}
return sawError ? 1 : 0;
}
private static void delete(Configuration conf, Path path) throws IOException {
FileSystem fs = path.getFileSystem(conf);
if (LOG.isDebugEnabled()) {
LOG.debug("deleting file: {}", fs.makeQualified(path));
}
boolean deleted = fs.delete(path, true);
if (LOG.isDebugEnabled()) {
if (deleted) {
LOG.debug("delete success: {}", fs.makeQualified(path));
} else if (fs.exists(path)) {
LOG.debug("delete failed: {}", fs.makeQualified(path));
} else {
LOG.debug("target file is not found: {}", fs.makeQualified(path));
}
}
}
} |
<filename>model/jst/TaobaoJdsTradesStatisticsDiffRequest.go
package jst
import (
"net/url"
"github.com/bububa/opentaobao/model"
)
/*
订单全链路状态统计差异比较 APIRequest
taobao.jds.trades.statistics.diff
订单全链路状态统计差异比较
*/
type TaobaoJdsTradesStatisticsDiffRequest struct {
model.Params
// 查询的日期，格式如YYYYMMDD的日期对应的数字
date int64
// 需要比较的状态，将会和post_status做比较
preStatus string
// 需要比较的状态
postStatus string
// 页数
pageNo int64
}
func NewTaobaoJdsTradesStatisticsDiffRequest() *TaobaoJdsTradesStatisticsDiffRequest{
return &TaobaoJdsTradesStatisticsDiffRequest{
Params: model.NewParams(),
}
}
func (r TaobaoJdsTradesStatisticsDiffRequest) GetApiMethodName() string {
return "taobao.jds.trades.statistics.diff"
}
func (r TaobaoJdsTradesStatisticsDiffRequest) GetApiParams() url.Values {
params := url.Values{}
for k, v := range r.GetRawParams() {
params.Set(k, v.String())
}
return params
}
func (r *TaobaoJdsTradesStatisticsDiffRequest) SetDate(date int64) error {
r.date = date
r.Set("date", date)
return nil
}
func (r TaobaoJdsTradesStatisticsDiffRequest) GetDate() int64 {
return r.date
}
func (r *TaobaoJdsTradesStatisticsDiffRequest) SetPreStatus(preStatus string) error {
r.preStatus = preStatus
r.Set("pre_status", preStatus)
return nil
}
func (r TaobaoJdsTradesStatisticsDiffRequest) GetPreStatus() string {
return r.preStatus
}
func (r *TaobaoJdsTradesStatisticsDiffRequest) SetPostStatus(postStatus string) error {
r.postStatus = postStatus
r.Set("post_status", postStatus)
return nil
}
func (r TaobaoJdsTradesStatisticsDiffRequest) GetPostStatus() string {
return r.postStatus
}
func (r *TaobaoJdsTradesStatisticsDiffRequest) SetPageNo(pageNo int64) error {
r.pageNo = pageNo
r.Set("page_no", pageNo)
return nil
}
func (r TaobaoJdsTradesStatisticsDiffRequest) GetPageNo() int64 {
return r.pageNo
}
|
<filename>go/vt/proto/vtctldata/vtctldata.pb.go
//
//Copyright 2019 The Vitess 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.
// This package contains the data structures for a service allowing
// you to use vtctld as a server for vt commands.
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.27.1
// protoc v3.6.1
// source: vtctldata.proto
package vtctldata
import (
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
binlogdata "vitess.io/vitess/go/vt/proto/binlogdata"
logutil "vitess.io/vitess/go/vt/proto/logutil"
mysqlctl "vitess.io/vitess/go/vt/proto/mysqlctl"
replicationdata "vitess.io/vitess/go/vt/proto/replicationdata"
tabletmanagerdata "vitess.io/vitess/go/vt/proto/tabletmanagerdata"
topodata "vitess.io/vitess/go/vt/proto/topodata"
vschema "vitess.io/vitess/go/vt/proto/vschema"
vttime "vitess.io/vitess/go/vt/proto/vttime"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
// MaterializationIntent describes the reason for creating the Materialize flow
type MaterializationIntent int32
const (
// CUSTOM is the default value
MaterializationIntent_CUSTOM MaterializationIntent = 0
// MOVETABLES is when we are creating a MoveTables flow
MaterializationIntent_MOVETABLES MaterializationIntent = 1
// CREATELOOKUPINDEX is when we are creating a CreateLookupIndex flow
MaterializationIntent_CREATELOOKUPINDEX MaterializationIntent = 2
)
// Enum value maps for MaterializationIntent.
var (
MaterializationIntent_name = map[int32]string{
0: "CUSTOM",
1: "MOVETABLES",
2: "CREATELOOKUPINDEX",
}
MaterializationIntent_value = map[string]int32{
"CUSTOM": 0,
"MOVETABLES": 1,
"CREATELOOKUPINDEX": 2,
}
)
func (x MaterializationIntent) Enum() *MaterializationIntent {
p := new(MaterializationIntent)
*p = x
return p
}
func (x MaterializationIntent) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (MaterializationIntent) Descriptor() protoreflect.EnumDescriptor {
return file_vtctldata_proto_enumTypes[0].Descriptor()
}
func (MaterializationIntent) Type() protoreflect.EnumType {
return &file_vtctldata_proto_enumTypes[0]
}
func (x MaterializationIntent) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Use MaterializationIntent.Descriptor instead.
func (MaterializationIntent) EnumDescriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{0}
}
// ExecuteVtctlCommandRequest is the payload for ExecuteVtctlCommand.
// timeouts are in nanoseconds.
type ExecuteVtctlCommandRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Args []string `protobuf:"bytes,1,rep,name=args,proto3" json:"args,omitempty"`
ActionTimeout int64 `protobuf:"varint,2,opt,name=action_timeout,json=actionTimeout,proto3" json:"action_timeout,omitempty"`
}
func (x *ExecuteVtctlCommandRequest) Reset() {
*x = ExecuteVtctlCommandRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ExecuteVtctlCommandRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ExecuteVtctlCommandRequest) ProtoMessage() {}
func (x *ExecuteVtctlCommandRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[0]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ExecuteVtctlCommandRequest.ProtoReflect.Descriptor instead.
func (*ExecuteVtctlCommandRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{0}
}
func (x *ExecuteVtctlCommandRequest) GetArgs() []string {
if x != nil {
return x.Args
}
return nil
}
func (x *ExecuteVtctlCommandRequest) GetActionTimeout() int64 {
if x != nil {
return x.ActionTimeout
}
return 0
}
// ExecuteVtctlCommandResponse is streamed back by ExecuteVtctlCommand.
type ExecuteVtctlCommandResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Event *logutil.Event `protobuf:"bytes,1,opt,name=event,proto3" json:"event,omitempty"`
}
func (x *ExecuteVtctlCommandResponse) Reset() {
*x = ExecuteVtctlCommandResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ExecuteVtctlCommandResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ExecuteVtctlCommandResponse) ProtoMessage() {}
func (x *ExecuteVtctlCommandResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[1]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ExecuteVtctlCommandResponse.ProtoReflect.Descriptor instead.
func (*ExecuteVtctlCommandResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{1}
}
func (x *ExecuteVtctlCommandResponse) GetEvent() *logutil.Event {
if x != nil {
return x.Event
}
return nil
}
// TableMaterializeSttings contains the settings for one table.
type TableMaterializeSettings struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
TargetTable string `protobuf:"bytes,1,opt,name=target_table,json=targetTable,proto3" json:"target_table,omitempty"`
// source_expression is a select statement.
SourceExpression string `protobuf:"bytes,2,opt,name=source_expression,json=sourceExpression,proto3" json:"source_expression,omitempty"`
// create_ddl contains the DDL to create the target table.
// If empty, the target table must already exist.
// if "copy", the target table DDL is the same as the source table.
CreateDdl string `protobuf:"bytes,3,opt,name=create_ddl,json=createDdl,proto3" json:"create_ddl,omitempty"`
}
func (x *TableMaterializeSettings) Reset() {
*x = TableMaterializeSettings{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[2]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *TableMaterializeSettings) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TableMaterializeSettings) ProtoMessage() {}
func (x *TableMaterializeSettings) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[2]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TableMaterializeSettings.ProtoReflect.Descriptor instead.
func (*TableMaterializeSettings) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{2}
}
func (x *TableMaterializeSettings) GetTargetTable() string {
if x != nil {
return x.TargetTable
}
return ""
}
func (x *TableMaterializeSettings) GetSourceExpression() string {
if x != nil {
return x.SourceExpression
}
return ""
}
func (x *TableMaterializeSettings) GetCreateDdl() string {
if x != nil {
return x.CreateDdl
}
return ""
}
// MaterializeSettings contains the settings for the Materialize command.
type MaterializeSettings struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// workflow is the name of the workflow.
Workflow string `protobuf:"bytes,1,opt,name=workflow,proto3" json:"workflow,omitempty"`
SourceKeyspace string `protobuf:"bytes,2,opt,name=source_keyspace,json=sourceKeyspace,proto3" json:"source_keyspace,omitempty"`
TargetKeyspace string `protobuf:"bytes,3,opt,name=target_keyspace,json=targetKeyspace,proto3" json:"target_keyspace,omitempty"`
// stop_after_copy specifies if vreplication should be stopped after copying.
StopAfterCopy bool `protobuf:"varint,4,opt,name=stop_after_copy,json=stopAfterCopy,proto3" json:"stop_after_copy,omitempty"`
TableSettings []*TableMaterializeSettings `protobuf:"bytes,5,rep,name=table_settings,json=tableSettings,proto3" json:"table_settings,omitempty"`
// optional parameters.
Cell string `protobuf:"bytes,6,opt,name=cell,proto3" json:"cell,omitempty"`
TabletTypes string `protobuf:"bytes,7,opt,name=tablet_types,json=tabletTypes,proto3" json:"tablet_types,omitempty"`
// ExternalCluster is the name of the mounted cluster which has the source keyspace/db for this workflow
// it is of the type <cluster_type.cluster_name>
ExternalCluster string `protobuf:"bytes,8,opt,name=external_cluster,json=externalCluster,proto3" json:"external_cluster,omitempty"`
// MaterializationIntent is used to identify the reason behind the materialization workflow: eg. MoveTables, CreateLookupVindex
MaterializationIntent MaterializationIntent `protobuf:"varint,9,opt,name=materialization_intent,json=materializationIntent,proto3,enum=vtctldata.MaterializationIntent" json:"materialization_intent,omitempty"`
}
func (x *MaterializeSettings) Reset() {
*x = MaterializeSettings{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[3]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *MaterializeSettings) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*MaterializeSettings) ProtoMessage() {}
func (x *MaterializeSettings) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[3]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use MaterializeSettings.ProtoReflect.Descriptor instead.
func (*MaterializeSettings) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{3}
}
func (x *MaterializeSettings) GetWorkflow() string {
if x != nil {
return x.Workflow
}
return ""
}
func (x *MaterializeSettings) GetSourceKeyspace() string {
if x != nil {
return x.SourceKeyspace
}
return ""
}
func (x *MaterializeSettings) GetTargetKeyspace() string {
if x != nil {
return x.TargetKeyspace
}
return ""
}
func (x *MaterializeSettings) GetStopAfterCopy() bool {
if x != nil {
return x.StopAfterCopy
}
return false
}
func (x *MaterializeSettings) GetTableSettings() []*TableMaterializeSettings {
if x != nil {
return x.TableSettings
}
return nil
}
func (x *MaterializeSettings) GetCell() string {
if x != nil {
return x.Cell
}
return ""
}
func (x *MaterializeSettings) GetTabletTypes() string {
if x != nil {
return x.TabletTypes
}
return ""
}
func (x *MaterializeSettings) GetExternalCluster() string {
if x != nil {
return x.ExternalCluster
}
return ""
}
func (x *MaterializeSettings) GetMaterializationIntent() MaterializationIntent {
if x != nil {
return x.MaterializationIntent
}
return MaterializationIntent_CUSTOM
}
type Keyspace struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
Keyspace *topodata.Keyspace `protobuf:"bytes,2,opt,name=keyspace,proto3" json:"keyspace,omitempty"`
}
func (x *Keyspace) Reset() {
*x = Keyspace{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[4]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *Keyspace) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Keyspace) ProtoMessage() {}
func (x *Keyspace) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[4]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Keyspace.ProtoReflect.Descriptor instead.
func (*Keyspace) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{4}
}
func (x *Keyspace) GetName() string {
if x != nil {
return x.Name
}
return ""
}
func (x *Keyspace) GetKeyspace() *topodata.Keyspace {
if x != nil {
return x.Keyspace
}
return nil
}
type Shard struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Keyspace string `protobuf:"bytes,1,opt,name=keyspace,proto3" json:"keyspace,omitempty"`
Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
Shard *topodata.Shard `protobuf:"bytes,3,opt,name=shard,proto3" json:"shard,omitempty"`
}
func (x *Shard) Reset() {
*x = Shard{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[5]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *Shard) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Shard) ProtoMessage() {}
func (x *Shard) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[5]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Shard.ProtoReflect.Descriptor instead.
func (*Shard) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{5}
}
func (x *Shard) GetKeyspace() string {
if x != nil {
return x.Keyspace
}
return ""
}
func (x *Shard) GetName() string {
if x != nil {
return x.Name
}
return ""
}
func (x *Shard) GetShard() *topodata.Shard {
if x != nil {
return x.Shard
}
return nil
}
// TODO: comment the hell out of this.
type Workflow struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
Source *Workflow_ReplicationLocation `protobuf:"bytes,2,opt,name=source,proto3" json:"source,omitempty"`
Target *Workflow_ReplicationLocation `protobuf:"bytes,3,opt,name=target,proto3" json:"target,omitempty"`
MaxVReplicationLag int64 `protobuf:"varint,4,opt,name=max_v_replication_lag,json=maxVReplicationLag,proto3" json:"max_v_replication_lag,omitempty"`
ShardStreams map[string]*Workflow_ShardStream `protobuf:"bytes,5,rep,name=shard_streams,json=shardStreams,proto3" json:"shard_streams,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *Workflow) Reset() {
*x = Workflow{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[6]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *Workflow) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Workflow) ProtoMessage() {}
func (x *Workflow) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[6]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Workflow.ProtoReflect.Descriptor instead.
func (*Workflow) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{6}
}
func (x *Workflow) GetName() string {
if x != nil {
return x.Name
}
return ""
}
func (x *Workflow) GetSource() *Workflow_ReplicationLocation {
if x != nil {
return x.Source
}
return nil
}
func (x *Workflow) GetTarget() *Workflow_ReplicationLocation {
if x != nil {
return x.Target
}
return nil
}
func (x *Workflow) GetMaxVReplicationLag() int64 {
if x != nil {
return x.MaxVReplicationLag
}
return 0
}
func (x *Workflow) GetShardStreams() map[string]*Workflow_ShardStream {
if x != nil {
return x.ShardStreams
}
return nil
}
type AddCellInfoRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
CellInfo *topodata.CellInfo `protobuf:"bytes,2,opt,name=cell_info,json=cellInfo,proto3" json:"cell_info,omitempty"`
}
func (x *AddCellInfoRequest) Reset() {
*x = AddCellInfoRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[7]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *AddCellInfoRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*AddCellInfoRequest) ProtoMessage() {}
func (x *AddCellInfoRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[7]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use AddCellInfoRequest.ProtoReflect.Descriptor instead.
func (*AddCellInfoRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{7}
}
func (x *AddCellInfoRequest) GetName() string {
if x != nil {
return x.Name
}
return ""
}
func (x *AddCellInfoRequest) GetCellInfo() *topodata.CellInfo {
if x != nil {
return x.CellInfo
}
return nil
}
type AddCellInfoResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *AddCellInfoResponse) Reset() {
*x = AddCellInfoResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[8]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *AddCellInfoResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*AddCellInfoResponse) ProtoMessage() {}
func (x *AddCellInfoResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[8]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use AddCellInfoResponse.ProtoReflect.Descriptor instead.
func (*AddCellInfoResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{8}
}
type AddCellsAliasRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
Cells []string `protobuf:"bytes,2,rep,name=cells,proto3" json:"cells,omitempty"`
}
func (x *AddCellsAliasRequest) Reset() {
*x = AddCellsAliasRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[9]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *AddCellsAliasRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*AddCellsAliasRequest) ProtoMessage() {}
func (x *AddCellsAliasRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[9]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use AddCellsAliasRequest.ProtoReflect.Descriptor instead.
func (*AddCellsAliasRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{9}
}
func (x *AddCellsAliasRequest) GetName() string {
if x != nil {
return x.Name
}
return ""
}
func (x *AddCellsAliasRequest) GetCells() []string {
if x != nil {
return x.Cells
}
return nil
}
type AddCellsAliasResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *AddCellsAliasResponse) Reset() {
*x = AddCellsAliasResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[10]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *AddCellsAliasResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*AddCellsAliasResponse) ProtoMessage() {}
func (x *AddCellsAliasResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[10]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use AddCellsAliasResponse.ProtoReflect.Descriptor instead.
func (*AddCellsAliasResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{10}
}
type ApplyRoutingRulesRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
RoutingRules *vschema.RoutingRules `protobuf:"bytes,1,opt,name=routing_rules,json=routingRules,proto3" json:"routing_rules,omitempty"`
// SkipRebuild, if set, will cause ApplyRoutingRules to skip rebuilding the
// SrvVSchema objects in each cell in RebuildCells.
SkipRebuild bool `protobuf:"varint,2,opt,name=skip_rebuild,json=skipRebuild,proto3" json:"skip_rebuild,omitempty"`
// RebuildCells limits the SrvVSchema rebuild to the specified cells. If not
// provided the SrvVSchema will be rebuilt in every cell in the topology.
//
// Ignored if SkipRebuild is set.
RebuildCells []string `protobuf:"bytes,3,rep,name=rebuild_cells,json=rebuildCells,proto3" json:"rebuild_cells,omitempty"`
}
func (x *ApplyRoutingRulesRequest) Reset() {
*x = ApplyRoutingRulesRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[11]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ApplyRoutingRulesRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ApplyRoutingRulesRequest) ProtoMessage() {}
func (x *ApplyRoutingRulesRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[11]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ApplyRoutingRulesRequest.ProtoReflect.Descriptor instead.
func (*ApplyRoutingRulesRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{11}
}
func (x *ApplyRoutingRulesRequest) GetRoutingRules() *vschema.RoutingRules {
if x != nil {
return x.RoutingRules
}
return nil
}
func (x *ApplyRoutingRulesRequest) GetSkipRebuild() bool {
if x != nil {
return x.SkipRebuild
}
return false
}
func (x *ApplyRoutingRulesRequest) GetRebuildCells() []string {
if x != nil {
return x.RebuildCells
}
return nil
}
type ApplyRoutingRulesResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *ApplyRoutingRulesResponse) Reset() {
*x = ApplyRoutingRulesResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[12]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ApplyRoutingRulesResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ApplyRoutingRulesResponse) ProtoMessage() {}
func (x *ApplyRoutingRulesResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[12]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ApplyRoutingRulesResponse.ProtoReflect.Descriptor instead.
func (*ApplyRoutingRulesResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{12}
}
type ApplyVSchemaRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Keyspace string `protobuf:"bytes,1,opt,name=keyspace,proto3" json:"keyspace,omitempty"`
SkipRebuild bool `protobuf:"varint,2,opt,name=skip_rebuild,json=skipRebuild,proto3" json:"skip_rebuild,omitempty"`
DryRun bool `protobuf:"varint,3,opt,name=dry_run,json=dryRun,proto3" json:"dry_run,omitempty"`
Cells []string `protobuf:"bytes,4,rep,name=cells,proto3" json:"cells,omitempty"`
VSchema *vschema.Keyspace `protobuf:"bytes,5,opt,name=v_schema,json=vSchema,proto3" json:"v_schema,omitempty"`
Sql string `protobuf:"bytes,6,opt,name=sql,proto3" json:"sql,omitempty"`
}
func (x *ApplyVSchemaRequest) Reset() {
*x = ApplyVSchemaRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[13]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ApplyVSchemaRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ApplyVSchemaRequest) ProtoMessage() {}
func (x *ApplyVSchemaRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[13]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ApplyVSchemaRequest.ProtoReflect.Descriptor instead.
func (*ApplyVSchemaRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{13}
}
func (x *ApplyVSchemaRequest) GetKeyspace() string {
if x != nil {
return x.Keyspace
}
return ""
}
func (x *ApplyVSchemaRequest) GetSkipRebuild() bool {
if x != nil {
return x.SkipRebuild
}
return false
}
func (x *ApplyVSchemaRequest) GetDryRun() bool {
if x != nil {
return x.DryRun
}
return false
}
func (x *ApplyVSchemaRequest) GetCells() []string {
if x != nil {
return x.Cells
}
return nil
}
func (x *ApplyVSchemaRequest) GetVSchema() *vschema.Keyspace {
if x != nil {
return x.VSchema
}
return nil
}
func (x *ApplyVSchemaRequest) GetSql() string {
if x != nil {
return x.Sql
}
return ""
}
type ApplyVSchemaResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
VSchema *vschema.Keyspace `protobuf:"bytes,1,opt,name=v_schema,json=vSchema,proto3" json:"v_schema,omitempty"`
}
func (x *ApplyVSchemaResponse) Reset() {
*x = ApplyVSchemaResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[14]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ApplyVSchemaResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ApplyVSchemaResponse) ProtoMessage() {}
func (x *ApplyVSchemaResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[14]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ApplyVSchemaResponse.ProtoReflect.Descriptor instead.
func (*ApplyVSchemaResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{14}
}
func (x *ApplyVSchemaResponse) GetVSchema() *vschema.Keyspace {
if x != nil {
return x.VSchema
}
return nil
}
type ChangeTabletTypeRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
TabletAlias *topodata.TabletAlias `protobuf:"bytes,1,opt,name=tablet_alias,json=tabletAlias,proto3" json:"tablet_alias,omitempty"`
DbType topodata.TabletType `protobuf:"varint,2,opt,name=db_type,json=dbType,proto3,enum=topodata.TabletType" json:"db_type,omitempty"`
DryRun bool `protobuf:"varint,3,opt,name=dry_run,json=dryRun,proto3" json:"dry_run,omitempty"`
}
func (x *ChangeTabletTypeRequest) Reset() {
*x = ChangeTabletTypeRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[15]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ChangeTabletTypeRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ChangeTabletTypeRequest) ProtoMessage() {}
func (x *ChangeTabletTypeRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[15]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ChangeTabletTypeRequest.ProtoReflect.Descriptor instead.
func (*ChangeTabletTypeRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{15}
}
func (x *ChangeTabletTypeRequest) GetTabletAlias() *topodata.TabletAlias {
if x != nil {
return x.TabletAlias
}
return nil
}
func (x *ChangeTabletTypeRequest) GetDbType() topodata.TabletType {
if x != nil {
return x.DbType
}
return topodata.TabletType(0)
}
func (x *ChangeTabletTypeRequest) GetDryRun() bool {
if x != nil {
return x.DryRun
}
return false
}
type ChangeTabletTypeResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
BeforeTablet *topodata.Tablet `protobuf:"bytes,1,opt,name=before_tablet,json=beforeTablet,proto3" json:"before_tablet,omitempty"`
AfterTablet *topodata.Tablet `protobuf:"bytes,2,opt,name=after_tablet,json=afterTablet,proto3" json:"after_tablet,omitempty"`
WasDryRun bool `protobuf:"varint,3,opt,name=was_dry_run,json=wasDryRun,proto3" json:"was_dry_run,omitempty"`
}
func (x *ChangeTabletTypeResponse) Reset() {
*x = ChangeTabletTypeResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[16]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ChangeTabletTypeResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ChangeTabletTypeResponse) ProtoMessage() {}
func (x *ChangeTabletTypeResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[16]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ChangeTabletTypeResponse.ProtoReflect.Descriptor instead.
func (*ChangeTabletTypeResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{16}
}
func (x *ChangeTabletTypeResponse) GetBeforeTablet() *topodata.Tablet {
if x != nil {
return x.BeforeTablet
}
return nil
}
func (x *ChangeTabletTypeResponse) GetAfterTablet() *topodata.Tablet {
if x != nil {
return x.AfterTablet
}
return nil
}
func (x *ChangeTabletTypeResponse) GetWasDryRun() bool {
if x != nil {
return x.WasDryRun
}
return false
}
type CreateKeyspaceRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Name is the name of the keyspace.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// Force proceeds with the request even if the keyspace already exists.
Force bool `protobuf:"varint,2,opt,name=force,proto3" json:"force,omitempty"`
// AllowEmptyVSchema allows a keyspace to be created with no vschema.
AllowEmptyVSchema bool `protobuf:"varint,3,opt,name=allow_empty_v_schema,json=allowEmptyVSchema,proto3" json:"allow_empty_v_schema,omitempty"`
// ShardingColumnName specifies the column to use for sharding operations.
ShardingColumnName string `protobuf:"bytes,4,opt,name=sharding_column_name,json=shardingColumnName,proto3" json:"sharding_column_name,omitempty"`
// ShardingColumnType specifies the type of the column to use for sharding
// operations.
ShardingColumnType topodata.KeyspaceIdType `protobuf:"varint,5,opt,name=sharding_column_type,json=shardingColumnType,proto3,enum=topodata.KeyspaceIdType" json:"sharding_column_type,omitempty"`
// ServedFroms specifies a set of db_type:keyspace pairs used to serve
// traffic for the keyspace.
ServedFroms []*topodata.Keyspace_ServedFrom `protobuf:"bytes,6,rep,name=served_froms,json=servedFroms,proto3" json:"served_froms,omitempty"`
// Type is the type of the keyspace to create.
Type topodata.KeyspaceType `protobuf:"varint,7,opt,name=type,proto3,enum=topodata.KeyspaceType" json:"type,omitempty"`
// BaseKeyspace specifies the base keyspace for SNAPSHOT keyspaces. It is
// required to create a SNAPSHOT keyspace.
BaseKeyspace string `protobuf:"bytes,8,opt,name=base_keyspace,json=baseKeyspace,proto3" json:"base_keyspace,omitempty"`
// SnapshotTime specifies the snapshot time for this keyspace. It is required
// to create a SNAPSHOT keyspace.
SnapshotTime *vttime.Time `protobuf:"bytes,9,opt,name=snapshot_time,json=snapshotTime,proto3" json:"snapshot_time,omitempty"`
}
func (x *CreateKeyspaceRequest) Reset() {
*x = CreateKeyspaceRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[17]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *CreateKeyspaceRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*CreateKeyspaceRequest) ProtoMessage() {}
func (x *CreateKeyspaceRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[17]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use CreateKeyspaceRequest.ProtoReflect.Descriptor instead.
func (*CreateKeyspaceRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{17}
}
func (x *CreateKeyspaceRequest) GetName() string {
if x != nil {
return x.Name
}
return ""
}
func (x *CreateKeyspaceRequest) GetForce() bool {
if x != nil {
return x.Force
}
return false
}
func (x *CreateKeyspaceRequest) GetAllowEmptyVSchema() bool {
if x != nil {
return x.AllowEmptyVSchema
}
return false
}
func (x *CreateKeyspaceRequest) GetShardingColumnName() string {
if x != nil {
return x.ShardingColumnName
}
return ""
}
func (x *CreateKeyspaceRequest) GetShardingColumnType() topodata.KeyspaceIdType {
if x != nil {
return x.ShardingColumnType
}
return topodata.KeyspaceIdType(0)
}
func (x *CreateKeyspaceRequest) GetServedFroms() []*topodata.Keyspace_ServedFrom {
if x != nil {
return x.ServedFroms
}
return nil
}
func (x *CreateKeyspaceRequest) GetType() topodata.KeyspaceType {
if x != nil {
return x.Type
}
return topodata.KeyspaceType(0)
}
func (x *CreateKeyspaceRequest) GetBaseKeyspace() string {
if x != nil {
return x.BaseKeyspace
}
return ""
}
func (x *CreateKeyspaceRequest) GetSnapshotTime() *vttime.Time {
if x != nil {
return x.SnapshotTime
}
return nil
}
type CreateKeyspaceResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Keyspace is the newly-created keyspace.
Keyspace *Keyspace `protobuf:"bytes,1,opt,name=keyspace,proto3" json:"keyspace,omitempty"`
}
func (x *CreateKeyspaceResponse) Reset() {
*x = CreateKeyspaceResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[18]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *CreateKeyspaceResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*CreateKeyspaceResponse) ProtoMessage() {}
func (x *CreateKeyspaceResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[18]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use CreateKeyspaceResponse.ProtoReflect.Descriptor instead.
func (*CreateKeyspaceResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{18}
}
func (x *CreateKeyspaceResponse) GetKeyspace() *Keyspace {
if x != nil {
return x.Keyspace
}
return nil
}
type CreateShardRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Keyspace is the name of the keyspace to create the shard in.
Keyspace string `protobuf:"bytes,1,opt,name=keyspace,proto3" json:"keyspace,omitempty"`
// ShardName is the name of the shard to create. E.g. "-" or "-80".
ShardName string `protobuf:"bytes,2,opt,name=shard_name,json=shardName,proto3" json:"shard_name,omitempty"`
// Force treats an attempt to create a shard that already exists as a
// non-error.
Force bool `protobuf:"varint,3,opt,name=force,proto3" json:"force,omitempty"`
// IncludeParent creates the parent keyspace as an empty BASE keyspace, if it
// doesn't already exist.
IncludeParent bool `protobuf:"varint,4,opt,name=include_parent,json=includeParent,proto3" json:"include_parent,omitempty"`
}
func (x *CreateShardRequest) Reset() {
*x = CreateShardRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[19]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *CreateShardRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*CreateShardRequest) ProtoMessage() {}
func (x *CreateShardRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[19]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use CreateShardRequest.ProtoReflect.Descriptor instead.
func (*CreateShardRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{19}
}
func (x *CreateShardRequest) GetKeyspace() string {
if x != nil {
return x.Keyspace
}
return ""
}
func (x *CreateShardRequest) GetShardName() string {
if x != nil {
return x.ShardName
}
return ""
}
func (x *CreateShardRequest) GetForce() bool {
if x != nil {
return x.Force
}
return false
}
func (x *CreateShardRequest) GetIncludeParent() bool {
if x != nil {
return x.IncludeParent
}
return false
}
type CreateShardResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Keyspace is the created keyspace. It is set only if IncludeParent was
// specified in the request and the parent keyspace needed to be created.
Keyspace *Keyspace `protobuf:"bytes,1,opt,name=keyspace,proto3" json:"keyspace,omitempty"`
// Shard is the newly-created shard object.
Shard *Shard `protobuf:"bytes,2,opt,name=shard,proto3" json:"shard,omitempty"`
// ShardAlreadyExists is set if Force was specified in the request and the
// shard already existed.
ShardAlreadyExists bool `protobuf:"varint,3,opt,name=shard_already_exists,json=shardAlreadyExists,proto3" json:"shard_already_exists,omitempty"`
}
func (x *CreateShardResponse) Reset() {
*x = CreateShardResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[20]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *CreateShardResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*CreateShardResponse) ProtoMessage() {}
func (x *CreateShardResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[20]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use CreateShardResponse.ProtoReflect.Descriptor instead.
func (*CreateShardResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{20}
}
func (x *CreateShardResponse) GetKeyspace() *Keyspace {
if x != nil {
return x.Keyspace
}
return nil
}
func (x *CreateShardResponse) GetShard() *Shard {
if x != nil {
return x.Shard
}
return nil
}
func (x *CreateShardResponse) GetShardAlreadyExists() bool {
if x != nil {
return x.ShardAlreadyExists
}
return false
}
type DeleteCellInfoRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
Force bool `protobuf:"varint,2,opt,name=force,proto3" json:"force,omitempty"`
}
func (x *DeleteCellInfoRequest) Reset() {
*x = DeleteCellInfoRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[21]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *DeleteCellInfoRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*DeleteCellInfoRequest) ProtoMessage() {}
func (x *DeleteCellInfoRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[21]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use DeleteCellInfoRequest.ProtoReflect.Descriptor instead.
func (*DeleteCellInfoRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{21}
}
func (x *DeleteCellInfoRequest) GetName() string {
if x != nil {
return x.Name
}
return ""
}
func (x *DeleteCellInfoRequest) GetForce() bool {
if x != nil {
return x.Force
}
return false
}
type DeleteCellInfoResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *DeleteCellInfoResponse) Reset() {
*x = DeleteCellInfoResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[22]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *DeleteCellInfoResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*DeleteCellInfoResponse) ProtoMessage() {}
func (x *DeleteCellInfoResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[22]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use DeleteCellInfoResponse.ProtoReflect.Descriptor instead.
func (*DeleteCellInfoResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{22}
}
type DeleteCellsAliasRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
}
func (x *DeleteCellsAliasRequest) Reset() {
*x = DeleteCellsAliasRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[23]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *DeleteCellsAliasRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*DeleteCellsAliasRequest) ProtoMessage() {}
func (x *DeleteCellsAliasRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[23]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use DeleteCellsAliasRequest.ProtoReflect.Descriptor instead.
func (*DeleteCellsAliasRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{23}
}
func (x *DeleteCellsAliasRequest) GetName() string {
if x != nil {
return x.Name
}
return ""
}
type DeleteCellsAliasResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *DeleteCellsAliasResponse) Reset() {
*x = DeleteCellsAliasResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[24]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *DeleteCellsAliasResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*DeleteCellsAliasResponse) ProtoMessage() {}
func (x *DeleteCellsAliasResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[24]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use DeleteCellsAliasResponse.ProtoReflect.Descriptor instead.
func (*DeleteCellsAliasResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{24}
}
type DeleteKeyspaceRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Keyspace is the name of the keyspace to delete.
Keyspace string `protobuf:"bytes,1,opt,name=keyspace,proto3" json:"keyspace,omitempty"`
// Recursive causes all shards in the keyspace to be recursively deleted
// before deleting the keyspace. It is an error to call DeleteKeyspace on a
// non-empty keyspace without also specifying Recursive.
Recursive bool `protobuf:"varint,2,opt,name=recursive,proto3" json:"recursive,omitempty"`
}
func (x *DeleteKeyspaceRequest) Reset() {
*x = DeleteKeyspaceRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[25]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *DeleteKeyspaceRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*DeleteKeyspaceRequest) ProtoMessage() {}
func (x *DeleteKeyspaceRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[25]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use DeleteKeyspaceRequest.ProtoReflect.Descriptor instead.
func (*DeleteKeyspaceRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{25}
}
func (x *DeleteKeyspaceRequest) GetKeyspace() string {
if x != nil {
return x.Keyspace
}
return ""
}
func (x *DeleteKeyspaceRequest) GetRecursive() bool {
if x != nil {
return x.Recursive
}
return false
}
type DeleteKeyspaceResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *DeleteKeyspaceResponse) Reset() {
*x = DeleteKeyspaceResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[26]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *DeleteKeyspaceResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*DeleteKeyspaceResponse) ProtoMessage() {}
func (x *DeleteKeyspaceResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[26]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use DeleteKeyspaceResponse.ProtoReflect.Descriptor instead.
func (*DeleteKeyspaceResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{26}
}
type DeleteShardsRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Shards is the list of shards to delete. The nested topodatapb.Shard field
// is not required for DeleteShard, but the Keyspace and Shard fields are.
Shards []*Shard `protobuf:"bytes,1,rep,name=shards,proto3" json:"shards,omitempty"`
// Recursive also deletes all tablets belonging to the shard(s). It is an
// error to call DeleteShard on a non-empty shard without also specificying
// Recursive.
Recursive bool `protobuf:"varint,2,opt,name=recursive,proto3" json:"recursive,omitempty"`
// EvenIfServing allows a shard to be deleted even if it is serving, which is
// normally an error. Use with caution.
EvenIfServing bool `protobuf:"varint,4,opt,name=even_if_serving,json=evenIfServing,proto3" json:"even_if_serving,omitempty"`
}
func (x *DeleteShardsRequest) Reset() {
*x = DeleteShardsRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[27]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *DeleteShardsRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*DeleteShardsRequest) ProtoMessage() {}
func (x *DeleteShardsRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[27]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use DeleteShardsRequest.ProtoReflect.Descriptor instead.
func (*DeleteShardsRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{27}
}
func (x *DeleteShardsRequest) GetShards() []*Shard {
if x != nil {
return x.Shards
}
return nil
}
func (x *DeleteShardsRequest) GetRecursive() bool {
if x != nil {
return x.Recursive
}
return false
}
func (x *DeleteShardsRequest) GetEvenIfServing() bool {
if x != nil {
return x.EvenIfServing
}
return false
}
type DeleteShardsResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *DeleteShardsResponse) Reset() {
*x = DeleteShardsResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[28]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *DeleteShardsResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*DeleteShardsResponse) ProtoMessage() {}
func (x *DeleteShardsResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[28]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use DeleteShardsResponse.ProtoReflect.Descriptor instead.
func (*DeleteShardsResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{28}
}
type DeleteSrvVSchemaRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Cell string `protobuf:"bytes,1,opt,name=cell,proto3" json:"cell,omitempty"`
}
func (x *DeleteSrvVSchemaRequest) Reset() {
*x = DeleteSrvVSchemaRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[29]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *DeleteSrvVSchemaRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*DeleteSrvVSchemaRequest) ProtoMessage() {}
func (x *DeleteSrvVSchemaRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[29]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use DeleteSrvVSchemaRequest.ProtoReflect.Descriptor instead.
func (*DeleteSrvVSchemaRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{29}
}
func (x *DeleteSrvVSchemaRequest) GetCell() string {
if x != nil {
return x.Cell
}
return ""
}
type DeleteSrvVSchemaResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *DeleteSrvVSchemaResponse) Reset() {
*x = DeleteSrvVSchemaResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[30]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *DeleteSrvVSchemaResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*DeleteSrvVSchemaResponse) ProtoMessage() {}
func (x *DeleteSrvVSchemaResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[30]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use DeleteSrvVSchemaResponse.ProtoReflect.Descriptor instead.
func (*DeleteSrvVSchemaResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{30}
}
type DeleteTabletsRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// TabletAliases is the list of tablets to delete.
TabletAliases []*topodata.TabletAlias `protobuf:"bytes,1,rep,name=tablet_aliases,json=tabletAliases,proto3" json:"tablet_aliases,omitempty"`
// AllowPrimary allows for the primary tablet of a shard to be deleted.
// Use with caution.
AllowPrimary bool `protobuf:"varint,2,opt,name=allow_primary,json=allowPrimary,proto3" json:"allow_primary,omitempty"`
}
func (x *DeleteTabletsRequest) Reset() {
*x = DeleteTabletsRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[31]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *DeleteTabletsRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*DeleteTabletsRequest) ProtoMessage() {}
func (x *DeleteTabletsRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[31]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use DeleteTabletsRequest.ProtoReflect.Descriptor instead.
func (*DeleteTabletsRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{31}
}
func (x *DeleteTabletsRequest) GetTabletAliases() []*topodata.TabletAlias {
if x != nil {
return x.TabletAliases
}
return nil
}
func (x *DeleteTabletsRequest) GetAllowPrimary() bool {
if x != nil {
return x.AllowPrimary
}
return false
}
type DeleteTabletsResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *DeleteTabletsResponse) Reset() {
*x = DeleteTabletsResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[32]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *DeleteTabletsResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*DeleteTabletsResponse) ProtoMessage() {}
func (x *DeleteTabletsResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[32]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use DeleteTabletsResponse.ProtoReflect.Descriptor instead.
func (*DeleteTabletsResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{32}
}
type EmergencyReparentShardRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Keyspace is the name of the keyspace to perform the Emergency Reparent in.
Keyspace string `protobuf:"bytes,1,opt,name=keyspace,proto3" json:"keyspace,omitempty"`
// Shard is the name of the shard to perform the Emergency Reparent in.
Shard string `protobuf:"bytes,2,opt,name=shard,proto3" json:"shard,omitempty"`
// Optional alias of a tablet that should become the new shard primary. If not
// not specified, the vtctld will select the most up-to-date canditate to
// promote.
NewPrimary *topodata.TabletAlias `protobuf:"bytes,3,opt,name=new_primary,json=newPrimary,proto3" json:"new_primary,omitempty"`
// List of replica aliases to ignore during the Emergency Reparent. The vtctld
// will not attempt to stop replication on these tablets, nor attempt to
// demote any that may think they are the shard primary.
IgnoreReplicas []*topodata.TabletAlias `protobuf:"bytes,4,rep,name=ignore_replicas,json=ignoreReplicas,proto3" json:"ignore_replicas,omitempty"`
// WaitReplicasTimeout is the duration of time to wait for replicas to catch
// up in reparenting.
WaitReplicasTimeout *vttime.Duration `protobuf:"bytes,5,opt,name=wait_replicas_timeout,json=waitReplicasTimeout,proto3" json:"wait_replicas_timeout,omitempty"`
}
func (x *EmergencyReparentShardRequest) Reset() {
*x = EmergencyReparentShardRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[33]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *EmergencyReparentShardRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*EmergencyReparentShardRequest) ProtoMessage() {}
func (x *EmergencyReparentShardRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[33]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use EmergencyReparentShardRequest.ProtoReflect.Descriptor instead.
func (*EmergencyReparentShardRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{33}
}
func (x *EmergencyReparentShardRequest) GetKeyspace() string {
if x != nil {
return x.Keyspace
}
return ""
}
func (x *EmergencyReparentShardRequest) GetShard() string {
if x != nil {
return x.Shard
}
return ""
}
func (x *EmergencyReparentShardRequest) GetNewPrimary() *topodata.TabletAlias {
if x != nil {
return x.NewPrimary
}
return nil
}
func (x *EmergencyReparentShardRequest) GetIgnoreReplicas() []*topodata.TabletAlias {
if x != nil {
return x.IgnoreReplicas
}
return nil
}
func (x *EmergencyReparentShardRequest) GetWaitReplicasTimeout() *vttime.Duration {
if x != nil {
return x.WaitReplicasTimeout
}
return nil
}
type EmergencyReparentShardResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Keyspace is the name of the keyspace the Emergency Reparent took place in.
Keyspace string `protobuf:"bytes,1,opt,name=keyspace,proto3" json:"keyspace,omitempty"`
// Shard is the name of the shard the Emergency Reparent took place in.
Shard string `protobuf:"bytes,2,opt,name=shard,proto3" json:"shard,omitempty"`
// PromotedPrimary is the alias of the tablet that was promoted to shard
// primary. If NewPrimary was set in the request, then this will be the same
// alias. Otherwise, it will be the alias of the tablet found to be most
// up-to-date.
PromotedPrimary *topodata.TabletAlias `protobuf:"bytes,3,opt,name=promoted_primary,json=promotedPrimary,proto3" json:"promoted_primary,omitempty"`
Events []*logutil.Event `protobuf:"bytes,4,rep,name=events,proto3" json:"events,omitempty"`
}
func (x *EmergencyReparentShardResponse) Reset() {
*x = EmergencyReparentShardResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[34]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *EmergencyReparentShardResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*EmergencyReparentShardResponse) ProtoMessage() {}
func (x *EmergencyReparentShardResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[34]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use EmergencyReparentShardResponse.ProtoReflect.Descriptor instead.
func (*EmergencyReparentShardResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{34}
}
func (x *EmergencyReparentShardResponse) GetKeyspace() string {
if x != nil {
return x.Keyspace
}
return ""
}
func (x *EmergencyReparentShardResponse) GetShard() string {
if x != nil {
return x.Shard
}
return ""
}
func (x *EmergencyReparentShardResponse) GetPromotedPrimary() *topodata.TabletAlias {
if x != nil {
return x.PromotedPrimary
}
return nil
}
func (x *EmergencyReparentShardResponse) GetEvents() []*logutil.Event {
if x != nil {
return x.Events
}
return nil
}
type FindAllShardsInKeyspaceRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Keyspace string `protobuf:"bytes,1,opt,name=keyspace,proto3" json:"keyspace,omitempty"`
}
func (x *FindAllShardsInKeyspaceRequest) Reset() {
*x = FindAllShardsInKeyspaceRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[35]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *FindAllShardsInKeyspaceRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*FindAllShardsInKeyspaceRequest) ProtoMessage() {}
func (x *FindAllShardsInKeyspaceRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[35]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use FindAllShardsInKeyspaceRequest.ProtoReflect.Descriptor instead.
func (*FindAllShardsInKeyspaceRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{35}
}
func (x *FindAllShardsInKeyspaceRequest) GetKeyspace() string {
if x != nil {
return x.Keyspace
}
return ""
}
type FindAllShardsInKeyspaceResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Shards map[string]*Shard `protobuf:"bytes,1,rep,name=shards,proto3" json:"shards,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *FindAllShardsInKeyspaceResponse) Reset() {
*x = FindAllShardsInKeyspaceResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[36]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *FindAllShardsInKeyspaceResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*FindAllShardsInKeyspaceResponse) ProtoMessage() {}
func (x *FindAllShardsInKeyspaceResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[36]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use FindAllShardsInKeyspaceResponse.ProtoReflect.Descriptor instead.
func (*FindAllShardsInKeyspaceResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{36}
}
func (x *FindAllShardsInKeyspaceResponse) GetShards() map[string]*Shard {
if x != nil {
return x.Shards
}
return nil
}
type GetBackupsRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Keyspace string `protobuf:"bytes,1,opt,name=keyspace,proto3" json:"keyspace,omitempty"`
Shard string `protobuf:"bytes,2,opt,name=shard,proto3" json:"shard,omitempty"`
// Limit, if nonzero, will return only the most N recent backups.
Limit uint32 `protobuf:"varint,3,opt,name=limit,proto3" json:"limit,omitempty"`
// Detailed indicates whether to use the backupengine, if supported, to
// populate additional fields, such as Engine and Status, on BackupInfo
// objects in the response. If not set, or if the backupengine does not
// support populating these fields, Engine will always be empty, and Status
// will always be UNKNOWN.
Detailed bool `protobuf:"varint,4,opt,name=detailed,proto3" json:"detailed,omitempty"`
// DetailedLimit, if nonzero, will only populate additional fields (see Detailed)
// on the N most recent backups. The Limit field still dictates the total
// number of backup info objects returned, so, in reality, min(Limit, DetailedLimit)
// backup infos will have additional fields set, and any remaining backups
// will not.
DetailedLimit uint32 `protobuf:"varint,5,opt,name=detailed_limit,json=detailedLimit,proto3" json:"detailed_limit,omitempty"`
}
func (x *GetBackupsRequest) Reset() {
*x = GetBackupsRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[37]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetBackupsRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetBackupsRequest) ProtoMessage() {}
func (x *GetBackupsRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[37]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetBackupsRequest.ProtoReflect.Descriptor instead.
func (*GetBackupsRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{37}
}
func (x *GetBackupsRequest) GetKeyspace() string {
if x != nil {
return x.Keyspace
}
return ""
}
func (x *GetBackupsRequest) GetShard() string {
if x != nil {
return x.Shard
}
return ""
}
func (x *GetBackupsRequest) GetLimit() uint32 {
if x != nil {
return x.Limit
}
return 0
}
func (x *GetBackupsRequest) GetDetailed() bool {
if x != nil {
return x.Detailed
}
return false
}
func (x *GetBackupsRequest) GetDetailedLimit() uint32 {
if x != nil {
return x.DetailedLimit
}
return 0
}
type GetBackupsResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Backups []*mysqlctl.BackupInfo `protobuf:"bytes,1,rep,name=backups,proto3" json:"backups,omitempty"`
}
func (x *GetBackupsResponse) Reset() {
*x = GetBackupsResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[38]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetBackupsResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetBackupsResponse) ProtoMessage() {}
func (x *GetBackupsResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[38]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetBackupsResponse.ProtoReflect.Descriptor instead.
func (*GetBackupsResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{38}
}
func (x *GetBackupsResponse) GetBackups() []*mysqlctl.BackupInfo {
if x != nil {
return x.Backups
}
return nil
}
type GetCellInfoRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Cell string `protobuf:"bytes,1,opt,name=cell,proto3" json:"cell,omitempty"`
}
func (x *GetCellInfoRequest) Reset() {
*x = GetCellInfoRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[39]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetCellInfoRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetCellInfoRequest) ProtoMessage() {}
func (x *GetCellInfoRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[39]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetCellInfoRequest.ProtoReflect.Descriptor instead.
func (*GetCellInfoRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{39}
}
func (x *GetCellInfoRequest) GetCell() string {
if x != nil {
return x.Cell
}
return ""
}
type GetCellInfoResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
CellInfo *topodata.CellInfo `protobuf:"bytes,1,opt,name=cell_info,json=cellInfo,proto3" json:"cell_info,omitempty"`
}
func (x *GetCellInfoResponse) Reset() {
*x = GetCellInfoResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[40]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetCellInfoResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetCellInfoResponse) ProtoMessage() {}
func (x *GetCellInfoResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[40]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetCellInfoResponse.ProtoReflect.Descriptor instead.
func (*GetCellInfoResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{40}
}
func (x *GetCellInfoResponse) GetCellInfo() *topodata.CellInfo {
if x != nil {
return x.CellInfo
}
return nil
}
type GetCellInfoNamesRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *GetCellInfoNamesRequest) Reset() {
*x = GetCellInfoNamesRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[41]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetCellInfoNamesRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetCellInfoNamesRequest) ProtoMessage() {}
func (x *GetCellInfoNamesRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[41]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetCellInfoNamesRequest.ProtoReflect.Descriptor instead.
func (*GetCellInfoNamesRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{41}
}
type GetCellInfoNamesResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Names []string `protobuf:"bytes,1,rep,name=names,proto3" json:"names,omitempty"`
}
func (x *GetCellInfoNamesResponse) Reset() {
*x = GetCellInfoNamesResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[42]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetCellInfoNamesResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetCellInfoNamesResponse) ProtoMessage() {}
func (x *GetCellInfoNamesResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[42]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetCellInfoNamesResponse.ProtoReflect.Descriptor instead.
func (*GetCellInfoNamesResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{42}
}
func (x *GetCellInfoNamesResponse) GetNames() []string {
if x != nil {
return x.Names
}
return nil
}
type GetCellsAliasesRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *GetCellsAliasesRequest) Reset() {
*x = GetCellsAliasesRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[43]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetCellsAliasesRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetCellsAliasesRequest) ProtoMessage() {}
func (x *GetCellsAliasesRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[43]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetCellsAliasesRequest.ProtoReflect.Descriptor instead.
func (*GetCellsAliasesRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{43}
}
type GetCellsAliasesResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Aliases map[string]*topodata.CellsAlias `protobuf:"bytes,1,rep,name=aliases,proto3" json:"aliases,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *GetCellsAliasesResponse) Reset() {
*x = GetCellsAliasesResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[44]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetCellsAliasesResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetCellsAliasesResponse) ProtoMessage() {}
func (x *GetCellsAliasesResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[44]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetCellsAliasesResponse.ProtoReflect.Descriptor instead.
func (*GetCellsAliasesResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{44}
}
func (x *GetCellsAliasesResponse) GetAliases() map[string]*topodata.CellsAlias {
if x != nil {
return x.Aliases
}
return nil
}
type GetKeyspacesRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *GetKeyspacesRequest) Reset() {
*x = GetKeyspacesRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[45]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetKeyspacesRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetKeyspacesRequest) ProtoMessage() {}
func (x *GetKeyspacesRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[45]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetKeyspacesRequest.ProtoReflect.Descriptor instead.
func (*GetKeyspacesRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{45}
}
type GetKeyspacesResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Keyspaces []*Keyspace `protobuf:"bytes,1,rep,name=keyspaces,proto3" json:"keyspaces,omitempty"`
}
func (x *GetKeyspacesResponse) Reset() {
*x = GetKeyspacesResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[46]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetKeyspacesResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetKeyspacesResponse) ProtoMessage() {}
func (x *GetKeyspacesResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[46]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetKeyspacesResponse.ProtoReflect.Descriptor instead.
func (*GetKeyspacesResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{46}
}
func (x *GetKeyspacesResponse) GetKeyspaces() []*Keyspace {
if x != nil {
return x.Keyspaces
}
return nil
}
type GetKeyspaceRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Keyspace string `protobuf:"bytes,1,opt,name=keyspace,proto3" json:"keyspace,omitempty"`
}
func (x *GetKeyspaceRequest) Reset() {
*x = GetKeyspaceRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[47]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetKeyspaceRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetKeyspaceRequest) ProtoMessage() {}
func (x *GetKeyspaceRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[47]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetKeyspaceRequest.ProtoReflect.Descriptor instead.
func (*GetKeyspaceRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{47}
}
func (x *GetKeyspaceRequest) GetKeyspace() string {
if x != nil {
return x.Keyspace
}
return ""
}
type GetKeyspaceResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Keyspace *Keyspace `protobuf:"bytes,1,opt,name=keyspace,proto3" json:"keyspace,omitempty"`
}
func (x *GetKeyspaceResponse) Reset() {
*x = GetKeyspaceResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[48]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetKeyspaceResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetKeyspaceResponse) ProtoMessage() {}
func (x *GetKeyspaceResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[48]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetKeyspaceResponse.ProtoReflect.Descriptor instead.
func (*GetKeyspaceResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{48}
}
func (x *GetKeyspaceResponse) GetKeyspace() *Keyspace {
if x != nil {
return x.Keyspace
}
return nil
}
type GetRoutingRulesRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *GetRoutingRulesRequest) Reset() {
*x = GetRoutingRulesRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[49]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetRoutingRulesRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetRoutingRulesRequest) ProtoMessage() {}
func (x *GetRoutingRulesRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[49]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetRoutingRulesRequest.ProtoReflect.Descriptor instead.
func (*GetRoutingRulesRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{49}
}
type GetRoutingRulesResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
RoutingRules *vschema.RoutingRules `protobuf:"bytes,1,opt,name=routing_rules,json=routingRules,proto3" json:"routing_rules,omitempty"`
}
func (x *GetRoutingRulesResponse) Reset() {
*x = GetRoutingRulesResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[50]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetRoutingRulesResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetRoutingRulesResponse) ProtoMessage() {}
func (x *GetRoutingRulesResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[50]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetRoutingRulesResponse.ProtoReflect.Descriptor instead.
func (*GetRoutingRulesResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{50}
}
func (x *GetRoutingRulesResponse) GetRoutingRules() *vschema.RoutingRules {
if x != nil {
return x.RoutingRules
}
return nil
}
type GetSchemaRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
TabletAlias *topodata.TabletAlias `protobuf:"bytes,1,opt,name=tablet_alias,json=tabletAlias,proto3" json:"tablet_alias,omitempty"`
// Tables is a list of tables for which we should gather information. Each is
// either an exact match, or a regular expression of the form /regexp/.
Tables []string `protobuf:"bytes,2,rep,name=tables,proto3" json:"tables,omitempty"`
// ExcludeTables is a list of tables to exclude from the result. Each is
// either an exact match, or a regular expression of the form /regexp/.
ExcludeTables []string `protobuf:"bytes,3,rep,name=exclude_tables,json=excludeTables,proto3" json:"exclude_tables,omitempty"`
// IncludeViews specifies whether to include views in the result.
IncludeViews bool `protobuf:"varint,4,opt,name=include_views,json=includeViews,proto3" json:"include_views,omitempty"`
// TableNamesOnly specifies whether to limit the results to just table names,
// rather than full schema information for each table.
TableNamesOnly bool `protobuf:"varint,5,opt,name=table_names_only,json=tableNamesOnly,proto3" json:"table_names_only,omitempty"`
// TableSizesOnly specifies whether to limit the results to just table sizes,
// rather than full schema information for each table. It is ignored if
// TableNamesOnly is set to true.
TableSizesOnly bool `protobuf:"varint,6,opt,name=table_sizes_only,json=tableSizesOnly,proto3" json:"table_sizes_only,omitempty"`
}
func (x *GetSchemaRequest) Reset() {
*x = GetSchemaRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[51]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetSchemaRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetSchemaRequest) ProtoMessage() {}
func (x *GetSchemaRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[51]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetSchemaRequest.ProtoReflect.Descriptor instead.
func (*GetSchemaRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{51}
}
func (x *GetSchemaRequest) GetTabletAlias() *topodata.TabletAlias {
if x != nil {
return x.TabletAlias
}
return nil
}
func (x *GetSchemaRequest) GetTables() []string {
if x != nil {
return x.Tables
}
return nil
}
func (x *GetSchemaRequest) GetExcludeTables() []string {
if x != nil {
return x.ExcludeTables
}
return nil
}
func (x *GetSchemaRequest) GetIncludeViews() bool {
if x != nil {
return x.IncludeViews
}
return false
}
func (x *GetSchemaRequest) GetTableNamesOnly() bool {
if x != nil {
return x.TableNamesOnly
}
return false
}
func (x *GetSchemaRequest) GetTableSizesOnly() bool {
if x != nil {
return x.TableSizesOnly
}
return false
}
type GetSchemaResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Schema *tabletmanagerdata.SchemaDefinition `protobuf:"bytes,1,opt,name=schema,proto3" json:"schema,omitempty"`
}
func (x *GetSchemaResponse) Reset() {
*x = GetSchemaResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[52]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetSchemaResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetSchemaResponse) ProtoMessage() {}
func (x *GetSchemaResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[52]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetSchemaResponse.ProtoReflect.Descriptor instead.
func (*GetSchemaResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{52}
}
func (x *GetSchemaResponse) GetSchema() *tabletmanagerdata.SchemaDefinition {
if x != nil {
return x.Schema
}
return nil
}
type GetShardRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Keyspace string `protobuf:"bytes,1,opt,name=keyspace,proto3" json:"keyspace,omitempty"`
ShardName string `protobuf:"bytes,2,opt,name=shard_name,json=shardName,proto3" json:"shard_name,omitempty"`
}
func (x *GetShardRequest) Reset() {
*x = GetShardRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[53]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetShardRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetShardRequest) ProtoMessage() {}
func (x *GetShardRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[53]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetShardRequest.ProtoReflect.Descriptor instead.
func (*GetShardRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{53}
}
func (x *GetShardRequest) GetKeyspace() string {
if x != nil {
return x.Keyspace
}
return ""
}
func (x *GetShardRequest) GetShardName() string {
if x != nil {
return x.ShardName
}
return ""
}
type GetShardResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Shard *Shard `protobuf:"bytes,1,opt,name=shard,proto3" json:"shard,omitempty"`
}
func (x *GetShardResponse) Reset() {
*x = GetShardResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[54]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetShardResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetShardResponse) ProtoMessage() {}
func (x *GetShardResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[54]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetShardResponse.ProtoReflect.Descriptor instead.
func (*GetShardResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{54}
}
func (x *GetShardResponse) GetShard() *Shard {
if x != nil {
return x.Shard
}
return nil
}
type GetSrvKeyspaceNamesRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Cells []string `protobuf:"bytes,1,rep,name=cells,proto3" json:"cells,omitempty"`
}
func (x *GetSrvKeyspaceNamesRequest) Reset() {
*x = GetSrvKeyspaceNamesRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[55]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetSrvKeyspaceNamesRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetSrvKeyspaceNamesRequest) ProtoMessage() {}
func (x *GetSrvKeyspaceNamesRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[55]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetSrvKeyspaceNamesRequest.ProtoReflect.Descriptor instead.
func (*GetSrvKeyspaceNamesRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{55}
}
func (x *GetSrvKeyspaceNamesRequest) GetCells() []string {
if x != nil {
return x.Cells
}
return nil
}
type GetSrvKeyspaceNamesResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Names is a mapping of cell name to a list of SrvKeyspace names.
Names map[string]*GetSrvKeyspaceNamesResponse_NameList `protobuf:"bytes,1,rep,name=names,proto3" json:"names,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *GetSrvKeyspaceNamesResponse) Reset() {
*x = GetSrvKeyspaceNamesResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[56]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetSrvKeyspaceNamesResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetSrvKeyspaceNamesResponse) ProtoMessage() {}
func (x *GetSrvKeyspaceNamesResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[56]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetSrvKeyspaceNamesResponse.ProtoReflect.Descriptor instead.
func (*GetSrvKeyspaceNamesResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{56}
}
func (x *GetSrvKeyspaceNamesResponse) GetNames() map[string]*GetSrvKeyspaceNamesResponse_NameList {
if x != nil {
return x.Names
}
return nil
}
type GetSrvKeyspacesRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Keyspace string `protobuf:"bytes,1,opt,name=keyspace,proto3" json:"keyspace,omitempty"`
// Cells is a list of cells to lookup a SrvKeyspace for. Leaving this empty is
// equivalent to specifying all cells in the topo.
Cells []string `protobuf:"bytes,2,rep,name=cells,proto3" json:"cells,omitempty"`
}
func (x *GetSrvKeyspacesRequest) Reset() {
*x = GetSrvKeyspacesRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[57]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetSrvKeyspacesRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetSrvKeyspacesRequest) ProtoMessage() {}
func (x *GetSrvKeyspacesRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[57]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetSrvKeyspacesRequest.ProtoReflect.Descriptor instead.
func (*GetSrvKeyspacesRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{57}
}
func (x *GetSrvKeyspacesRequest) GetKeyspace() string {
if x != nil {
return x.Keyspace
}
return ""
}
func (x *GetSrvKeyspacesRequest) GetCells() []string {
if x != nil {
return x.Cells
}
return nil
}
type GetSrvKeyspacesResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// SrvKeyspaces is a mapping of cell name to SrvKeyspace.
SrvKeyspaces map[string]*topodata.SrvKeyspace `protobuf:"bytes,1,rep,name=srv_keyspaces,json=srvKeyspaces,proto3" json:"srv_keyspaces,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *GetSrvKeyspacesResponse) Reset() {
*x = GetSrvKeyspacesResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[58]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetSrvKeyspacesResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetSrvKeyspacesResponse) ProtoMessage() {}
func (x *GetSrvKeyspacesResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[58]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetSrvKeyspacesResponse.ProtoReflect.Descriptor instead.
func (*GetSrvKeyspacesResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{58}
}
func (x *GetSrvKeyspacesResponse) GetSrvKeyspaces() map[string]*topodata.SrvKeyspace {
if x != nil {
return x.SrvKeyspaces
}
return nil
}
type GetSrvVSchemaRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Cell string `protobuf:"bytes,1,opt,name=cell,proto3" json:"cell,omitempty"`
}
func (x *GetSrvVSchemaRequest) Reset() {
*x = GetSrvVSchemaRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[59]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetSrvVSchemaRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetSrvVSchemaRequest) ProtoMessage() {}
func (x *GetSrvVSchemaRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[59]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetSrvVSchemaRequest.ProtoReflect.Descriptor instead.
func (*GetSrvVSchemaRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{59}
}
func (x *GetSrvVSchemaRequest) GetCell() string {
if x != nil {
return x.Cell
}
return ""
}
type GetSrvVSchemaResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
SrvVSchema *vschema.SrvVSchema `protobuf:"bytes,1,opt,name=srv_v_schema,json=srvVSchema,proto3" json:"srv_v_schema,omitempty"`
}
func (x *GetSrvVSchemaResponse) Reset() {
*x = GetSrvVSchemaResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[60]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetSrvVSchemaResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetSrvVSchemaResponse) ProtoMessage() {}
func (x *GetSrvVSchemaResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[60]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetSrvVSchemaResponse.ProtoReflect.Descriptor instead.
func (*GetSrvVSchemaResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{60}
}
func (x *GetSrvVSchemaResponse) GetSrvVSchema() *vschema.SrvVSchema {
if x != nil {
return x.SrvVSchema
}
return nil
}
type GetSrvVSchemasRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Cells []string `protobuf:"bytes,2,rep,name=cells,proto3" json:"cells,omitempty"`
}
func (x *GetSrvVSchemasRequest) Reset() {
*x = GetSrvVSchemasRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[61]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetSrvVSchemasRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetSrvVSchemasRequest) ProtoMessage() {}
func (x *GetSrvVSchemasRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[61]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetSrvVSchemasRequest.ProtoReflect.Descriptor instead.
func (*GetSrvVSchemasRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{61}
}
func (x *GetSrvVSchemasRequest) GetCells() []string {
if x != nil {
return x.Cells
}
return nil
}
type GetSrvVSchemasResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// SrvVSchemas is a mapping of cell name to SrvVSchema
SrvVSchemas map[string]*vschema.SrvVSchema `protobuf:"bytes,1,rep,name=srv_v_schemas,json=srvVSchemas,proto3" json:"srv_v_schemas,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *GetSrvVSchemasResponse) Reset() {
*x = GetSrvVSchemasResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[62]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetSrvVSchemasResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetSrvVSchemasResponse) ProtoMessage() {}
func (x *GetSrvVSchemasResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[62]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetSrvVSchemasResponse.ProtoReflect.Descriptor instead.
func (*GetSrvVSchemasResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{62}
}
func (x *GetSrvVSchemasResponse) GetSrvVSchemas() map[string]*vschema.SrvVSchema {
if x != nil {
return x.SrvVSchemas
}
return nil
}
type GetTabletRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
TabletAlias *topodata.TabletAlias `protobuf:"bytes,1,opt,name=tablet_alias,json=tabletAlias,proto3" json:"tablet_alias,omitempty"`
}
func (x *GetTabletRequest) Reset() {
*x = GetTabletRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[63]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetTabletRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetTabletRequest) ProtoMessage() {}
func (x *GetTabletRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[63]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetTabletRequest.ProtoReflect.Descriptor instead.
func (*GetTabletRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{63}
}
func (x *GetTabletRequest) GetTabletAlias() *topodata.TabletAlias {
if x != nil {
return x.TabletAlias
}
return nil
}
type GetTabletResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Tablet *topodata.Tablet `protobuf:"bytes,1,opt,name=tablet,proto3" json:"tablet,omitempty"`
}
func (x *GetTabletResponse) Reset() {
*x = GetTabletResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[64]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetTabletResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetTabletResponse) ProtoMessage() {}
func (x *GetTabletResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[64]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetTabletResponse.ProtoReflect.Descriptor instead.
func (*GetTabletResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{64}
}
func (x *GetTabletResponse) GetTablet() *topodata.Tablet {
if x != nil {
return x.Tablet
}
return nil
}
type GetTabletsRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Keyspace is the name of the keyspace to return tablets for. Omit to return
// all tablets.
Keyspace string `protobuf:"bytes,1,opt,name=keyspace,proto3" json:"keyspace,omitempty"`
// Shard is the name of the shard to return tablets for. This field is ignored
// if Keyspace is not set.
Shard string `protobuf:"bytes,2,opt,name=shard,proto3" json:"shard,omitempty"`
// Cells is an optional set of cells to return tablets for.
Cells []string `protobuf:"bytes,3,rep,name=cells,proto3" json:"cells,omitempty"`
// Strict specifies how the server should treat failures from individual
// cells.
//
// When false (the default), GetTablets will return data from any cells that
// return successfully, but will fail the request if all cells fail. When
// true, any individual cell can fail the full request.
Strict bool `protobuf:"varint,4,opt,name=strict,proto3" json:"strict,omitempty"`
// TabletAliases is an optional list of tablet aliases to fetch Tablet objects
// for. If specified, Keyspace, Shard, and Cells are ignored, and tablets are
// looked up by their respective aliases' Cells directly.
TabletAliases []*topodata.TabletAlias `protobuf:"bytes,5,rep,name=tablet_aliases,json=tabletAliases,proto3" json:"tablet_aliases,omitempty"`
}
func (x *GetTabletsRequest) Reset() {
*x = GetTabletsRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[65]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetTabletsRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetTabletsRequest) ProtoMessage() {}
func (x *GetTabletsRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[65]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetTabletsRequest.ProtoReflect.Descriptor instead.
func (*GetTabletsRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{65}
}
func (x *GetTabletsRequest) GetKeyspace() string {
if x != nil {
return x.Keyspace
}
return ""
}
func (x *GetTabletsRequest) GetShard() string {
if x != nil {
return x.Shard
}
return ""
}
func (x *GetTabletsRequest) GetCells() []string {
if x != nil {
return x.Cells
}
return nil
}
func (x *GetTabletsRequest) GetStrict() bool {
if x != nil {
return x.Strict
}
return false
}
func (x *GetTabletsRequest) GetTabletAliases() []*topodata.TabletAlias {
if x != nil {
return x.TabletAliases
}
return nil
}
type GetTabletsResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Tablets []*topodata.Tablet `protobuf:"bytes,1,rep,name=tablets,proto3" json:"tablets,omitempty"`
}
func (x *GetTabletsResponse) Reset() {
*x = GetTabletsResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[66]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetTabletsResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetTabletsResponse) ProtoMessage() {}
func (x *GetTabletsResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[66]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetTabletsResponse.ProtoReflect.Descriptor instead.
func (*GetTabletsResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{66}
}
func (x *GetTabletsResponse) GetTablets() []*topodata.Tablet {
if x != nil {
return x.Tablets
}
return nil
}
type GetVSchemaRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Keyspace string `protobuf:"bytes,1,opt,name=keyspace,proto3" json:"keyspace,omitempty"`
}
func (x *GetVSchemaRequest) Reset() {
*x = GetVSchemaRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[67]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetVSchemaRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetVSchemaRequest) ProtoMessage() {}
func (x *GetVSchemaRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[67]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetVSchemaRequest.ProtoReflect.Descriptor instead.
func (*GetVSchemaRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{67}
}
func (x *GetVSchemaRequest) GetKeyspace() string {
if x != nil {
return x.Keyspace
}
return ""
}
type GetVSchemaResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
VSchema *vschema.Keyspace `protobuf:"bytes,1,opt,name=v_schema,json=vSchema,proto3" json:"v_schema,omitempty"`
}
func (x *GetVSchemaResponse) Reset() {
*x = GetVSchemaResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[68]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetVSchemaResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetVSchemaResponse) ProtoMessage() {}
func (x *GetVSchemaResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[68]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetVSchemaResponse.ProtoReflect.Descriptor instead.
func (*GetVSchemaResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{68}
}
func (x *GetVSchemaResponse) GetVSchema() *vschema.Keyspace {
if x != nil {
return x.VSchema
}
return nil
}
type GetWorkflowsRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Keyspace string `protobuf:"bytes,1,opt,name=keyspace,proto3" json:"keyspace,omitempty"`
ActiveOnly bool `protobuf:"varint,2,opt,name=active_only,json=activeOnly,proto3" json:"active_only,omitempty"`
}
func (x *GetWorkflowsRequest) Reset() {
*x = GetWorkflowsRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[69]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetWorkflowsRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetWorkflowsRequest) ProtoMessage() {}
func (x *GetWorkflowsRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[69]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetWorkflowsRequest.ProtoReflect.Descriptor instead.
func (*GetWorkflowsRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{69}
}
func (x *GetWorkflowsRequest) GetKeyspace() string {
if x != nil {
return x.Keyspace
}
return ""
}
func (x *GetWorkflowsRequest) GetActiveOnly() bool {
if x != nil {
return x.ActiveOnly
}
return false
}
type GetWorkflowsResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Workflows []*Workflow `protobuf:"bytes,1,rep,name=workflows,proto3" json:"workflows,omitempty"`
}
func (x *GetWorkflowsResponse) Reset() {
*x = GetWorkflowsResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[70]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetWorkflowsResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetWorkflowsResponse) ProtoMessage() {}
func (x *GetWorkflowsResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[70]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetWorkflowsResponse.ProtoReflect.Descriptor instead.
func (*GetWorkflowsResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{70}
}
func (x *GetWorkflowsResponse) GetWorkflows() []*Workflow {
if x != nil {
return x.Workflows
}
return nil
}
type InitShardPrimaryRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Keyspace string `protobuf:"bytes,1,opt,name=keyspace,proto3" json:"keyspace,omitempty"`
Shard string `protobuf:"bytes,2,opt,name=shard,proto3" json:"shard,omitempty"`
PrimaryElectTabletAlias *topodata.TabletAlias `protobuf:"bytes,3,opt,name=primary_elect_tablet_alias,json=primaryElectTabletAlias,proto3" json:"primary_elect_tablet_alias,omitempty"`
Force bool `protobuf:"varint,4,opt,name=force,proto3" json:"force,omitempty"`
WaitReplicasTimeout *vttime.Duration `protobuf:"bytes,5,opt,name=wait_replicas_timeout,json=waitReplicasTimeout,proto3" json:"wait_replicas_timeout,omitempty"`
}
func (x *InitShardPrimaryRequest) Reset() {
*x = InitShardPrimaryRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[71]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *InitShardPrimaryRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*InitShardPrimaryRequest) ProtoMessage() {}
func (x *InitShardPrimaryRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[71]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use InitShardPrimaryRequest.ProtoReflect.Descriptor instead.
func (*InitShardPrimaryRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{71}
}
func (x *InitShardPrimaryRequest) GetKeyspace() string {
if x != nil {
return x.Keyspace
}
return ""
}
func (x *InitShardPrimaryRequest) GetShard() string {
if x != nil {
return x.Shard
}
return ""
}
func (x *InitShardPrimaryRequest) GetPrimaryElectTabletAlias() *topodata.TabletAlias {
if x != nil {
return x.PrimaryElectTabletAlias
}
return nil
}
func (x *InitShardPrimaryRequest) GetForce() bool {
if x != nil {
return x.Force
}
return false
}
func (x *InitShardPrimaryRequest) GetWaitReplicasTimeout() *vttime.Duration {
if x != nil {
return x.WaitReplicasTimeout
}
return nil
}
type InitShardPrimaryResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Events []*logutil.Event `protobuf:"bytes,1,rep,name=events,proto3" json:"events,omitempty"`
}
func (x *InitShardPrimaryResponse) Reset() {
*x = InitShardPrimaryResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[72]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *InitShardPrimaryResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*InitShardPrimaryResponse) ProtoMessage() {}
func (x *InitShardPrimaryResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[72]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use InitShardPrimaryResponse.ProtoReflect.Descriptor instead.
func (*InitShardPrimaryResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{72}
}
func (x *InitShardPrimaryResponse) GetEvents() []*logutil.Event {
if x != nil {
return x.Events
}
return nil
}
type PingTabletRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
TabletAlias *topodata.TabletAlias `protobuf:"bytes,1,opt,name=tablet_alias,json=tabletAlias,proto3" json:"tablet_alias,omitempty"`
}
func (x *PingTabletRequest) Reset() {
*x = PingTabletRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[73]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *PingTabletRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*PingTabletRequest) ProtoMessage() {}
func (x *PingTabletRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[73]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use PingTabletRequest.ProtoReflect.Descriptor instead.
func (*PingTabletRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{73}
}
func (x *PingTabletRequest) GetTabletAlias() *topodata.TabletAlias {
if x != nil {
return x.TabletAlias
}
return nil
}
type PingTabletResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *PingTabletResponse) Reset() {
*x = PingTabletResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[74]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *PingTabletResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*PingTabletResponse) ProtoMessage() {}
func (x *PingTabletResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[74]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use PingTabletResponse.ProtoReflect.Descriptor instead.
func (*PingTabletResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{74}
}
type PlannedReparentShardRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Keyspace is the name of the keyspace to perform the Planned Reparent in.
Keyspace string `protobuf:"bytes,1,opt,name=keyspace,proto3" json:"keyspace,omitempty"`
// Shard is the name of the shard to perform teh Planned Reparent in.
Shard string `protobuf:"bytes,2,opt,name=shard,proto3" json:"shard,omitempty"`
// NewPrimary is the alias of the tablet to promote to shard primary. If not
// specified, the vtctld will select the most up-to-date candidate to promote.
//
// It is an error to set NewPrimary and AvoidPrimary to the same alias.
NewPrimary *topodata.TabletAlias `protobuf:"bytes,3,opt,name=new_primary,json=newPrimary,proto3" json:"new_primary,omitempty"`
// AvoidPrimary is the alias of the tablet to demote. In other words,
// specifying an AvoidPrimary alias tells the vtctld to promote any replica
// other than this one. A shard whose current primary is not this one is then
// a no-op.
//
// It is an error to set NewPrimary and AvoidPrimary to the same alias.
AvoidPrimary *topodata.TabletAlias `protobuf:"bytes,4,opt,name=avoid_primary,json=avoidPrimary,proto3" json:"avoid_primary,omitempty"`
// WaitReplicasTimeout is the duration of time to wait for replicas to catch
// up in replication both before and after the reparent. The timeout is not
// cumulative across both wait periods, meaning that the replicas have
// WaitReplicasTimeout time to catch up before the reparent, and an additional
// WaitReplicasTimeout time to catch up after the reparent.
WaitReplicasTimeout *vttime.Duration `protobuf:"bytes,5,opt,name=wait_replicas_timeout,json=waitReplicasTimeout,proto3" json:"wait_replicas_timeout,omitempty"`
}
func (x *PlannedReparentShardRequest) Reset() {
*x = PlannedReparentShardRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[75]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *PlannedReparentShardRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*PlannedReparentShardRequest) ProtoMessage() {}
func (x *PlannedReparentShardRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[75]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use PlannedReparentShardRequest.ProtoReflect.Descriptor instead.
func (*PlannedReparentShardRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{75}
}
func (x *PlannedReparentShardRequest) GetKeyspace() string {
if x != nil {
return x.Keyspace
}
return ""
}
func (x *PlannedReparentShardRequest) GetShard() string {
if x != nil {
return x.Shard
}
return ""
}
func (x *PlannedReparentShardRequest) GetNewPrimary() *topodata.TabletAlias {
if x != nil {
return x.NewPrimary
}
return nil
}
func (x *PlannedReparentShardRequest) GetAvoidPrimary() *topodata.TabletAlias {
if x != nil {
return x.AvoidPrimary
}
return nil
}
func (x *PlannedReparentShardRequest) GetWaitReplicasTimeout() *vttime.Duration {
if x != nil {
return x.WaitReplicasTimeout
}
return nil
}
type PlannedReparentShardResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Keyspace is the name of the keyspace the Planned Reparent took place in.
Keyspace string `protobuf:"bytes,1,opt,name=keyspace,proto3" json:"keyspace,omitempty"`
// Shard is the name of the shard the Planned Reparent took place in.
Shard string `protobuf:"bytes,2,opt,name=shard,proto3" json:"shard,omitempty"`
// PromotedPrimary is the alias of the tablet that was promoted to shard
// primary. If NewPrimary was set in the request, then this will be the same
// alias. Otherwise, it will be the alias of the tablet found to be most
// up-to-date.
PromotedPrimary *topodata.TabletAlias `protobuf:"bytes,3,opt,name=promoted_primary,json=promotedPrimary,proto3" json:"promoted_primary,omitempty"`
Events []*logutil.Event `protobuf:"bytes,4,rep,name=events,proto3" json:"events,omitempty"`
}
func (x *PlannedReparentShardResponse) Reset() {
*x = PlannedReparentShardResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[76]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *PlannedReparentShardResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*PlannedReparentShardResponse) ProtoMessage() {}
func (x *PlannedReparentShardResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[76]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use PlannedReparentShardResponse.ProtoReflect.Descriptor instead.
func (*PlannedReparentShardResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{76}
}
func (x *PlannedReparentShardResponse) GetKeyspace() string {
if x != nil {
return x.Keyspace
}
return ""
}
func (x *PlannedReparentShardResponse) GetShard() string {
if x != nil {
return x.Shard
}
return ""
}
func (x *PlannedReparentShardResponse) GetPromotedPrimary() *topodata.TabletAlias {
if x != nil {
return x.PromotedPrimary
}
return nil
}
func (x *PlannedReparentShardResponse) GetEvents() []*logutil.Event {
if x != nil {
return x.Events
}
return nil
}
type RebuildKeyspaceGraphRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Keyspace string `protobuf:"bytes,1,opt,name=keyspace,proto3" json:"keyspace,omitempty"`
Cells []string `protobuf:"bytes,2,rep,name=cells,proto3" json:"cells,omitempty"`
// AllowPartial, when set, allows a SNAPSHOT keyspace to serve with an
// incomplete set of shards. It is ignored for all other keyspace types.
AllowPartial bool `protobuf:"varint,3,opt,name=allow_partial,json=allowPartial,proto3" json:"allow_partial,omitempty"`
}
func (x *RebuildKeyspaceGraphRequest) Reset() {
*x = RebuildKeyspaceGraphRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[77]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *RebuildKeyspaceGraphRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*RebuildKeyspaceGraphRequest) ProtoMessage() {}
func (x *RebuildKeyspaceGraphRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[77]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use RebuildKeyspaceGraphRequest.ProtoReflect.Descriptor instead.
func (*RebuildKeyspaceGraphRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{77}
}
func (x *RebuildKeyspaceGraphRequest) GetKeyspace() string {
if x != nil {
return x.Keyspace
}
return ""
}
func (x *RebuildKeyspaceGraphRequest) GetCells() []string {
if x != nil {
return x.Cells
}
return nil
}
func (x *RebuildKeyspaceGraphRequest) GetAllowPartial() bool {
if x != nil {
return x.AllowPartial
}
return false
}
type RebuildKeyspaceGraphResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *RebuildKeyspaceGraphResponse) Reset() {
*x = RebuildKeyspaceGraphResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[78]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *RebuildKeyspaceGraphResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*RebuildKeyspaceGraphResponse) ProtoMessage() {}
func (x *RebuildKeyspaceGraphResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[78]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use RebuildKeyspaceGraphResponse.ProtoReflect.Descriptor instead.
func (*RebuildKeyspaceGraphResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{78}
}
type RebuildVSchemaGraphRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Cells specifies the cells to rebuild the SrvVSchema objects for. If empty,
// RebuildVSchemaGraph rebuilds the SrvVSchema for every cell in the topo.
Cells []string `protobuf:"bytes,1,rep,name=cells,proto3" json:"cells,omitempty"`
}
func (x *RebuildVSchemaGraphRequest) Reset() {
*x = RebuildVSchemaGraphRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[79]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *RebuildVSchemaGraphRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*RebuildVSchemaGraphRequest) ProtoMessage() {}
func (x *RebuildVSchemaGraphRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[79]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use RebuildVSchemaGraphRequest.ProtoReflect.Descriptor instead.
func (*RebuildVSchemaGraphRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{79}
}
func (x *RebuildVSchemaGraphRequest) GetCells() []string {
if x != nil {
return x.Cells
}
return nil
}
type RebuildVSchemaGraphResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *RebuildVSchemaGraphResponse) Reset() {
*x = RebuildVSchemaGraphResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[80]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *RebuildVSchemaGraphResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*RebuildVSchemaGraphResponse) ProtoMessage() {}
func (x *RebuildVSchemaGraphResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[80]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use RebuildVSchemaGraphResponse.ProtoReflect.Descriptor instead.
func (*RebuildVSchemaGraphResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{80}
}
type RefreshStateRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
TabletAlias *topodata.TabletAlias `protobuf:"bytes,1,opt,name=tablet_alias,json=tabletAlias,proto3" json:"tablet_alias,omitempty"`
}
func (x *RefreshStateRequest) Reset() {
*x = RefreshStateRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[81]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *RefreshStateRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*RefreshStateRequest) ProtoMessage() {}
func (x *RefreshStateRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[81]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use RefreshStateRequest.ProtoReflect.Descriptor instead.
func (*RefreshStateRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{81}
}
func (x *RefreshStateRequest) GetTabletAlias() *topodata.TabletAlias {
if x != nil {
return x.TabletAlias
}
return nil
}
type RefreshStateResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *RefreshStateResponse) Reset() {
*x = RefreshStateResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[82]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *RefreshStateResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*RefreshStateResponse) ProtoMessage() {}
func (x *RefreshStateResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[82]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use RefreshStateResponse.ProtoReflect.Descriptor instead.
func (*RefreshStateResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{82}
}
type RefreshStateByShardRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Keyspace string `protobuf:"bytes,1,opt,name=keyspace,proto3" json:"keyspace,omitempty"`
Shard string `protobuf:"bytes,2,opt,name=shard,proto3" json:"shard,omitempty"`
Cells []string `protobuf:"bytes,3,rep,name=cells,proto3" json:"cells,omitempty"`
}
func (x *RefreshStateByShardRequest) Reset() {
*x = RefreshStateByShardRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[83]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *RefreshStateByShardRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*RefreshStateByShardRequest) ProtoMessage() {}
func (x *RefreshStateByShardRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[83]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use RefreshStateByShardRequest.ProtoReflect.Descriptor instead.
func (*RefreshStateByShardRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{83}
}
func (x *RefreshStateByShardRequest) GetKeyspace() string {
if x != nil {
return x.Keyspace
}
return ""
}
func (x *RefreshStateByShardRequest) GetShard() string {
if x != nil {
return x.Shard
}
return ""
}
func (x *RefreshStateByShardRequest) GetCells() []string {
if x != nil {
return x.Cells
}
return nil
}
type RefreshStateByShardResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
IsPartialRefresh bool `protobuf:"varint,1,opt,name=is_partial_refresh,json=isPartialRefresh,proto3" json:"is_partial_refresh,omitempty"`
}
func (x *RefreshStateByShardResponse) Reset() {
*x = RefreshStateByShardResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[84]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *RefreshStateByShardResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*RefreshStateByShardResponse) ProtoMessage() {}
func (x *RefreshStateByShardResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[84]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use RefreshStateByShardResponse.ProtoReflect.Descriptor instead.
func (*RefreshStateByShardResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{84}
}
func (x *RefreshStateByShardResponse) GetIsPartialRefresh() bool {
if x != nil {
return x.IsPartialRefresh
}
return false
}
type RemoveKeyspaceCellRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Keyspace string `protobuf:"bytes,1,opt,name=keyspace,proto3" json:"keyspace,omitempty"`
Cell string `protobuf:"bytes,2,opt,name=cell,proto3" json:"cell,omitempty"`
// Force proceeds even if the cell's topology server cannot be reached. This
// should only be set if a cell has been shut down entirely, and the global
// topology data just needs to be updated.
Force bool `protobuf:"varint,3,opt,name=force,proto3" json:"force,omitempty"`
// Recursive also deletes all tablets in that cell belonging to the specified
// keyspace.
Recursive bool `protobuf:"varint,4,opt,name=recursive,proto3" json:"recursive,omitempty"`
}
func (x *RemoveKeyspaceCellRequest) Reset() {
*x = RemoveKeyspaceCellRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[85]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *RemoveKeyspaceCellRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*RemoveKeyspaceCellRequest) ProtoMessage() {}
func (x *RemoveKeyspaceCellRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[85]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use RemoveKeyspaceCellRequest.ProtoReflect.Descriptor instead.
func (*RemoveKeyspaceCellRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{85}
}
func (x *RemoveKeyspaceCellRequest) GetKeyspace() string {
if x != nil {
return x.Keyspace
}
return ""
}
func (x *RemoveKeyspaceCellRequest) GetCell() string {
if x != nil {
return x.Cell
}
return ""
}
func (x *RemoveKeyspaceCellRequest) GetForce() bool {
if x != nil {
return x.Force
}
return false
}
func (x *RemoveKeyspaceCellRequest) GetRecursive() bool {
if x != nil {
return x.Recursive
}
return false
}
type RemoveKeyspaceCellResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *RemoveKeyspaceCellResponse) Reset() {
*x = RemoveKeyspaceCellResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[86]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *RemoveKeyspaceCellResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*RemoveKeyspaceCellResponse) ProtoMessage() {}
func (x *RemoveKeyspaceCellResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[86]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use RemoveKeyspaceCellResponse.ProtoReflect.Descriptor instead.
func (*RemoveKeyspaceCellResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{86}
}
type RemoveShardCellRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Keyspace string `protobuf:"bytes,1,opt,name=keyspace,proto3" json:"keyspace,omitempty"`
ShardName string `protobuf:"bytes,2,opt,name=shard_name,json=shardName,proto3" json:"shard_name,omitempty"`
Cell string `protobuf:"bytes,3,opt,name=cell,proto3" json:"cell,omitempty"`
// Force proceeds even if the cell's topology server cannot be reached. This
// should only be set if a cell has been shut down entirely, and the global
// topology data just needs to be updated.
Force bool `protobuf:"varint,4,opt,name=force,proto3" json:"force,omitempty"`
// Recursive also deletes all tablets in that cell belonging to the specified
// keyspace and shard.
Recursive bool `protobuf:"varint,5,opt,name=recursive,proto3" json:"recursive,omitempty"`
}
func (x *RemoveShardCellRequest) Reset() {
*x = RemoveShardCellRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[87]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *RemoveShardCellRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*RemoveShardCellRequest) ProtoMessage() {}
func (x *RemoveShardCellRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[87]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use RemoveShardCellRequest.ProtoReflect.Descriptor instead.
func (*RemoveShardCellRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{87}
}
func (x *RemoveShardCellRequest) GetKeyspace() string {
if x != nil {
return x.Keyspace
}
return ""
}
func (x *RemoveShardCellRequest) GetShardName() string {
if x != nil {
return x.ShardName
}
return ""
}
func (x *RemoveShardCellRequest) GetCell() string {
if x != nil {
return x.Cell
}
return ""
}
func (x *RemoveShardCellRequest) GetForce() bool {
if x != nil {
return x.Force
}
return false
}
func (x *RemoveShardCellRequest) GetRecursive() bool {
if x != nil {
return x.Recursive
}
return false
}
type RemoveShardCellResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *RemoveShardCellResponse) Reset() {
*x = RemoveShardCellResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[88]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *RemoveShardCellResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*RemoveShardCellResponse) ProtoMessage() {}
func (x *RemoveShardCellResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[88]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use RemoveShardCellResponse.ProtoReflect.Descriptor instead.
func (*RemoveShardCellResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{88}
}
type ReparentTabletRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Tablet is the alias of the tablet that should be reparented under the
// current shard primary.
Tablet *topodata.TabletAlias `protobuf:"bytes,1,opt,name=tablet,proto3" json:"tablet,omitempty"`
}
func (x *ReparentTabletRequest) Reset() {
*x = ReparentTabletRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[89]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ReparentTabletRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ReparentTabletRequest) ProtoMessage() {}
func (x *ReparentTabletRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[89]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ReparentTabletRequest.ProtoReflect.Descriptor instead.
func (*ReparentTabletRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{89}
}
func (x *ReparentTabletRequest) GetTablet() *topodata.TabletAlias {
if x != nil {
return x.Tablet
}
return nil
}
type ReparentTabletResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Keyspace is the name of the keyspace the tablet was reparented in.
Keyspace string `protobuf:"bytes,1,opt,name=keyspace,proto3" json:"keyspace,omitempty"`
// Shard is the name of the shard the tablet was reparented in.
Shard string `protobuf:"bytes,2,opt,name=shard,proto3" json:"shard,omitempty"`
// Primary is the alias of the tablet that the tablet was reparented under.
Primary *topodata.TabletAlias `protobuf:"bytes,3,opt,name=primary,proto3" json:"primary,omitempty"`
}
func (x *ReparentTabletResponse) Reset() {
*x = ReparentTabletResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[90]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ReparentTabletResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ReparentTabletResponse) ProtoMessage() {}
func (x *ReparentTabletResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[90]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ReparentTabletResponse.ProtoReflect.Descriptor instead.
func (*ReparentTabletResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{90}
}
func (x *ReparentTabletResponse) GetKeyspace() string {
if x != nil {
return x.Keyspace
}
return ""
}
func (x *ReparentTabletResponse) GetShard() string {
if x != nil {
return x.Shard
}
return ""
}
func (x *ReparentTabletResponse) GetPrimary() *topodata.TabletAlias {
if x != nil {
return x.Primary
}
return nil
}
type RunHealthCheckRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
TabletAlias *topodata.TabletAlias `protobuf:"bytes,1,opt,name=tablet_alias,json=tabletAlias,proto3" json:"tablet_alias,omitempty"`
}
func (x *RunHealthCheckRequest) Reset() {
*x = RunHealthCheckRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[91]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *RunHealthCheckRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*RunHealthCheckRequest) ProtoMessage() {}
func (x *RunHealthCheckRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[91]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use RunHealthCheckRequest.ProtoReflect.Descriptor instead.
func (*RunHealthCheckRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{91}
}
func (x *RunHealthCheckRequest) GetTabletAlias() *topodata.TabletAlias {
if x != nil {
return x.TabletAlias
}
return nil
}
type RunHealthCheckResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *RunHealthCheckResponse) Reset() {
*x = RunHealthCheckResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[92]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *RunHealthCheckResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*RunHealthCheckResponse) ProtoMessage() {}
func (x *RunHealthCheckResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[92]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use RunHealthCheckResponse.ProtoReflect.Descriptor instead.
func (*RunHealthCheckResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{92}
}
type SetKeyspaceServedFromRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Keyspace string `protobuf:"bytes,1,opt,name=keyspace,proto3" json:"keyspace,omitempty"`
TabletType topodata.TabletType `protobuf:"varint,2,opt,name=tablet_type,json=tabletType,proto3,enum=topodata.TabletType" json:"tablet_type,omitempty"`
Cells []string `protobuf:"bytes,3,rep,name=cells,proto3" json:"cells,omitempty"`
Remove bool `protobuf:"varint,4,opt,name=remove,proto3" json:"remove,omitempty"`
SourceKeyspace string `protobuf:"bytes,5,opt,name=source_keyspace,json=sourceKeyspace,proto3" json:"source_keyspace,omitempty"`
}
func (x *SetKeyspaceServedFromRequest) Reset() {
*x = SetKeyspaceServedFromRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[93]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SetKeyspaceServedFromRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SetKeyspaceServedFromRequest) ProtoMessage() {}
func (x *SetKeyspaceServedFromRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[93]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SetKeyspaceServedFromRequest.ProtoReflect.Descriptor instead.
func (*SetKeyspaceServedFromRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{93}
}
func (x *SetKeyspaceServedFromRequest) GetKeyspace() string {
if x != nil {
return x.Keyspace
}
return ""
}
func (x *SetKeyspaceServedFromRequest) GetTabletType() topodata.TabletType {
if x != nil {
return x.TabletType
}
return topodata.TabletType(0)
}
func (x *SetKeyspaceServedFromRequest) GetCells() []string {
if x != nil {
return x.Cells
}
return nil
}
func (x *SetKeyspaceServedFromRequest) GetRemove() bool {
if x != nil {
return x.Remove
}
return false
}
func (x *SetKeyspaceServedFromRequest) GetSourceKeyspace() string {
if x != nil {
return x.SourceKeyspace
}
return ""
}
type SetKeyspaceServedFromResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Keyspace is the updated keyspace record.
Keyspace *topodata.Keyspace `protobuf:"bytes,1,opt,name=keyspace,proto3" json:"keyspace,omitempty"`
}
func (x *SetKeyspaceServedFromResponse) Reset() {
*x = SetKeyspaceServedFromResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[94]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SetKeyspaceServedFromResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SetKeyspaceServedFromResponse) ProtoMessage() {}
func (x *SetKeyspaceServedFromResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[94]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SetKeyspaceServedFromResponse.ProtoReflect.Descriptor instead.
func (*SetKeyspaceServedFromResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{94}
}
func (x *SetKeyspaceServedFromResponse) GetKeyspace() *topodata.Keyspace {
if x != nil {
return x.Keyspace
}
return nil
}
type SetKeyspaceShardingInfoRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Keyspace string `protobuf:"bytes,1,opt,name=keyspace,proto3" json:"keyspace,omitempty"`
ColumnName string `protobuf:"bytes,2,opt,name=column_name,json=columnName,proto3" json:"column_name,omitempty"`
ColumnType topodata.KeyspaceIdType `protobuf:"varint,3,opt,name=column_type,json=columnType,proto3,enum=topodata.KeyspaceIdType" json:"column_type,omitempty"`
Force bool `protobuf:"varint,4,opt,name=force,proto3" json:"force,omitempty"`
}
func (x *SetKeyspaceShardingInfoRequest) Reset() {
*x = SetKeyspaceShardingInfoRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[95]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SetKeyspaceShardingInfoRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SetKeyspaceShardingInfoRequest) ProtoMessage() {}
func (x *SetKeyspaceShardingInfoRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[95]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SetKeyspaceShardingInfoRequest.ProtoReflect.Descriptor instead.
func (*SetKeyspaceShardingInfoRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{95}
}
func (x *SetKeyspaceShardingInfoRequest) GetKeyspace() string {
if x != nil {
return x.Keyspace
}
return ""
}
func (x *SetKeyspaceShardingInfoRequest) GetColumnName() string {
if x != nil {
return x.ColumnName
}
return ""
}
func (x *SetKeyspaceShardingInfoRequest) GetColumnType() topodata.KeyspaceIdType {
if x != nil {
return x.ColumnType
}
return topodata.KeyspaceIdType(0)
}
func (x *SetKeyspaceShardingInfoRequest) GetForce() bool {
if x != nil {
return x.Force
}
return false
}
type SetKeyspaceShardingInfoResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Keyspace is the updated keyspace record.
Keyspace *topodata.Keyspace `protobuf:"bytes,1,opt,name=keyspace,proto3" json:"keyspace,omitempty"`
}
func (x *SetKeyspaceShardingInfoResponse) Reset() {
*x = SetKeyspaceShardingInfoResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[96]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SetKeyspaceShardingInfoResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SetKeyspaceShardingInfoResponse) ProtoMessage() {}
func (x *SetKeyspaceShardingInfoResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[96]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SetKeyspaceShardingInfoResponse.ProtoReflect.Descriptor instead.
func (*SetKeyspaceShardingInfoResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{96}
}
func (x *SetKeyspaceShardingInfoResponse) GetKeyspace() *topodata.Keyspace {
if x != nil {
return x.Keyspace
}
return nil
}
type SetShardIsPrimaryServingRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Keyspace string `protobuf:"bytes,1,opt,name=keyspace,proto3" json:"keyspace,omitempty"`
Shard string `protobuf:"bytes,2,opt,name=shard,proto3" json:"shard,omitempty"`
IsServing bool `protobuf:"varint,3,opt,name=is_serving,json=isServing,proto3" json:"is_serving,omitempty"`
}
func (x *SetShardIsPrimaryServingRequest) Reset() {
*x = SetShardIsPrimaryServingRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[97]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SetShardIsPrimaryServingRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SetShardIsPrimaryServingRequest) ProtoMessage() {}
func (x *SetShardIsPrimaryServingRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[97]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SetShardIsPrimaryServingRequest.ProtoReflect.Descriptor instead.
func (*SetShardIsPrimaryServingRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{97}
}
func (x *SetShardIsPrimaryServingRequest) GetKeyspace() string {
if x != nil {
return x.Keyspace
}
return ""
}
func (x *SetShardIsPrimaryServingRequest) GetShard() string {
if x != nil {
return x.Shard
}
return ""
}
func (x *SetShardIsPrimaryServingRequest) GetIsServing() bool {
if x != nil {
return x.IsServing
}
return false
}
type SetShardIsPrimaryServingResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Shard is the updated shard record.
Shard *topodata.Shard `protobuf:"bytes,1,opt,name=shard,proto3" json:"shard,omitempty"`
}
func (x *SetShardIsPrimaryServingResponse) Reset() {
*x = SetShardIsPrimaryServingResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[98]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SetShardIsPrimaryServingResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SetShardIsPrimaryServingResponse) ProtoMessage() {}
func (x *SetShardIsPrimaryServingResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[98]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SetShardIsPrimaryServingResponse.ProtoReflect.Descriptor instead.
func (*SetShardIsPrimaryServingResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{98}
}
func (x *SetShardIsPrimaryServingResponse) GetShard() *topodata.Shard {
if x != nil {
return x.Shard
}
return nil
}
type SetShardTabletControlRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Keyspace string `protobuf:"bytes,1,opt,name=keyspace,proto3" json:"keyspace,omitempty"`
Shard string `protobuf:"bytes,2,opt,name=shard,proto3" json:"shard,omitempty"`
TabletType topodata.TabletType `protobuf:"varint,3,opt,name=tablet_type,json=tabletType,proto3,enum=topodata.TabletType" json:"tablet_type,omitempty"`
Cells []string `protobuf:"bytes,4,rep,name=cells,proto3" json:"cells,omitempty"`
// DeniedTables updates the list of denied tables the shard will serve for
// the given tablet type. This is useful to fix tables that are being blocked
// after a MoveTables operation.
//
// NOTE: Setting this field will cause DisableQueryService to be ignored.
DeniedTables []string `protobuf:"bytes,5,rep,name=denied_tables,json=deniedTables,proto3" json:"denied_tables,omitempty"`
// DisableQueryService instructs whether to enable the query service on
// tablets of the given type in the shard. This is useful to fix Reshard
// operations gone awry.
//
// NOTE: this is ignored if DeniedTables is not empty.
DisableQueryService bool `protobuf:"varint,6,opt,name=disable_query_service,json=disableQueryService,proto3" json:"disable_query_service,omitempty"`
// Remove removes the ShardTabletControl record entirely. If set, this takes
// precedence over DeniedTables and DisableQueryService fields, and is useful
// to manually remove serving restrictions after a completed MoveTables
// operation.
Remove bool `protobuf:"varint,7,opt,name=remove,proto3" json:"remove,omitempty"`
}
func (x *SetShardTabletControlRequest) Reset() {
*x = SetShardTabletControlRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[99]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SetShardTabletControlRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SetShardTabletControlRequest) ProtoMessage() {}
func (x *SetShardTabletControlRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[99]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SetShardTabletControlRequest.ProtoReflect.Descriptor instead.
func (*SetShardTabletControlRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{99}
}
func (x *SetShardTabletControlRequest) GetKeyspace() string {
if x != nil {
return x.Keyspace
}
return ""
}
func (x *SetShardTabletControlRequest) GetShard() string {
if x != nil {
return x.Shard
}
return ""
}
func (x *SetShardTabletControlRequest) GetTabletType() topodata.TabletType {
if x != nil {
return x.TabletType
}
return topodata.TabletType(0)
}
func (x *SetShardTabletControlRequest) GetCells() []string {
if x != nil {
return x.Cells
}
return nil
}
func (x *SetShardTabletControlRequest) GetDeniedTables() []string {
if x != nil {
return x.DeniedTables
}
return nil
}
func (x *SetShardTabletControlRequest) GetDisableQueryService() bool {
if x != nil {
return x.DisableQueryService
}
return false
}
func (x *SetShardTabletControlRequest) GetRemove() bool {
if x != nil {
return x.Remove
}
return false
}
type SetShardTabletControlResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Shard is the updated shard record.
Shard *topodata.Shard `protobuf:"bytes,1,opt,name=shard,proto3" json:"shard,omitempty"`
}
func (x *SetShardTabletControlResponse) Reset() {
*x = SetShardTabletControlResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[100]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SetShardTabletControlResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SetShardTabletControlResponse) ProtoMessage() {}
func (x *SetShardTabletControlResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[100]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SetShardTabletControlResponse.ProtoReflect.Descriptor instead.
func (*SetShardTabletControlResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{100}
}
func (x *SetShardTabletControlResponse) GetShard() *topodata.Shard {
if x != nil {
return x.Shard
}
return nil
}
type SetWritableRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
TabletAlias *topodata.TabletAlias `protobuf:"bytes,1,opt,name=tablet_alias,json=tabletAlias,proto3" json:"tablet_alias,omitempty"`
Writable bool `protobuf:"varint,2,opt,name=writable,proto3" json:"writable,omitempty"`
}
func (x *SetWritableRequest) Reset() {
*x = SetWritableRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[101]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SetWritableRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SetWritableRequest) ProtoMessage() {}
func (x *SetWritableRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[101]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SetWritableRequest.ProtoReflect.Descriptor instead.
func (*SetWritableRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{101}
}
func (x *SetWritableRequest) GetTabletAlias() *topodata.TabletAlias {
if x != nil {
return x.TabletAlias
}
return nil
}
func (x *SetWritableRequest) GetWritable() bool {
if x != nil {
return x.Writable
}
return false
}
type SetWritableResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *SetWritableResponse) Reset() {
*x = SetWritableResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[102]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SetWritableResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SetWritableResponse) ProtoMessage() {}
func (x *SetWritableResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[102]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SetWritableResponse.ProtoReflect.Descriptor instead.
func (*SetWritableResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{102}
}
type ShardReplicationPositionsRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Keyspace string `protobuf:"bytes,1,opt,name=keyspace,proto3" json:"keyspace,omitempty"`
Shard string `protobuf:"bytes,2,opt,name=shard,proto3" json:"shard,omitempty"`
}
func (x *ShardReplicationPositionsRequest) Reset() {
*x = ShardReplicationPositionsRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[103]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ShardReplicationPositionsRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ShardReplicationPositionsRequest) ProtoMessage() {}
func (x *ShardReplicationPositionsRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[103]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ShardReplicationPositionsRequest.ProtoReflect.Descriptor instead.
func (*ShardReplicationPositionsRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{103}
}
func (x *ShardReplicationPositionsRequest) GetKeyspace() string {
if x != nil {
return x.Keyspace
}
return ""
}
func (x *ShardReplicationPositionsRequest) GetShard() string {
if x != nil {
return x.Shard
}
return ""
}
type ShardReplicationPositionsResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// ReplicationStatuses is a mapping of tablet alias string to replication
// status for that tablet.
ReplicationStatuses map[string]*replicationdata.Status `protobuf:"bytes,1,rep,name=replication_statuses,json=replicationStatuses,proto3" json:"replication_statuses,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// TabletMap is the set of tablets whose replication statuses were queried,
// keyed by tablet alias.
TabletMap map[string]*topodata.Tablet `protobuf:"bytes,2,rep,name=tablet_map,json=tabletMap,proto3" json:"tablet_map,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *ShardReplicationPositionsResponse) Reset() {
*x = ShardReplicationPositionsResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[104]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ShardReplicationPositionsResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ShardReplicationPositionsResponse) ProtoMessage() {}
func (x *ShardReplicationPositionsResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[104]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ShardReplicationPositionsResponse.ProtoReflect.Descriptor instead.
func (*ShardReplicationPositionsResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{104}
}
func (x *ShardReplicationPositionsResponse) GetReplicationStatuses() map[string]*replicationdata.Status {
if x != nil {
return x.ReplicationStatuses
}
return nil
}
func (x *ShardReplicationPositionsResponse) GetTabletMap() map[string]*topodata.Tablet {
if x != nil {
return x.TabletMap
}
return nil
}
type SleepTabletRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
TabletAlias *topodata.TabletAlias `protobuf:"bytes,1,opt,name=tablet_alias,json=tabletAlias,proto3" json:"tablet_alias,omitempty"`
Duration *vttime.Duration `protobuf:"bytes,2,opt,name=duration,proto3" json:"duration,omitempty"`
}
func (x *SleepTabletRequest) Reset() {
*x = SleepTabletRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[105]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SleepTabletRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SleepTabletRequest) ProtoMessage() {}
func (x *SleepTabletRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[105]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SleepTabletRequest.ProtoReflect.Descriptor instead.
func (*SleepTabletRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{105}
}
func (x *SleepTabletRequest) GetTabletAlias() *topodata.TabletAlias {
if x != nil {
return x.TabletAlias
}
return nil
}
func (x *SleepTabletRequest) GetDuration() *vttime.Duration {
if x != nil {
return x.Duration
}
return nil
}
type SleepTabletResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *SleepTabletResponse) Reset() {
*x = SleepTabletResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[106]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SleepTabletResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SleepTabletResponse) ProtoMessage() {}
func (x *SleepTabletResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[106]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SleepTabletResponse.ProtoReflect.Descriptor instead.
func (*SleepTabletResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{106}
}
type StartReplicationRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
TabletAlias *topodata.TabletAlias `protobuf:"bytes,1,opt,name=tablet_alias,json=tabletAlias,proto3" json:"tablet_alias,omitempty"`
}
func (x *StartReplicationRequest) Reset() {
*x = StartReplicationRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[107]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *StartReplicationRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*StartReplicationRequest) ProtoMessage() {}
func (x *StartReplicationRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[107]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use StartReplicationRequest.ProtoReflect.Descriptor instead.
func (*StartReplicationRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{107}
}
func (x *StartReplicationRequest) GetTabletAlias() *topodata.TabletAlias {
if x != nil {
return x.TabletAlias
}
return nil
}
type StartReplicationResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *StartReplicationResponse) Reset() {
*x = StartReplicationResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[108]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *StartReplicationResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*StartReplicationResponse) ProtoMessage() {}
func (x *StartReplicationResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[108]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use StartReplicationResponse.ProtoReflect.Descriptor instead.
func (*StartReplicationResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{108}
}
type StopReplicationRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
TabletAlias *topodata.TabletAlias `protobuf:"bytes,1,opt,name=tablet_alias,json=tabletAlias,proto3" json:"tablet_alias,omitempty"`
}
func (x *StopReplicationRequest) Reset() {
*x = StopReplicationRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[109]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *StopReplicationRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*StopReplicationRequest) ProtoMessage() {}
func (x *StopReplicationRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[109]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use StopReplicationRequest.ProtoReflect.Descriptor instead.
func (*StopReplicationRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{109}
}
func (x *StopReplicationRequest) GetTabletAlias() *topodata.TabletAlias {
if x != nil {
return x.TabletAlias
}
return nil
}
type StopReplicationResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *StopReplicationResponse) Reset() {
*x = StopReplicationResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[110]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *StopReplicationResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*StopReplicationResponse) ProtoMessage() {}
func (x *StopReplicationResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[110]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use StopReplicationResponse.ProtoReflect.Descriptor instead.
func (*StopReplicationResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{110}
}
type TabletExternallyReparentedRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Tablet is the alias of the tablet that was promoted externally and should
// be updated to the shard primary in the topo.
Tablet *topodata.TabletAlias `protobuf:"bytes,1,opt,name=tablet,proto3" json:"tablet,omitempty"`
}
func (x *TabletExternallyReparentedRequest) Reset() {
*x = TabletExternallyReparentedRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[111]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *TabletExternallyReparentedRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TabletExternallyReparentedRequest) ProtoMessage() {}
func (x *TabletExternallyReparentedRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[111]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TabletExternallyReparentedRequest.ProtoReflect.Descriptor instead.
func (*TabletExternallyReparentedRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{111}
}
func (x *TabletExternallyReparentedRequest) GetTablet() *topodata.TabletAlias {
if x != nil {
return x.Tablet
}
return nil
}
type TabletExternallyReparentedResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Keyspace string `protobuf:"bytes,1,opt,name=keyspace,proto3" json:"keyspace,omitempty"`
Shard string `protobuf:"bytes,2,opt,name=shard,proto3" json:"shard,omitempty"`
NewPrimary *topodata.TabletAlias `protobuf:"bytes,3,opt,name=new_primary,json=newPrimary,proto3" json:"new_primary,omitempty"`
OldPrimary *topodata.TabletAlias `protobuf:"bytes,4,opt,name=old_primary,json=oldPrimary,proto3" json:"old_primary,omitempty"`
}
func (x *TabletExternallyReparentedResponse) Reset() {
*x = TabletExternallyReparentedResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[112]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *TabletExternallyReparentedResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TabletExternallyReparentedResponse) ProtoMessage() {}
func (x *TabletExternallyReparentedResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[112]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TabletExternallyReparentedResponse.ProtoReflect.Descriptor instead.
func (*TabletExternallyReparentedResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{112}
}
func (x *TabletExternallyReparentedResponse) GetKeyspace() string {
if x != nil {
return x.Keyspace
}
return ""
}
func (x *TabletExternallyReparentedResponse) GetShard() string {
if x != nil {
return x.Shard
}
return ""
}
func (x *TabletExternallyReparentedResponse) GetNewPrimary() *topodata.TabletAlias {
if x != nil {
return x.NewPrimary
}
return nil
}
func (x *TabletExternallyReparentedResponse) GetOldPrimary() *topodata.TabletAlias {
if x != nil {
return x.OldPrimary
}
return nil
}
type UpdateCellInfoRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
CellInfo *topodata.CellInfo `protobuf:"bytes,2,opt,name=cell_info,json=cellInfo,proto3" json:"cell_info,omitempty"`
}
func (x *UpdateCellInfoRequest) Reset() {
*x = UpdateCellInfoRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[113]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *UpdateCellInfoRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*UpdateCellInfoRequest) ProtoMessage() {}
func (x *UpdateCellInfoRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[113]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use UpdateCellInfoRequest.ProtoReflect.Descriptor instead.
func (*UpdateCellInfoRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{113}
}
func (x *UpdateCellInfoRequest) GetName() string {
if x != nil {
return x.Name
}
return ""
}
func (x *UpdateCellInfoRequest) GetCellInfo() *topodata.CellInfo {
if x != nil {
return x.CellInfo
}
return nil
}
type UpdateCellInfoResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
CellInfo *topodata.CellInfo `protobuf:"bytes,2,opt,name=cell_info,json=cellInfo,proto3" json:"cell_info,omitempty"`
}
func (x *UpdateCellInfoResponse) Reset() {
*x = UpdateCellInfoResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[114]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *UpdateCellInfoResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*UpdateCellInfoResponse) ProtoMessage() {}
func (x *UpdateCellInfoResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[114]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use UpdateCellInfoResponse.ProtoReflect.Descriptor instead.
func (*UpdateCellInfoResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{114}
}
func (x *UpdateCellInfoResponse) GetName() string {
if x != nil {
return x.Name
}
return ""
}
func (x *UpdateCellInfoResponse) GetCellInfo() *topodata.CellInfo {
if x != nil {
return x.CellInfo
}
return nil
}
type UpdateCellsAliasRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
CellsAlias *topodata.CellsAlias `protobuf:"bytes,2,opt,name=cells_alias,json=cellsAlias,proto3" json:"cells_alias,omitempty"`
}
func (x *UpdateCellsAliasRequest) Reset() {
*x = UpdateCellsAliasRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[115]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *UpdateCellsAliasRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*UpdateCellsAliasRequest) ProtoMessage() {}
func (x *UpdateCellsAliasRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[115]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use UpdateCellsAliasRequest.ProtoReflect.Descriptor instead.
func (*UpdateCellsAliasRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{115}
}
func (x *UpdateCellsAliasRequest) GetName() string {
if x != nil {
return x.Name
}
return ""
}
func (x *UpdateCellsAliasRequest) GetCellsAlias() *topodata.CellsAlias {
if x != nil {
return x.CellsAlias
}
return nil
}
type UpdateCellsAliasResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
CellsAlias *topodata.CellsAlias `protobuf:"bytes,2,opt,name=cells_alias,json=cellsAlias,proto3" json:"cells_alias,omitempty"`
}
func (x *UpdateCellsAliasResponse) Reset() {
*x = UpdateCellsAliasResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[116]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *UpdateCellsAliasResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*UpdateCellsAliasResponse) ProtoMessage() {}
func (x *UpdateCellsAliasResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[116]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use UpdateCellsAliasResponse.ProtoReflect.Descriptor instead.
func (*UpdateCellsAliasResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{116}
}
func (x *UpdateCellsAliasResponse) GetName() string {
if x != nil {
return x.Name
}
return ""
}
func (x *UpdateCellsAliasResponse) GetCellsAlias() *topodata.CellsAlias {
if x != nil {
return x.CellsAlias
}
return nil
}
type ValidateRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
PingTablets bool `protobuf:"varint,1,opt,name=ping_tablets,json=pingTablets,proto3" json:"ping_tablets,omitempty"`
}
func (x *ValidateRequest) Reset() {
*x = ValidateRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[117]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ValidateRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ValidateRequest) ProtoMessage() {}
func (x *ValidateRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[117]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ValidateRequest.ProtoReflect.Descriptor instead.
func (*ValidateRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{117}
}
func (x *ValidateRequest) GetPingTablets() bool {
if x != nil {
return x.PingTablets
}
return false
}
type ValidateResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Results []string `protobuf:"bytes,1,rep,name=results,proto3" json:"results,omitempty"`
ResultsByKeyspace map[string]*ValidateKeyspaceResponse `protobuf:"bytes,2,rep,name=results_by_keyspace,json=resultsByKeyspace,proto3" json:"results_by_keyspace,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *ValidateResponse) Reset() {
*x = ValidateResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[118]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ValidateResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ValidateResponse) ProtoMessage() {}
func (x *ValidateResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[118]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ValidateResponse.ProtoReflect.Descriptor instead.
func (*ValidateResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{118}
}
func (x *ValidateResponse) GetResults() []string {
if x != nil {
return x.Results
}
return nil
}
func (x *ValidateResponse) GetResultsByKeyspace() map[string]*ValidateKeyspaceResponse {
if x != nil {
return x.ResultsByKeyspace
}
return nil
}
type ValidateKeyspaceRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Keyspace string `protobuf:"bytes,1,opt,name=keyspace,proto3" json:"keyspace,omitempty"`
PingTablets bool `protobuf:"varint,2,opt,name=ping_tablets,json=pingTablets,proto3" json:"ping_tablets,omitempty"`
}
func (x *ValidateKeyspaceRequest) Reset() {
*x = ValidateKeyspaceRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[119]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ValidateKeyspaceRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ValidateKeyspaceRequest) ProtoMessage() {}
func (x *ValidateKeyspaceRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[119]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ValidateKeyspaceRequest.ProtoReflect.Descriptor instead.
func (*ValidateKeyspaceRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{119}
}
func (x *ValidateKeyspaceRequest) GetKeyspace() string {
if x != nil {
return x.Keyspace
}
return ""
}
func (x *ValidateKeyspaceRequest) GetPingTablets() bool {
if x != nil {
return x.PingTablets
}
return false
}
type ValidateKeyspaceResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Results []string `protobuf:"bytes,1,rep,name=results,proto3" json:"results,omitempty"`
ResultsByShard map[string]*ValidateShardResponse `protobuf:"bytes,2,rep,name=results_by_shard,json=resultsByShard,proto3" json:"results_by_shard,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *ValidateKeyspaceResponse) Reset() {
*x = ValidateKeyspaceResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[120]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ValidateKeyspaceResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ValidateKeyspaceResponse) ProtoMessage() {}
func (x *ValidateKeyspaceResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[120]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ValidateKeyspaceResponse.ProtoReflect.Descriptor instead.
func (*ValidateKeyspaceResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{120}
}
func (x *ValidateKeyspaceResponse) GetResults() []string {
if x != nil {
return x.Results
}
return nil
}
func (x *ValidateKeyspaceResponse) GetResultsByShard() map[string]*ValidateShardResponse {
if x != nil {
return x.ResultsByShard
}
return nil
}
type ValidateShardRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Keyspace string `protobuf:"bytes,1,opt,name=keyspace,proto3" json:"keyspace,omitempty"`
Shard string `protobuf:"bytes,2,opt,name=shard,proto3" json:"shard,omitempty"`
PingTablets bool `protobuf:"varint,3,opt,name=ping_tablets,json=pingTablets,proto3" json:"ping_tablets,omitempty"`
}
func (x *ValidateShardRequest) Reset() {
*x = ValidateShardRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[121]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ValidateShardRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ValidateShardRequest) ProtoMessage() {}
func (x *ValidateShardRequest) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[121]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ValidateShardRequest.ProtoReflect.Descriptor instead.
func (*ValidateShardRequest) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{121}
}
func (x *ValidateShardRequest) GetKeyspace() string {
if x != nil {
return x.Keyspace
}
return ""
}
func (x *ValidateShardRequest) GetShard() string {
if x != nil {
return x.Shard
}
return ""
}
func (x *ValidateShardRequest) GetPingTablets() bool {
if x != nil {
return x.PingTablets
}
return false
}
type ValidateShardResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Results []string `protobuf:"bytes,1,rep,name=results,proto3" json:"results,omitempty"`
}
func (x *ValidateShardResponse) Reset() {
*x = ValidateShardResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[122]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ValidateShardResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ValidateShardResponse) ProtoMessage() {}
func (x *ValidateShardResponse) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[122]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ValidateShardResponse.ProtoReflect.Descriptor instead.
func (*ValidateShardResponse) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{122}
}
func (x *ValidateShardResponse) GetResults() []string {
if x != nil {
return x.Results
}
return nil
}
type Workflow_ReplicationLocation struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Keyspace string `protobuf:"bytes,1,opt,name=keyspace,proto3" json:"keyspace,omitempty"`
Shards []string `protobuf:"bytes,2,rep,name=shards,proto3" json:"shards,omitempty"`
}
func (x *Workflow_ReplicationLocation) Reset() {
*x = Workflow_ReplicationLocation{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[124]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *Workflow_ReplicationLocation) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Workflow_ReplicationLocation) ProtoMessage() {}
func (x *Workflow_ReplicationLocation) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[124]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Workflow_ReplicationLocation.ProtoReflect.Descriptor instead.
func (*Workflow_ReplicationLocation) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{6, 1}
}
func (x *Workflow_ReplicationLocation) GetKeyspace() string {
if x != nil {
return x.Keyspace
}
return ""
}
func (x *Workflow_ReplicationLocation) GetShards() []string {
if x != nil {
return x.Shards
}
return nil
}
type Workflow_ShardStream struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Streams []*Workflow_Stream `protobuf:"bytes,1,rep,name=streams,proto3" json:"streams,omitempty"`
TabletControls []*topodata.Shard_TabletControl `protobuf:"bytes,2,rep,name=tablet_controls,json=tabletControls,proto3" json:"tablet_controls,omitempty"`
IsPrimaryServing bool `protobuf:"varint,3,opt,name=is_primary_serving,json=isPrimaryServing,proto3" json:"is_primary_serving,omitempty"`
}
func (x *Workflow_ShardStream) Reset() {
*x = Workflow_ShardStream{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[125]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *Workflow_ShardStream) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Workflow_ShardStream) ProtoMessage() {}
func (x *Workflow_ShardStream) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[125]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Workflow_ShardStream.ProtoReflect.Descriptor instead.
func (*Workflow_ShardStream) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{6, 2}
}
func (x *Workflow_ShardStream) GetStreams() []*Workflow_Stream {
if x != nil {
return x.Streams
}
return nil
}
func (x *Workflow_ShardStream) GetTabletControls() []*topodata.Shard_TabletControl {
if x != nil {
return x.TabletControls
}
return nil
}
func (x *Workflow_ShardStream) GetIsPrimaryServing() bool {
if x != nil {
return x.IsPrimaryServing
}
return false
}
type Workflow_Stream struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
Shard string `protobuf:"bytes,2,opt,name=shard,proto3" json:"shard,omitempty"`
Tablet *topodata.TabletAlias `protobuf:"bytes,3,opt,name=tablet,proto3" json:"tablet,omitempty"`
BinlogSource *binlogdata.BinlogSource `protobuf:"bytes,4,opt,name=binlog_source,json=binlogSource,proto3" json:"binlog_source,omitempty"`
Position string `protobuf:"bytes,5,opt,name=position,proto3" json:"position,omitempty"`
StopPosition string `protobuf:"bytes,6,opt,name=stop_position,json=stopPosition,proto3" json:"stop_position,omitempty"`
State string `protobuf:"bytes,7,opt,name=state,proto3" json:"state,omitempty"`
DbName string `protobuf:"bytes,8,opt,name=db_name,json=dbName,proto3" json:"db_name,omitempty"`
TransactionTimestamp *vttime.Time `protobuf:"bytes,9,opt,name=transaction_timestamp,json=transactionTimestamp,proto3" json:"transaction_timestamp,omitempty"`
TimeUpdated *vttime.Time `protobuf:"bytes,10,opt,name=time_updated,json=timeUpdated,proto3" json:"time_updated,omitempty"`
Message string `protobuf:"bytes,11,opt,name=message,proto3" json:"message,omitempty"`
CopyStates []*Workflow_Stream_CopyState `protobuf:"bytes,12,rep,name=copy_states,json=copyStates,proto3" json:"copy_states,omitempty"`
Logs []*Workflow_Stream_Log `protobuf:"bytes,13,rep,name=logs,proto3" json:"logs,omitempty"`
// LogFetchError is set if we fail to fetch some logs for this stream. We
// will never fail to fetch workflows because we cannot fetch the logs, but
// we will still forward log-fetch errors to the caller, should that be
// relevant to the context in which they are fetching workflows.
//
// Note that this field being set does not necessarily mean that Logs is nil;
// if there are N logs that exist for the stream, and we fail to fetch the
// ith log, we will still return logs in [0, i) + (i, N].
LogFetchError string `protobuf:"bytes,14,opt,name=log_fetch_error,json=logFetchError,proto3" json:"log_fetch_error,omitempty"`
Tags []string `protobuf:"bytes,15,rep,name=tags,proto3" json:"tags,omitempty"`
}
func (x *Workflow_Stream) Reset() {
*x = Workflow_Stream{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[126]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *Workflow_Stream) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Workflow_Stream) ProtoMessage() {}
func (x *Workflow_Stream) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[126]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Workflow_Stream.ProtoReflect.Descriptor instead.
func (*Workflow_Stream) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{6, 3}
}
func (x *Workflow_Stream) GetId() int64 {
if x != nil {
return x.Id
}
return 0
}
func (x *Workflow_Stream) GetShard() string {
if x != nil {
return x.Shard
}
return ""
}
func (x *Workflow_Stream) GetTablet() *topodata.TabletAlias {
if x != nil {
return x.Tablet
}
return nil
}
func (x *Workflow_Stream) GetBinlogSource() *binlogdata.BinlogSource {
if x != nil {
return x.BinlogSource
}
return nil
}
func (x *Workflow_Stream) GetPosition() string {
if x != nil {
return x.Position
}
return ""
}
func (x *Workflow_Stream) GetStopPosition() string {
if x != nil {
return x.StopPosition
}
return ""
}
func (x *Workflow_Stream) GetState() string {
if x != nil {
return x.State
}
return ""
}
func (x *Workflow_Stream) GetDbName() string {
if x != nil {
return x.DbName
}
return ""
}
func (x *Workflow_Stream) GetTransactionTimestamp() *vttime.Time {
if x != nil {
return x.TransactionTimestamp
}
return nil
}
func (x *Workflow_Stream) GetTimeUpdated() *vttime.Time {
if x != nil {
return x.TimeUpdated
}
return nil
}
func (x *Workflow_Stream) GetMessage() string {
if x != nil {
return x.Message
}
return ""
}
func (x *Workflow_Stream) GetCopyStates() []*Workflow_Stream_CopyState {
if x != nil {
return x.CopyStates
}
return nil
}
func (x *Workflow_Stream) GetLogs() []*Workflow_Stream_Log {
if x != nil {
return x.Logs
}
return nil
}
func (x *Workflow_Stream) GetLogFetchError() string {
if x != nil {
return x.LogFetchError
}
return ""
}
func (x *Workflow_Stream) GetTags() []string {
if x != nil {
return x.Tags
}
return nil
}
type Workflow_Stream_CopyState struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Table string `protobuf:"bytes,1,opt,name=table,proto3" json:"table,omitempty"`
LastPk string `protobuf:"bytes,2,opt,name=last_pk,json=lastPk,proto3" json:"last_pk,omitempty"`
}
func (x *Workflow_Stream_CopyState) Reset() {
*x = Workflow_Stream_CopyState{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[127]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *Workflow_Stream_CopyState) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Workflow_Stream_CopyState) ProtoMessage() {}
func (x *Workflow_Stream_CopyState) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[127]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Workflow_Stream_CopyState.ProtoReflect.Descriptor instead.
func (*Workflow_Stream_CopyState) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{6, 3, 0}
}
func (x *Workflow_Stream_CopyState) GetTable() string {
if x != nil {
return x.Table
}
return ""
}
func (x *Workflow_Stream_CopyState) GetLastPk() string {
if x != nil {
return x.LastPk
}
return ""
}
type Workflow_Stream_Log struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
StreamId int64 `protobuf:"varint,2,opt,name=stream_id,json=streamId,proto3" json:"stream_id,omitempty"`
Type string `protobuf:"bytes,3,opt,name=type,proto3" json:"type,omitempty"`
State string `protobuf:"bytes,4,opt,name=state,proto3" json:"state,omitempty"`
CreatedAt *vttime.Time `protobuf:"bytes,5,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
UpdatedAt *vttime.Time `protobuf:"bytes,6,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
Message string `protobuf:"bytes,7,opt,name=message,proto3" json:"message,omitempty"`
Count int64 `protobuf:"varint,8,opt,name=count,proto3" json:"count,omitempty"`
}
func (x *Workflow_Stream_Log) Reset() {
*x = Workflow_Stream_Log{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[128]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *Workflow_Stream_Log) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Workflow_Stream_Log) ProtoMessage() {}
func (x *Workflow_Stream_Log) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[128]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Workflow_Stream_Log.ProtoReflect.Descriptor instead.
func (*Workflow_Stream_Log) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{6, 3, 1}
}
func (x *Workflow_Stream_Log) GetId() int64 {
if x != nil {
return x.Id
}
return 0
}
func (x *Workflow_Stream_Log) GetStreamId() int64 {
if x != nil {
return x.StreamId
}
return 0
}
func (x *Workflow_Stream_Log) GetType() string {
if x != nil {
return x.Type
}
return ""
}
func (x *Workflow_Stream_Log) GetState() string {
if x != nil {
return x.State
}
return ""
}
func (x *Workflow_Stream_Log) GetCreatedAt() *vttime.Time {
if x != nil {
return x.CreatedAt
}
return nil
}
func (x *Workflow_Stream_Log) GetUpdatedAt() *vttime.Time {
if x != nil {
return x.UpdatedAt
}
return nil
}
func (x *Workflow_Stream_Log) GetMessage() string {
if x != nil {
return x.Message
}
return ""
}
func (x *Workflow_Stream_Log) GetCount() int64 {
if x != nil {
return x.Count
}
return 0
}
type GetSrvKeyspaceNamesResponse_NameList struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Names []string `protobuf:"bytes,1,rep,name=names,proto3" json:"names,omitempty"`
}
func (x *GetSrvKeyspaceNamesResponse_NameList) Reset() {
*x = GetSrvKeyspaceNamesResponse_NameList{}
if protoimpl.UnsafeEnabled {
mi := &file_vtctldata_proto_msgTypes[132]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetSrvKeyspaceNamesResponse_NameList) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetSrvKeyspaceNamesResponse_NameList) ProtoMessage() {}
func (x *GetSrvKeyspaceNamesResponse_NameList) ProtoReflect() protoreflect.Message {
mi := &file_vtctldata_proto_msgTypes[132]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetSrvKeyspaceNamesResponse_NameList.ProtoReflect.Descriptor instead.
func (*GetSrvKeyspaceNamesResponse_NameList) Descriptor() ([]byte, []int) {
return file_vtctldata_proto_rawDescGZIP(), []int{56, 1}
}
func (x *GetSrvKeyspaceNamesResponse_NameList) GetNames() []string {
if x != nil {
return x.Names
}
return nil
}
var File_vtctldata_proto protoreflect.FileDescriptor
var file_vtctldata_proto_rawDesc = []byte{
0x0a, 0x0f, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x12, 0x09, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x1a, 0x10, 0x62, 0x69,
0x6e, 0x6c, 0x6f, 0x67, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x0d,
0x6c, 0x6f, 0x67, 0x75, 0x74, 0x69, 0x6c, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x0e, 0x6d,
0x79, 0x73, 0x71, 0x6c, 0x63, 0x74, 0x6c, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x15, 0x72,
0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x70,
0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x17, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x6d, 0x61, 0x6e, 0x61,
0x67, 0x65, 0x72, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x0e, 0x74,
0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x0d, 0x76,
0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x0c, 0x76, 0x74,
0x74, 0x69, 0x6d, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x57, 0x0a, 0x1a, 0x45, 0x78,
0x65, 0x63, 0x75, 0x74, 0x65, 0x56, 0x74, 0x63, 0x74, 0x6c, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e,
0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x61, 0x72, 0x67, 0x73,
0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x04, 0x61, 0x72, 0x67, 0x73, 0x12, 0x25, 0x0a, 0x0e,
0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x18, 0x02,
0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65,
0x6f, 0x75, 0x74, 0x22, 0x43, 0x0a, 0x1b, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x56, 0x74,
0x63, 0x74, 0x6c, 0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
0x73, 0x65, 0x12, 0x24, 0x0a, 0x05, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28,
0x0b, 0x32, 0x0e, 0x2e, 0x6c, 0x6f, 0x67, 0x75, 0x74, 0x69, 0x6c, 0x2e, 0x45, 0x76, 0x65, 0x6e,
0x74, 0x52, 0x05, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x22, 0x89, 0x01, 0x0a, 0x18, 0x54, 0x61, 0x62,
0x6c, 0x65, 0x4d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x53, 0x65, 0x74,
0x74, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f,
0x74, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x74, 0x61, 0x72,
0x67, 0x65, 0x74, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x12, 0x2b, 0x0a, 0x11, 0x73, 0x6f, 0x75, 0x72,
0x63, 0x65, 0x5f, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20,
0x01, 0x28, 0x09, 0x52, 0x10, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x45, 0x78, 0x70, 0x72, 0x65,
0x73, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x5f,
0x64, 0x64, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x72, 0x65, 0x61, 0x74,
0x65, 0x44, 0x64, 0x6c, 0x22, 0xb2, 0x03, 0x0a, 0x13, 0x4d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61,
0x6c, 0x69, 0x7a, 0x65, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x1a, 0x0a, 0x08,
0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08,
0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x12, 0x27, 0x0a, 0x0f, 0x73, 0x6f, 0x75, 0x72,
0x63, 0x65, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28,
0x09, 0x52, 0x0e, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63,
0x65, 0x12, 0x27, 0x0a, 0x0f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x73,
0x70, 0x61, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x74, 0x61, 0x72, 0x67,
0x65, 0x74, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x26, 0x0a, 0x0f, 0x73, 0x74,
0x6f, 0x70, 0x5f, 0x61, 0x66, 0x74, 0x65, 0x72, 0x5f, 0x63, 0x6f, 0x70, 0x79, 0x18, 0x04, 0x20,
0x01, 0x28, 0x08, 0x52, 0x0d, 0x73, 0x74, 0x6f, 0x70, 0x41, 0x66, 0x74, 0x65, 0x72, 0x43, 0x6f,
0x70, 0x79, 0x12, 0x4a, 0x0a, 0x0e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x73, 0x65, 0x74, 0x74,
0x69, 0x6e, 0x67, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x76, 0x74, 0x63,
0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x4d, 0x61, 0x74, 0x65,
0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x52,
0x0d, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x12,
0x0a, 0x04, 0x63, 0x65, 0x6c, 0x6c, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x63, 0x65,
0x6c, 0x6c, 0x12, 0x21, 0x0a, 0x0c, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70,
0x65, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74,
0x54, 0x79, 0x70, 0x65, 0x73, 0x12, 0x29, 0x0a, 0x10, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61,
0x6c, 0x5f, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52,
0x0f, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72,
0x12, 0x57, 0x0a, 0x16, 0x6d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x74,
0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0e,
0x32, 0x20, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4d, 0x61, 0x74,
0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x74, 0x65,
0x6e, 0x74, 0x52, 0x15, 0x6d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x74,
0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x22, 0x4e, 0x0a, 0x08, 0x4b, 0x65, 0x79,
0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20,
0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x2e, 0x0a, 0x08, 0x6b, 0x65, 0x79,
0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x74, 0x6f,
0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52,
0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x22, 0x5e, 0x0a, 0x05, 0x53, 0x68, 0x61,
0x72, 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01,
0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x12,
0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61,
0x6d, 0x65, 0x12, 0x25, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28,
0x0b, 0x32, 0x0f, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x68, 0x61,
0x72, 0x64, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x22, 0x81, 0x0c, 0x0a, 0x08, 0x57, 0x6f,
0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01,
0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x3f, 0x0a, 0x06, 0x73, 0x6f,
0x75, 0x72, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x76, 0x74, 0x63,
0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e,
0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4c, 0x6f, 0x63, 0x61, 0x74,
0x69, 0x6f, 0x6e, 0x52, 0x06, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x3f, 0x0a, 0x06, 0x74,
0x61, 0x72, 0x67, 0x65, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x76, 0x74,
0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77,
0x2e, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4c, 0x6f, 0x63, 0x61,
0x74, 0x69, 0x6f, 0x6e, 0x52, 0x06, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x12, 0x31, 0x0a, 0x15,
0x6d, 0x61, 0x78, 0x5f, 0x76, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f,
0x6e, 0x5f, 0x6c, 0x61, 0x67, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x12, 0x6d, 0x61, 0x78,
0x56, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4c, 0x61, 0x67, 0x12,
0x4a, 0x0a, 0x0d, 0x73, 0x68, 0x61, 0x72, 0x64, 0x5f, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x73,
0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61,
0x74, 0x61, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x53, 0x68, 0x61, 0x72,
0x64, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0c, 0x73,
0x68, 0x61, 0x72, 0x64, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x73, 0x1a, 0x60, 0x0a, 0x11, 0x53,
0x68, 0x61, 0x72, 0x64, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79,
0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b,
0x65, 0x79, 0x12, 0x35, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28,
0x0b, 0x32, 0x1f, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x57, 0x6f,
0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x53, 0x68, 0x61, 0x72, 0x64, 0x53, 0x74, 0x72, 0x65,
0x61, 0x6d, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x49, 0x0a,
0x13, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4c, 0x6f, 0x63, 0x61,
0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65,
0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65,
0x12, 0x16, 0x0a, 0x06, 0x73, 0x68, 0x61, 0x72, 0x64, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09,
0x52, 0x06, 0x73, 0x68, 0x61, 0x72, 0x64, 0x73, 0x1a, 0xb9, 0x01, 0x0a, 0x0b, 0x53, 0x68, 0x61,
0x72, 0x64, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x12, 0x34, 0x0a, 0x07, 0x73, 0x74, 0x72, 0x65,
0x61, 0x6d, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x76, 0x74, 0x63, 0x74,
0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x53,
0x74, 0x72, 0x65, 0x61, 0x6d, 0x52, 0x07, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x73, 0x12, 0x46,
0x0a, 0x0f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c,
0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61,
0x74, 0x61, 0x2e, 0x53, 0x68, 0x61, 0x72, 0x64, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x43,
0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x52, 0x0e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x43, 0x6f,
0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x73, 0x12, 0x2c, 0x0a, 0x12, 0x69, 0x73, 0x5f, 0x70, 0x72, 0x69,
0x6d, 0x61, 0x72, 0x79, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x6e, 0x67, 0x18, 0x03, 0x20, 0x01,
0x28, 0x08, 0x52, 0x10, 0x69, 0x73, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x53, 0x65, 0x72,
0x76, 0x69, 0x6e, 0x67, 0x1a, 0xf6, 0x06, 0x0a, 0x06, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x12,
0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x02, 0x69, 0x64, 0x12,
0x14, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05,
0x73, 0x68, 0x61, 0x72, 0x64, 0x12, 0x2d, 0x0a, 0x06, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x18,
0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61,
0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x06, 0x74, 0x61,
0x62, 0x6c, 0x65, 0x74, 0x12, 0x3d, 0x0a, 0x0d, 0x62, 0x69, 0x6e, 0x6c, 0x6f, 0x67, 0x5f, 0x73,
0x6f, 0x75, 0x72, 0x63, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x62, 0x69,
0x6e, 0x6c, 0x6f, 0x67, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x42, 0x69, 0x6e, 0x6c, 0x6f, 0x67, 0x53,
0x6f, 0x75, 0x72, 0x63, 0x65, 0x52, 0x0c, 0x62, 0x69, 0x6e, 0x6c, 0x6f, 0x67, 0x53, 0x6f, 0x75,
0x72, 0x63, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18,
0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12,
0x23, 0x0a, 0x0d, 0x73, 0x74, 0x6f, 0x70, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e,
0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x73, 0x74, 0x6f, 0x70, 0x50, 0x6f, 0x73, 0x69,
0x74, 0x69, 0x6f, 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x07, 0x20,
0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x12, 0x17, 0x0a, 0x07, 0x64, 0x62,
0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x64, 0x62, 0x4e,
0x61, 0x6d, 0x65, 0x12, 0x41, 0x0a, 0x15, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69,
0x6f, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x09, 0x20, 0x01,
0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x76, 0x74, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x54, 0x69, 0x6d, 0x65,
0x52, 0x14, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d,
0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x2f, 0x0a, 0x0c, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x75,
0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x76,
0x74, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x52, 0x0b, 0x74, 0x69, 0x6d, 0x65,
0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61,
0x67, 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
0x65, 0x12, 0x45, 0x0a, 0x0b, 0x63, 0x6f, 0x70, 0x79, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x73,
0x18, 0x0c, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61,
0x74, 0x61, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x53, 0x74, 0x72, 0x65,
0x61, 0x6d, 0x2e, 0x43, 0x6f, 0x70, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x0a, 0x63, 0x6f,
0x70, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x73, 0x12, 0x32, 0x0a, 0x04, 0x6c, 0x6f, 0x67, 0x73,
0x18, 0x0d, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61,
0x74, 0x61, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x2e, 0x53, 0x74, 0x72, 0x65,
0x61, 0x6d, 0x2e, 0x4c, 0x6f, 0x67, 0x52, 0x04, 0x6c, 0x6f, 0x67, 0x73, 0x12, 0x26, 0x0a, 0x0f,
0x6c, 0x6f, 0x67, 0x5f, 0x66, 0x65, 0x74, 0x63, 0x68, 0x5f, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18,
0x0e, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x6c, 0x6f, 0x67, 0x46, 0x65, 0x74, 0x63, 0x68, 0x45,
0x72, 0x72, 0x6f, 0x72, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x61, 0x67, 0x73, 0x18, 0x0f, 0x20, 0x03,
0x28, 0x09, 0x52, 0x04, 0x74, 0x61, 0x67, 0x73, 0x1a, 0x3a, 0x0a, 0x09, 0x43, 0x6f, 0x70, 0x79,
0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x01,
0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x12, 0x17, 0x0a, 0x07, 0x6c,
0x61, 0x73, 0x74, 0x5f, 0x70, 0x6b, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x6c, 0x61,
0x73, 0x74, 0x50, 0x6b, 0x1a, 0xe6, 0x01, 0x0a, 0x03, 0x4c, 0x6f, 0x67, 0x12, 0x0e, 0x0a, 0x02,
0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x02, 0x69, 0x64, 0x12, 0x1b, 0x0a, 0x09,
0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52,
0x08, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x49, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70,
0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x14, 0x0a,
0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x74,
0x61, 0x74, 0x65, 0x12, 0x2b, 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61,
0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x76, 0x74, 0x74, 0x69, 0x6d, 0x65,
0x2e, 0x54, 0x69, 0x6d, 0x65, 0x52, 0x09, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74,
0x12, 0x2b, 0x0a, 0x0a, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x06,
0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x76, 0x74, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x54, 0x69,
0x6d, 0x65, 0x52, 0x09, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x12, 0x18, 0x0a,
0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07,
0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74,
0x18, 0x08, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x59, 0x0a,
0x12, 0x41, 0x64, 0x64, 0x43, 0x65, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75,
0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28,
0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x2f, 0x0a, 0x09, 0x63, 0x65, 0x6c, 0x6c, 0x5f,
0x69, 0x6e, 0x66, 0x6f, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x74, 0x6f, 0x70,
0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x08,
0x63, 0x65, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0x15, 0x0a, 0x13, 0x41, 0x64, 0x64, 0x43,
0x65, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
0x40, 0x0a, 0x14, 0x41, 0x64, 0x64, 0x43, 0x65, 0x6c, 0x6c, 0x73, 0x41, 0x6c, 0x69, 0x61, 0x73,
0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18,
0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x63,
0x65, 0x6c, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x63, 0x65, 0x6c, 0x6c,
0x73, 0x22, 0x17, 0x0a, 0x15, 0x41, 0x64, 0x64, 0x43, 0x65, 0x6c, 0x6c, 0x73, 0x41, 0x6c, 0x69,
0x61, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x9e, 0x01, 0x0a, 0x18, 0x41,
0x70, 0x70, 0x6c, 0x79, 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73,
0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3a, 0x0a, 0x0d, 0x72, 0x6f, 0x75, 0x74, 0x69,
0x6e, 0x67, 0x5f, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15,
0x2e, 0x76, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x2e, 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67,
0x52, 0x75, 0x6c, 0x65, 0x73, 0x52, 0x0c, 0x72, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x52, 0x75,
0x6c, 0x65, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x6b, 0x69, 0x70, 0x5f, 0x72, 0x65, 0x62, 0x75,
0x69, 0x6c, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x73, 0x6b, 0x69, 0x70, 0x52,
0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x62, 0x75, 0x69, 0x6c,
0x64, 0x5f, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0c, 0x72,
0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x43, 0x65, 0x6c, 0x6c, 0x73, 0x22, 0x1b, 0x0a, 0x19, 0x41,
0x70, 0x70, 0x6c, 0x79, 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73,
0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xc3, 0x01, 0x0a, 0x13, 0x41, 0x70, 0x70,
0x6c, 0x79, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01,
0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x21, 0x0a, 0x0c,
0x73, 0x6b, 0x69, 0x70, 0x5f, 0x72, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x18, 0x02, 0x20, 0x01,
0x28, 0x08, 0x52, 0x0b, 0x73, 0x6b, 0x69, 0x70, 0x52, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x12,
0x17, 0x0a, 0x07, 0x64, 0x72, 0x79, 0x5f, 0x72, 0x75, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08,
0x52, 0x06, 0x64, 0x72, 0x79, 0x52, 0x75, 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x65, 0x6c, 0x6c,
0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x12, 0x2c,
0x0a, 0x08, 0x76, 0x5f, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b,
0x32, 0x11, 0x2e, 0x76, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x2e, 0x4b, 0x65, 0x79, 0x73, 0x70,
0x61, 0x63, 0x65, 0x52, 0x07, 0x76, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x12, 0x10, 0x0a, 0x03,
0x73, 0x71, 0x6c, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x73, 0x71, 0x6c, 0x22, 0x44,
0x0a, 0x14, 0x41, 0x70, 0x70, 0x6c, 0x79, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65,
0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2c, 0x0a, 0x08, 0x76, 0x5f, 0x73, 0x63, 0x68, 0x65,
0x6d, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x76, 0x73, 0x63, 0x68, 0x65,
0x6d, 0x61, 0x2e, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x07, 0x76, 0x53, 0x63,
0x68, 0x65, 0x6d, 0x61, 0x22, 0x9b, 0x01, 0x0a, 0x17, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x54,
0x61, 0x62, 0x6c, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
0x12, 0x38, 0x0a, 0x0c, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73,
0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74,
0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0b, 0x74,
0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x12, 0x2d, 0x0a, 0x07, 0x64, 0x62,
0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x14, 0x2e, 0x74, 0x6f,
0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x54, 0x79, 0x70,
0x65, 0x52, 0x06, 0x64, 0x62, 0x54, 0x79, 0x70, 0x65, 0x12, 0x17, 0x0a, 0x07, 0x64, 0x72, 0x79,
0x5f, 0x72, 0x75, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x64, 0x72, 0x79, 0x52,
0x75, 0x6e, 0x22, 0xa6, 0x01, 0x0a, 0x18, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x54, 0x61, 0x62,
0x6c, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12,
0x35, 0x0a, 0x0d, 0x62, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x5f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74,
0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74,
0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x52, 0x0c, 0x62, 0x65, 0x66, 0x6f, 0x72, 0x65,
0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x12, 0x33, 0x0a, 0x0c, 0x61, 0x66, 0x74, 0x65, 0x72, 0x5f,
0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x74,
0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x52, 0x0b,
0x61, 0x66, 0x74, 0x65, 0x72, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x12, 0x1e, 0x0a, 0x0b, 0x77,
0x61, 0x73, 0x5f, 0x64, 0x72, 0x79, 0x5f, 0x72, 0x75, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08,
0x52, 0x09, 0x77, 0x61, 0x73, 0x44, 0x72, 0x79, 0x52, 0x75, 0x6e, 0x22, 0xb6, 0x03, 0x0a, 0x15,
0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65,
0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20,
0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x66, 0x6f, 0x72,
0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x12,
0x2f, 0x0a, 0x14, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x5f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x5f, 0x76,
0x5f, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x11, 0x61,
0x6c, 0x6c, 0x6f, 0x77, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61,
0x12, 0x30, 0x0a, 0x14, 0x73, 0x68, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x63, 0x6f, 0x6c,
0x75, 0x6d, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12,
0x73, 0x68, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x4e, 0x61,
0x6d, 0x65, 0x12, 0x4a, 0x0a, 0x14, 0x73, 0x68, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x63,
0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e,
0x32, 0x18, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4b, 0x65, 0x79, 0x73,
0x70, 0x61, 0x63, 0x65, 0x49, 0x64, 0x54, 0x79, 0x70, 0x65, 0x52, 0x12, 0x73, 0x68, 0x61, 0x72,
0x64, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x12, 0x40,
0x0a, 0x0c, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x5f, 0x66, 0x72, 0x6f, 0x6d, 0x73, 0x18, 0x06,
0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e,
0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x2e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x64, 0x46,
0x72, 0x6f, 0x6d, 0x52, 0x0b, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x46, 0x72, 0x6f, 0x6d, 0x73,
0x12, 0x2a, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x16,
0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61,
0x63, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x23, 0x0a, 0x0d,
0x62, 0x61, 0x73, 0x65, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x08, 0x20,
0x01, 0x28, 0x09, 0x52, 0x0c, 0x62, 0x61, 0x73, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63,
0x65, 0x12, 0x31, 0x0a, 0x0d, 0x73, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x5f, 0x74, 0x69,
0x6d, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x76, 0x74, 0x74, 0x69, 0x6d,
0x65, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x52, 0x0c, 0x73, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74,
0x54, 0x69, 0x6d, 0x65, 0x22, 0x49, 0x0a, 0x16, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x4b, 0x65,
0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2f,
0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b,
0x32, 0x13, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4b, 0x65, 0x79,
0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x22,
0x8c, 0x01, 0x0a, 0x12, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52,
0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61,
0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61,
0x63, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x68, 0x61, 0x72, 0x64, 0x5f, 0x6e, 0x61, 0x6d, 0x65,
0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x68, 0x61, 0x72, 0x64, 0x4e, 0x61, 0x6d,
0x65, 0x12, 0x14, 0x0a, 0x05, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08,
0x52, 0x05, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x69, 0x6e, 0x63, 0x6c, 0x75,
0x64, 0x65, 0x5f, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52,
0x0d, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x50, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x22, 0xa0,
0x01, 0x0a, 0x13, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65,
0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2f, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61,
0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c,
0x64, 0x61, 0x74, 0x61, 0x2e, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x08, 0x6b,
0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x26, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64,
0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61,
0x74, 0x61, 0x2e, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x12,
0x30, 0x0a, 0x14, 0x73, 0x68, 0x61, 0x72, 0x64, 0x5f, 0x61, 0x6c, 0x72, 0x65, 0x61, 0x64, 0x79,
0x5f, 0x65, 0x78, 0x69, 0x73, 0x74, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x12, 0x73,
0x68, 0x61, 0x72, 0x64, 0x41, 0x6c, 0x72, 0x65, 0x61, 0x64, 0x79, 0x45, 0x78, 0x69, 0x73, 0x74,
0x73, 0x22, 0x41, 0x0a, 0x15, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x43, 0x65, 0x6c, 0x6c, 0x49,
0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61,
0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x14,
0x0a, 0x05, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x66,
0x6f, 0x72, 0x63, 0x65, 0x22, 0x18, 0x0a, 0x16, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x43, 0x65,
0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2d,
0x0a, 0x17, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x43, 0x65, 0x6c, 0x6c, 0x73, 0x41, 0x6c, 0x69,
0x61, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d,
0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x1a, 0x0a,
0x18, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x43, 0x65, 0x6c, 0x6c, 0x73, 0x41, 0x6c, 0x69, 0x61,
0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x51, 0x0a, 0x15, 0x44, 0x65, 0x6c,
0x65, 0x74, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65,
0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01,
0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x1c,
0x0a, 0x09, 0x72, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x76, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28,
0x08, 0x52, 0x09, 0x72, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x76, 0x65, 0x22, 0x18, 0x0a, 0x16,
0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65,
0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x85, 0x01, 0x0a, 0x13, 0x44, 0x65, 0x6c, 0x65, 0x74,
0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x28,
0x0a, 0x06, 0x73, 0x68, 0x61, 0x72, 0x64, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x10,
0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x68, 0x61, 0x72, 0x64,
0x52, 0x06, 0x73, 0x68, 0x61, 0x72, 0x64, 0x73, 0x12, 0x1c, 0x0a, 0x09, 0x72, 0x65, 0x63, 0x75,
0x72, 0x73, 0x69, 0x76, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x72, 0x65, 0x63,
0x75, 0x72, 0x73, 0x69, 0x76, 0x65, 0x12, 0x26, 0x0a, 0x0f, 0x65, 0x76, 0x65, 0x6e, 0x5f, 0x69,
0x66, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x6e, 0x67, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52,
0x0d, 0x65, 0x76, 0x65, 0x6e, 0x49, 0x66, 0x53, 0x65, 0x72, 0x76, 0x69, 0x6e, 0x67, 0x22, 0x16,
0x0a, 0x14, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x73, 0x52, 0x65,
0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2d, 0x0a, 0x17, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65,
0x53, 0x72, 0x76, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
0x74, 0x12, 0x12, 0x0a, 0x04, 0x63, 0x65, 0x6c, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
0x04, 0x63, 0x65, 0x6c, 0x6c, 0x22, 0x1a, 0x0a, 0x18, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x53,
0x72, 0x76, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
0x65, 0x22, 0x79, 0x0a, 0x14, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x54, 0x61, 0x62, 0x6c, 0x65,
0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3c, 0x0a, 0x0e, 0x74, 0x61, 0x62,
0x6c, 0x65, 0x74, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28,
0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62,
0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0d, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74,
0x41, 0x6c, 0x69, 0x61, 0x73, 0x65, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x61, 0x6c, 0x6c, 0x6f, 0x77,
0x5f, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c,
0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x17, 0x0a, 0x15,
0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x73, 0x52, 0x65, 0x73,
0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x8f, 0x02, 0x0a, 0x1d, 0x45, 0x6d, 0x65, 0x72, 0x67, 0x65,
0x6e, 0x63, 0x79, 0x52, 0x65, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64,
0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70,
0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70,
0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x02, 0x20, 0x01,
0x28, 0x09, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x12, 0x36, 0x0a, 0x0b, 0x6e, 0x65, 0x77,
0x5f, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15,
0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74,
0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0a, 0x6e, 0x65, 0x77, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72,
0x79, 0x12, 0x3e, 0x0a, 0x0f, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x5f, 0x72, 0x65, 0x70, 0x6c,
0x69, 0x63, 0x61, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70,
0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61,
0x73, 0x52, 0x0e, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61,
0x73, 0x12, 0x44, 0x0a, 0x15, 0x77, 0x61, 0x69, 0x74, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63,
0x61, 0x73, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b,
0x32, 0x10, 0x2e, 0x76, 0x74, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69,
0x6f, 0x6e, 0x52, 0x13, 0x77, 0x61, 0x69, 0x74, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73,
0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x22, 0xbc, 0x01, 0x0a, 0x1e, 0x45, 0x6d, 0x65, 0x72,
0x67, 0x65, 0x6e, 0x63, 0x79, 0x52, 0x65, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x53, 0x68, 0x61,
0x72, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65,
0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65,
0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18,
0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x12, 0x40, 0x0a, 0x10,
0x70, 0x72, 0x6f, 0x6d, 0x6f, 0x74, 0x65, 0x64, 0x5f, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79,
0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74,
0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0f, 0x70,
0x72, 0x6f, 0x6d, 0x6f, 0x74, 0x65, 0x64, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x26,
0x0a, 0x06, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0e,
0x2e, 0x6c, 0x6f, 0x67, 0x75, 0x74, 0x69, 0x6c, 0x2e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x06,
0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x22, 0x3c, 0x0a, 0x1e, 0x46, 0x69, 0x6e, 0x64, 0x41, 0x6c,
0x6c, 0x53, 0x68, 0x61, 0x72, 0x64, 0x73, 0x49, 0x6e, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63,
0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73,
0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73,
0x70, 0x61, 0x63, 0x65, 0x22, 0xbe, 0x01, 0x0a, 0x1f, 0x46, 0x69, 0x6e, 0x64, 0x41, 0x6c, 0x6c,
0x53, 0x68, 0x61, 0x72, 0x64, 0x73, 0x49, 0x6e, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65,
0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4e, 0x0a, 0x06, 0x73, 0x68, 0x61, 0x72,
0x64, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x36, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c,
0x64, 0x61, 0x74, 0x61, 0x2e, 0x46, 0x69, 0x6e, 0x64, 0x41, 0x6c, 0x6c, 0x53, 0x68, 0x61, 0x72,
0x64, 0x73, 0x49, 0x6e, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70,
0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x53, 0x68, 0x61, 0x72, 0x64, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79,
0x52, 0x06, 0x73, 0x68, 0x61, 0x72, 0x64, 0x73, 0x1a, 0x4b, 0x0a, 0x0b, 0x53, 0x68, 0x61, 0x72,
0x64, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01,
0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x26, 0x0a, 0x05, 0x76, 0x61, 0x6c,
0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c,
0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75,
0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x9e, 0x01, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x42, 0x61, 0x63,
0x6b, 0x75, 0x70, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b,
0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b,
0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64,
0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x12, 0x14, 0x0a,
0x05, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x6c, 0x69,
0x6d, 0x69, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x18,
0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x12,
0x25, 0x0a, 0x0e, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x5f, 0x6c, 0x69, 0x6d, 0x69,
0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0d, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x65,
0x64, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0x44, 0x0a, 0x12, 0x47, 0x65, 0x74, 0x42, 0x61, 0x63,
0x6b, 0x75, 0x70, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2e, 0x0a, 0x07,
0x62, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e,
0x6d, 0x79, 0x73, 0x71, 0x6c, 0x63, 0x74, 0x6c, 0x2e, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x49,
0x6e, 0x66, 0x6f, 0x52, 0x07, 0x62, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x73, 0x22, 0x28, 0x0a, 0x12,
0x47, 0x65, 0x74, 0x43, 0x65, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65,
0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x63, 0x65, 0x6c, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
0x52, 0x04, 0x63, 0x65, 0x6c, 0x6c, 0x22, 0x46, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x43, 0x65, 0x6c,
0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2f, 0x0a,
0x09, 0x63, 0x65, 0x6c, 0x6c, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b,
0x32, 0x12, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x43, 0x65, 0x6c, 0x6c,
0x49, 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x63, 0x65, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0x19,
0x0a, 0x17, 0x47, 0x65, 0x74, 0x43, 0x65, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x4e, 0x61, 0x6d,
0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x30, 0x0a, 0x18, 0x47, 0x65, 0x74,
0x43, 0x65, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x52, 0x65, 0x73,
0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x18, 0x01,
0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x22, 0x18, 0x0a, 0x16, 0x47,
0x65, 0x74, 0x43, 0x65, 0x6c, 0x6c, 0x73, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x65, 0x73, 0x52, 0x65,
0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0xb6, 0x01, 0x0a, 0x17, 0x47, 0x65, 0x74, 0x43, 0x65, 0x6c,
0x6c, 0x73, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
0x65, 0x12, 0x49, 0x0a, 0x07, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03,
0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47,
0x65, 0x74, 0x43, 0x65, 0x6c, 0x6c, 0x73, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x65, 0x73, 0x52, 0x65,
0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x65, 0x73, 0x45, 0x6e,
0x74, 0x72, 0x79, 0x52, 0x07, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x65, 0x73, 0x1a, 0x50, 0x0a, 0x0c,
0x41, 0x6c, 0x69, 0x61, 0x73, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03,
0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x2a,
0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e,
0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x73, 0x41, 0x6c,
0x69, 0x61, 0x73, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x15,
0x0a, 0x13, 0x47, 0x65, 0x74, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x52, 0x65,
0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x49, 0x0a, 0x14, 0x47, 0x65, 0x74, 0x4b, 0x65, 0x79, 0x73,
0x70, 0x61, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x31, 0x0a,
0x09, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b,
0x32, 0x13, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4b, 0x65, 0x79,
0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x09, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73,
0x22, 0x30, 0x0a, 0x12, 0x47, 0x65, 0x74, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52,
0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61,
0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61,
0x63, 0x65, 0x22, 0x46, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63,
0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2f, 0x0a, 0x08, 0x6b, 0x65, 0x79,
0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x76, 0x74,
0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65,
0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x22, 0x18, 0x0a, 0x16, 0x47, 0x65,
0x74, 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x71,
0x75, 0x65, 0x73, 0x74, 0x22, 0x55, 0x0a, 0x17, 0x47, 0x65, 0x74, 0x52, 0x6f, 0x75, 0x74, 0x69,
0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12,
0x3a, 0x0a, 0x0d, 0x72, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x72, 0x75, 0x6c, 0x65, 0x73,
0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x76, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61,
0x2e, 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x52, 0x0c, 0x72,
0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x22, 0x84, 0x02, 0x0a, 0x10,
0x47, 0x65, 0x74, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
0x12, 0x38, 0x0a, 0x0c, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73,
0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74,
0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0b, 0x74,
0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x74, 0x61,
0x62, 0x6c, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x74, 0x61, 0x62, 0x6c,
0x65, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x74, 0x61,
0x62, 0x6c, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0d, 0x65, 0x78, 0x63, 0x6c,
0x75, 0x64, 0x65, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x69, 0x6e, 0x63,
0x6c, 0x75, 0x64, 0x65, 0x5f, 0x76, 0x69, 0x65, 0x77, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08,
0x52, 0x0c, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x56, 0x69, 0x65, 0x77, 0x73, 0x12, 0x28,
0x0a, 0x10, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x5f, 0x6f, 0x6e,
0x6c, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x4e,
0x61, 0x6d, 0x65, 0x73, 0x4f, 0x6e, 0x6c, 0x79, 0x12, 0x28, 0x0a, 0x10, 0x74, 0x61, 0x62, 0x6c,
0x65, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x73, 0x5f, 0x6f, 0x6e, 0x6c, 0x79, 0x18, 0x06, 0x20, 0x01,
0x28, 0x08, 0x52, 0x0e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x53, 0x69, 0x7a, 0x65, 0x73, 0x4f, 0x6e,
0x6c, 0x79, 0x22, 0x50, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52,
0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3b, 0x0a, 0x06, 0x73, 0x63, 0x68, 0x65, 0x6d,
0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74,
0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x63, 0x68, 0x65,
0x6d, 0x61, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x06, 0x73, 0x63,
0x68, 0x65, 0x6d, 0x61, 0x22, 0x4c, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64,
0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70,
0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70,
0x61, 0x63, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x68, 0x61, 0x72, 0x64, 0x5f, 0x6e, 0x61, 0x6d,
0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x68, 0x61, 0x72, 0x64, 0x4e, 0x61,
0x6d, 0x65, 0x22, 0x3a, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65,
0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x26, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18,
0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74,
0x61, 0x2e, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x22, 0x32,
0x0a, 0x1a, 0x47, 0x65, 0x74, 0x53, 0x72, 0x76, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65,
0x4e, 0x61, 0x6d, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x14, 0x0a, 0x05,
0x63, 0x65, 0x6c, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x63, 0x65, 0x6c,
0x6c, 0x73, 0x22, 0xf3, 0x01, 0x0a, 0x1b, 0x47, 0x65, 0x74, 0x53, 0x72, 0x76, 0x4b, 0x65, 0x79,
0x73, 0x70, 0x61, 0x63, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
0x73, 0x65, 0x12, 0x47, 0x0a, 0x05, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28,
0x0b, 0x32, 0x31, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65,
0x74, 0x53, 0x72, 0x76, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x4e, 0x61, 0x6d, 0x65,
0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x45,
0x6e, 0x74, 0x72, 0x79, 0x52, 0x05, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x1a, 0x69, 0x0a, 0x0a, 0x4e,
0x61, 0x6d, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79,
0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x45, 0x0a, 0x05, 0x76,
0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x76, 0x74, 0x63,
0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x72, 0x76, 0x4b, 0x65, 0x79,
0x73, 0x70, 0x61, 0x63, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
0x73, 0x65, 0x2e, 0x4e, 0x61, 0x6d, 0x65, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x05, 0x76, 0x61, 0x6c,
0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x20, 0x0a, 0x08, 0x4e, 0x61, 0x6d, 0x65, 0x4c, 0x69,
0x73, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28,
0x09, 0x52, 0x05, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x22, 0x4a, 0x0a, 0x16, 0x47, 0x65, 0x74, 0x53,
0x72, 0x76, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65,
0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01,
0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14,
0x0a, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x63,
0x65, 0x6c, 0x6c, 0x73, 0x22, 0xcc, 0x01, 0x0a, 0x17, 0x47, 0x65, 0x74, 0x53, 0x72, 0x76, 0x4b,
0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
0x12, 0x59, 0x0a, 0x0d, 0x73, 0x72, 0x76, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65,
0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x34, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64,
0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x72, 0x76, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61,
0x63, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x53, 0x72, 0x76, 0x4b,
0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0c, 0x73,
0x72, 0x76, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x1a, 0x56, 0x0a, 0x11, 0x53,
0x72, 0x76, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79,
0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b,
0x65, 0x79, 0x12, 0x2b, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28,
0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x72, 0x76,
0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a,
0x02, 0x38, 0x01, 0x22, 0x2a, 0x0a, 0x14, 0x47, 0x65, 0x74, 0x53, 0x72, 0x76, 0x56, 0x53, 0x63,
0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x63,
0x65, 0x6c, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x63, 0x65, 0x6c, 0x6c, 0x22,
0x4e, 0x0a, 0x15, 0x47, 0x65, 0x74, 0x53, 0x72, 0x76, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61,
0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x35, 0x0a, 0x0c, 0x73, 0x72, 0x76, 0x5f,
0x76, 0x5f, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13,
0x2e, 0x76, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x2e, 0x53, 0x72, 0x76, 0x56, 0x53, 0x63, 0x68,
0x65, 0x6d, 0x61, 0x52, 0x0a, 0x73, 0x72, 0x76, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22,
0x2d, 0x0a, 0x15, 0x47, 0x65, 0x74, 0x53, 0x72, 0x76, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61,
0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x65, 0x6c, 0x6c,
0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x22, 0xc5,
0x01, 0x0a, 0x16, 0x47, 0x65, 0x74, 0x53, 0x72, 0x76, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61,
0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x56, 0x0a, 0x0d, 0x73, 0x72, 0x76,
0x5f, 0x76, 0x5f, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b,
0x32, 0x32, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x47, 0x65, 0x74,
0x53, 0x72, 0x76, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f,
0x6e, 0x73, 0x65, 0x2e, 0x53, 0x72, 0x76, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x73, 0x45,
0x6e, 0x74, 0x72, 0x79, 0x52, 0x0b, 0x73, 0x72, 0x76, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61,
0x73, 0x1a, 0x53, 0x0a, 0x10, 0x53, 0x72, 0x76, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x73,
0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01,
0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x29, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65,
0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x76, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61,
0x2e, 0x53, 0x72, 0x76, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x05, 0x76, 0x61, 0x6c,
0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x4c, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x54, 0x61, 0x62,
0x6c, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x38, 0x0a, 0x0c, 0x74, 0x61,
0x62, 0x6c, 0x65, 0x74, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b,
0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c,
0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41,
0x6c, 0x69, 0x61, 0x73, 0x22, 0x3d, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x54, 0x61, 0x62, 0x6c, 0x65,
0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x28, 0x0a, 0x06, 0x74, 0x61, 0x62,
0x6c, 0x65, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x74, 0x6f, 0x70, 0x6f,
0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x52, 0x06, 0x74, 0x61, 0x62,
0x6c, 0x65, 0x74, 0x22, 0xb1, 0x01, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x54, 0x61, 0x62, 0x6c, 0x65,
0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79,
0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79,
0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x02,
0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x63,
0x65, 0x6c, 0x6c, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x63, 0x65, 0x6c, 0x6c,
0x73, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28,
0x08, 0x52, 0x06, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x12, 0x3c, 0x0a, 0x0e, 0x74, 0x61, 0x62,
0x6c, 0x65, 0x74, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x65, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28,
0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62,
0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0d, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74,
0x41, 0x6c, 0x69, 0x61, 0x73, 0x65, 0x73, 0x22, 0x40, 0x0a, 0x12, 0x47, 0x65, 0x74, 0x54, 0x61,
0x62, 0x6c, 0x65, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2a, 0x0a,
0x07, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x10,
0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74,
0x52, 0x07, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x73, 0x22, 0x2f, 0x0a, 0x11, 0x47, 0x65, 0x74,
0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a,
0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x22, 0x42, 0x0a, 0x12, 0x47, 0x65,
0x74, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
0x12, 0x2c, 0x0a, 0x08, 0x76, 0x5f, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x18, 0x01, 0x20, 0x01,
0x28, 0x0b, 0x32, 0x11, 0x2e, 0x76, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x2e, 0x4b, 0x65, 0x79,
0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x07, 0x76, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x52,
0x0a, 0x13, 0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x73, 0x52, 0x65,
0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63,
0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63,
0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x6f, 0x6e, 0x6c, 0x79,
0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x4f, 0x6e,
0x6c, 0x79, 0x22, 0x49, 0x0a, 0x14, 0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f,
0x77, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x31, 0x0a, 0x09, 0x77, 0x6f,
0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x13, 0x2e,
0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c,
0x6f, 0x77, 0x52, 0x09, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x73, 0x22, 0xfb, 0x01,
0x0a, 0x17, 0x49, 0x6e, 0x69, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x50, 0x72, 0x69, 0x6d, 0x61,
0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79,
0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79,
0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x02,
0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x12, 0x52, 0x0a, 0x1a, 0x70,
0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x5f, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x5f, 0x74, 0x61, 0x62,
0x6c, 0x65, 0x74, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32,
0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65,
0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x17, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x45,
0x6c, 0x65, 0x63, 0x74, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x12,
0x14, 0x0a, 0x05, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05,
0x66, 0x6f, 0x72, 0x63, 0x65, 0x12, 0x44, 0x0a, 0x15, 0x77, 0x61, 0x69, 0x74, 0x5f, 0x72, 0x65,
0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x18, 0x05,
0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x76, 0x74, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x44, 0x75,
0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x13, 0x77, 0x61, 0x69, 0x74, 0x52, 0x65, 0x70, 0x6c,
0x69, 0x63, 0x61, 0x73, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x22, 0x42, 0x0a, 0x18, 0x49,
0x6e, 0x69, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x52,
0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x26, 0x0a, 0x06, 0x65, 0x76, 0x65, 0x6e, 0x74,
0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x6c, 0x6f, 0x67, 0x75, 0x74, 0x69,
0x6c, 0x2e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x06, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x22,
0x4d, 0x0a, 0x11, 0x50, 0x69, 0x6e, 0x67, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x52, 0x65, 0x71,
0x75, 0x65, 0x73, 0x74, 0x12, 0x38, 0x0a, 0x0c, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x61,
0x6c, 0x69, 0x61, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70,
0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61,
0x73, 0x52, 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x22, 0x14,
0x0a, 0x12, 0x50, 0x69, 0x6e, 0x67, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70,
0x6f, 0x6e, 0x73, 0x65, 0x22, 0x89, 0x02, 0x0a, 0x1b, 0x50, 0x6c, 0x61, 0x6e, 0x6e, 0x65, 0x64,
0x52, 0x65, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x71,
0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65,
0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65,
0x12, 0x14, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x12, 0x36, 0x0a, 0x0b, 0x6e, 0x65, 0x77, 0x5f, 0x70, 0x72,
0x69, 0x6d, 0x61, 0x72, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f,
0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69,
0x61, 0x73, 0x52, 0x0a, 0x6e, 0x65, 0x77, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x3a,
0x0a, 0x0d, 0x61, 0x76, 0x6f, 0x69, 0x64, 0x5f, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x18,
0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61,
0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0c, 0x61, 0x76,
0x6f, 0x69, 0x64, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x44, 0x0a, 0x15, 0x77, 0x61,
0x69, 0x74, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x5f, 0x74, 0x69, 0x6d, 0x65,
0x6f, 0x75, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x76, 0x74, 0x74, 0x69,
0x6d, 0x65, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x13, 0x77, 0x61, 0x69,
0x74, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74,
0x22, 0xba, 0x01, 0x0a, 0x1c, 0x50, 0x6c, 0x61, 0x6e, 0x6e, 0x65, 0x64, 0x52, 0x65, 0x70, 0x61,
0x72, 0x65, 0x6e, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
0x65, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20,
0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a,
0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x68,
0x61, 0x72, 0x64, 0x12, 0x40, 0x0a, 0x10, 0x70, 0x72, 0x6f, 0x6d, 0x6f, 0x74, 0x65, 0x64, 0x5f,
0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e,
0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41,
0x6c, 0x69, 0x61, 0x73, 0x52, 0x0f, 0x70, 0x72, 0x6f, 0x6d, 0x6f, 0x74, 0x65, 0x64, 0x50, 0x72,
0x69, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x26, 0x0a, 0x06, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x18,
0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x6c, 0x6f, 0x67, 0x75, 0x74, 0x69, 0x6c, 0x2e,
0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x06, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x22, 0x74, 0x0a,
0x1b, 0x52, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65,
0x47, 0x72, 0x61, 0x70, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08,
0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08,
0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x65, 0x6c, 0x6c,
0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x12, 0x23,
0x0a, 0x0d, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x18,
0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x50, 0x61, 0x72, 0x74,
0x69, 0x61, 0x6c, 0x22, 0x1e, 0x0a, 0x1c, 0x52, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x4b, 0x65,
0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x47, 0x72, 0x61, 0x70, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f,
0x6e, 0x73, 0x65, 0x22, 0x32, 0x0a, 0x1a, 0x52, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x56, 0x53,
0x63, 0x68, 0x65, 0x6d, 0x61, 0x47, 0x72, 0x61, 0x70, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
0x74, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09,
0x52, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x22, 0x1d, 0x0a, 0x1b, 0x52, 0x65, 0x62, 0x75, 0x69,
0x6c, 0x64, 0x56, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x47, 0x72, 0x61, 0x70, 0x68, 0x52, 0x65,
0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x4f, 0x0a, 0x13, 0x52, 0x65, 0x66, 0x72, 0x65, 0x73,
0x68, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x38, 0x0a,
0x0c, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, 0x01, 0x20,
0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54,
0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0b, 0x74, 0x61, 0x62, 0x6c,
0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x22, 0x16, 0x0a, 0x14, 0x52, 0x65, 0x66, 0x72, 0x65,
0x73, 0x68, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
0x64, 0x0a, 0x1a, 0x52, 0x65, 0x66, 0x72, 0x65, 0x73, 0x68, 0x53, 0x74, 0x61, 0x74, 0x65, 0x42,
0x79, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a,
0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x68, 0x61,
0x72, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x12,
0x14, 0x0a, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05,
0x63, 0x65, 0x6c, 0x6c, 0x73, 0x22, 0x4b, 0x0a, 0x1b, 0x52, 0x65, 0x66, 0x72, 0x65, 0x73, 0x68,
0x53, 0x74, 0x61, 0x74, 0x65, 0x42, 0x79, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x73, 0x70,
0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2c, 0x0a, 0x12, 0x69, 0x73, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69,
0x61, 0x6c, 0x5f, 0x72, 0x65, 0x66, 0x72, 0x65, 0x73, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08,
0x52, 0x10, 0x69, 0x73, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x52, 0x65, 0x66, 0x72, 0x65,
0x73, 0x68, 0x22, 0x7f, 0x0a, 0x19, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x4b, 0x65, 0x79, 0x73,
0x70, 0x61, 0x63, 0x65, 0x43, 0x65, 0x6c, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12,
0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28,
0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x63,
0x65, 0x6c, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x63, 0x65, 0x6c, 0x6c, 0x12,
0x14, 0x0a, 0x05, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05,
0x66, 0x6f, 0x72, 0x63, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x72, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69,
0x76, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x72, 0x65, 0x63, 0x75, 0x72, 0x73,
0x69, 0x76, 0x65, 0x22, 0x1c, 0x0a, 0x1a, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x4b, 0x65, 0x79,
0x73, 0x70, 0x61, 0x63, 0x65, 0x43, 0x65, 0x6c, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
0x65, 0x22, 0x9b, 0x01, 0x0a, 0x16, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x53, 0x68, 0x61, 0x72,
0x64, 0x43, 0x65, 0x6c, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08,
0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08,
0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x68, 0x61, 0x72,
0x64, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x68,
0x61, 0x72, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x63, 0x65, 0x6c, 0x6c, 0x18,
0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x63, 0x65, 0x6c, 0x6c, 0x12, 0x14, 0x0a, 0x05, 0x66,
0x6f, 0x72, 0x63, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x66, 0x6f, 0x72, 0x63,
0x65, 0x12, 0x1c, 0x0a, 0x09, 0x72, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x76, 0x65, 0x18, 0x05,
0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x72, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x76, 0x65, 0x22,
0x19, 0x0a, 0x17, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x43, 0x65,
0x6c, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x46, 0x0a, 0x15, 0x52, 0x65,
0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75,
0x65, 0x73, 0x74, 0x12, 0x2d, 0x0a, 0x06, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x18, 0x01, 0x20,
0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54,
0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x06, 0x74, 0x61, 0x62, 0x6c,
0x65, 0x74, 0x22, 0x7b, 0x0a, 0x16, 0x52, 0x65, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x54, 0x61,
0x62, 0x6c, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1a, 0x0a, 0x08,
0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08,
0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72,
0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x12, 0x2f,
0x0a, 0x07, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32,
0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65,
0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x07, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x22,
0x51, 0x0a, 0x15, 0x52, 0x75, 0x6e, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x43, 0x68, 0x65, 0x63,
0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x38, 0x0a, 0x0c, 0x74, 0x61, 0x62, 0x6c,
0x65, 0x74, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15,
0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74,
0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69,
0x61, 0x73, 0x22, 0x18, 0x0a, 0x16, 0x52, 0x75, 0x6e, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x43,
0x68, 0x65, 0x63, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xc8, 0x01, 0x0a,
0x1c, 0x53, 0x65, 0x74, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x53, 0x65, 0x72, 0x76,
0x65, 0x64, 0x46, 0x72, 0x6f, 0x6d, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a,
0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x35, 0x0a, 0x0b, 0x74, 0x61, 0x62,
0x6c, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x14,
0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74,
0x54, 0x79, 0x70, 0x65, 0x52, 0x0a, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65,
0x12, 0x14, 0x0a, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52,
0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65,
0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x12, 0x27,
0x0a, 0x0f, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63,
0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4b,
0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x22, 0x4f, 0x0a, 0x1d, 0x53, 0x65, 0x74, 0x4b, 0x65,
0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x53, 0x65, 0x72, 0x76, 0x65, 0x64, 0x46, 0x72, 0x6f, 0x6d,
0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2e, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73,
0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x74, 0x6f, 0x70,
0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x08,
0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x22, 0xae, 0x01, 0x0a, 0x1e, 0x53, 0x65, 0x74,
0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x67,
0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b,
0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b,
0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x6f, 0x6c, 0x75, 0x6d,
0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6f,
0x6c, 0x75, 0x6d, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x39, 0x0a, 0x0b, 0x63, 0x6f, 0x6c, 0x75,
0x6d, 0x6e, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x18, 0x2e,
0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63,
0x65, 0x49, 0x64, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0a, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x54,
0x79, 0x70, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x18, 0x04, 0x20, 0x01,
0x28, 0x08, 0x52, 0x05, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x22, 0x51, 0x0a, 0x1f, 0x53, 0x65, 0x74,
0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x67,
0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2e, 0x0a, 0x08,
0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12,
0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61,
0x63, 0x65, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x22, 0x72, 0x0a, 0x1f,
0x53, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x49, 0x73, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72,
0x79, 0x53, 0x65, 0x72, 0x76, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12,
0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28,
0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73,
0x68, 0x61, 0x72, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72,
0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x69, 0x73, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x6e, 0x67, 0x18,
0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x69, 0x73, 0x53, 0x65, 0x72, 0x76, 0x69, 0x6e, 0x67,
0x22, 0x49, 0x0a, 0x20, 0x53, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x49, 0x73, 0x50, 0x72,
0x69, 0x6d, 0x61, 0x72, 0x79, 0x53, 0x65, 0x72, 0x76, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x73, 0x70,
0x6f, 0x6e, 0x73, 0x65, 0x12, 0x25, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x01, 0x20,
0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53,
0x68, 0x61, 0x72, 0x64, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x22, 0x8e, 0x02, 0x0a, 0x1c,
0x53, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x43, 0x6f,
0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08,
0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08,
0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72,
0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x12, 0x35,
0x0a, 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20,
0x01, 0x28, 0x0e, 0x32, 0x14, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54,
0x61, 0x62, 0x6c, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0a, 0x74, 0x61, 0x62, 0x6c, 0x65,
0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x18, 0x04,
0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x64,
0x65, 0x6e, 0x69, 0x65, 0x64, 0x5f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x18, 0x05, 0x20, 0x03,
0x28, 0x09, 0x52, 0x0c, 0x64, 0x65, 0x6e, 0x69, 0x65, 0x64, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73,
0x12, 0x32, 0x0a, 0x15, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x71, 0x75, 0x65, 0x72,
0x79, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52,
0x13, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x65, 0x72,
0x76, 0x69, 0x63, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x18, 0x07,
0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x22, 0x46, 0x0a, 0x1d,
0x53, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x43, 0x6f,
0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x25, 0x0a,
0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x74,
0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x05, 0x73,
0x68, 0x61, 0x72, 0x64, 0x22, 0x6a, 0x0a, 0x12, 0x53, 0x65, 0x74, 0x57, 0x72, 0x69, 0x74, 0x61,
0x62, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x38, 0x0a, 0x0c, 0x74, 0x61,
0x62, 0x6c, 0x65, 0x74, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b,
0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c,
0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41,
0x6c, 0x69, 0x61, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x77, 0x72, 0x69, 0x74, 0x61, 0x62, 0x6c, 0x65,
0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x77, 0x72, 0x69, 0x74, 0x61, 0x62, 0x6c, 0x65,
0x22, 0x15, 0x0a, 0x13, 0x53, 0x65, 0x74, 0x57, 0x72, 0x69, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x52,
0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x54, 0x0a, 0x20, 0x53, 0x68, 0x61, 0x72, 0x64,
0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x73, 0x69, 0x74,
0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b,
0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b,
0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64,
0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x22, 0xaa, 0x03,
0x0a, 0x21, 0x53, 0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69,
0x6f, 0x6e, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f,
0x6e, 0x73, 0x65, 0x12, 0x78, 0x0a, 0x14, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69,
0x6f, 0x6e, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28,
0x0b, 0x32, 0x45, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x68,
0x61, 0x72, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f,
0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e,
0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x75,
0x73, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x13, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63,
0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x65, 0x73, 0x12, 0x5a, 0x0a,
0x0a, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x6d, 0x61, 0x70, 0x18, 0x02, 0x20, 0x03, 0x28,
0x0b, 0x32, 0x3b, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x68,
0x61, 0x72, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f,
0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e,
0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x4d, 0x61, 0x70, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x09,
0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x4d, 0x61, 0x70, 0x1a, 0x5f, 0x0a, 0x18, 0x52, 0x65, 0x70,
0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x65, 0x73,
0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01,
0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x2d, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65,
0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61,
0x74, 0x69, 0x6f, 0x6e, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52,
0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x4e, 0x0a, 0x0e, 0x54, 0x61,
0x62, 0x6c, 0x65, 0x74, 0x4d, 0x61, 0x70, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03,
0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x26,
0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e,
0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x52,
0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x7c, 0x0a, 0x12, 0x53, 0x6c,
0x65, 0x65, 0x70, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
0x12, 0x38, 0x0a, 0x0c, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73,
0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74,
0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0b, 0x74,
0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x12, 0x2c, 0x0a, 0x08, 0x64, 0x75,
0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x76,
0x74, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x08,
0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x15, 0x0a, 0x13, 0x53, 0x6c, 0x65, 0x65,
0x70, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
0x53, 0x0a, 0x17, 0x53, 0x74, 0x61, 0x72, 0x74, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74,
0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x38, 0x0a, 0x0c, 0x74, 0x61,
0x62, 0x6c, 0x65, 0x74, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b,
0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c,
0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41,
0x6c, 0x69, 0x61, 0x73, 0x22, 0x1a, 0x0a, 0x18, 0x53, 0x74, 0x61, 0x72, 0x74, 0x52, 0x65, 0x70,
0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
0x22, 0x52, 0x0a, 0x16, 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74,
0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x38, 0x0a, 0x0c, 0x74, 0x61,
0x62, 0x6c, 0x65, 0x74, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b,
0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c,
0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0b, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41,
0x6c, 0x69, 0x61, 0x73, 0x22, 0x19, 0x0a, 0x17, 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x70, 0x6c,
0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
0x52, 0x0a, 0x21, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61,
0x6c, 0x6c, 0x79, 0x52, 0x65, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x65, 0x64, 0x52, 0x65, 0x71,
0x75, 0x65, 0x73, 0x74, 0x12, 0x2d, 0x0a, 0x06, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x18, 0x01,
0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e,
0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x06, 0x74, 0x61, 0x62,
0x6c, 0x65, 0x74, 0x22, 0xc6, 0x01, 0x0a, 0x22, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x45, 0x78,
0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x52, 0x65, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74,
0x65, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65,
0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65,
0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18,
0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x12, 0x36, 0x0a, 0x0b,
0x6e, 0x65, 0x77, 0x5f, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28,
0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62,
0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0a, 0x6e, 0x65, 0x77, 0x50, 0x72, 0x69,
0x6d, 0x61, 0x72, 0x79, 0x12, 0x36, 0x0a, 0x0b, 0x6f, 0x6c, 0x64, 0x5f, 0x70, 0x72, 0x69, 0x6d,
0x61, 0x72, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x6f, 0x70, 0x6f,
0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x41, 0x6c, 0x69, 0x61, 0x73,
0x52, 0x0a, 0x6f, 0x6c, 0x64, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x22, 0x5c, 0x0a, 0x15,
0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x43, 0x65, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65,
0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20,
0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x2f, 0x0a, 0x09, 0x63, 0x65, 0x6c,
0x6c, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x74,
0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x6f,
0x52, 0x08, 0x63, 0x65, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0x5d, 0x0a, 0x16, 0x55, 0x70,
0x64, 0x61, 0x74, 0x65, 0x43, 0x65, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70,
0x6f, 0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01,
0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x2f, 0x0a, 0x09, 0x63, 0x65, 0x6c, 0x6c,
0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x74, 0x6f,
0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x52,
0x08, 0x63, 0x65, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0x64, 0x0a, 0x17, 0x55, 0x70, 0x64,
0x61, 0x74, 0x65, 0x43, 0x65, 0x6c, 0x6c, 0x73, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x65, 0x71,
0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01,
0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x35, 0x0a, 0x0b, 0x63, 0x65, 0x6c, 0x6c,
0x73, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e,
0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x73, 0x41, 0x6c,
0x69, 0x61, 0x73, 0x52, 0x0a, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x22,
0x65, 0x0a, 0x18, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x43, 0x65, 0x6c, 0x6c, 0x73, 0x41, 0x6c,
0x69, 0x61, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e,
0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12,
0x35, 0x0a, 0x0b, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, 0x02,
0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x6f, 0x70, 0x6f, 0x64, 0x61, 0x74, 0x61, 0x2e,
0x43, 0x65, 0x6c, 0x6c, 0x73, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x52, 0x0a, 0x63, 0x65, 0x6c, 0x6c,
0x73, 0x41, 0x6c, 0x69, 0x61, 0x73, 0x22, 0x34, 0x0a, 0x0f, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61,
0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x70, 0x69, 0x6e,
0x67, 0x5f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52,
0x0b, 0x70, 0x69, 0x6e, 0x67, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x73, 0x22, 0xfb, 0x01, 0x0a,
0x10, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
0x65, 0x12, 0x18, 0x0a, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03,
0x28, 0x09, 0x52, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x12, 0x62, 0x0a, 0x13, 0x72,
0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x5f, 0x62, 0x79, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61,
0x63, 0x65, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c,
0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73,
0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x42, 0x79, 0x4b,
0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x11, 0x72, 0x65,
0x73, 0x75, 0x6c, 0x74, 0x73, 0x42, 0x79, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x1a,
0x69, 0x0a, 0x16, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x42, 0x79, 0x4b, 0x65, 0x79, 0x73,
0x70, 0x61, 0x63, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79,
0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x39, 0x0a, 0x05, 0x76,
0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x76, 0x74, 0x63,
0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x4b,
0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52,
0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x58, 0x0a, 0x17, 0x56, 0x61,
0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65,
0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63,
0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63,
0x65, 0x12, 0x21, 0x0a, 0x0c, 0x70, 0x69, 0x6e, 0x67, 0x5f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74,
0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x70, 0x69, 0x6e, 0x67, 0x54, 0x61, 0x62,
0x6c, 0x65, 0x74, 0x73, 0x22, 0xfc, 0x01, 0x0a, 0x18, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
0x65, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
0x65, 0x12, 0x18, 0x0a, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03,
0x28, 0x09, 0x52, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x12, 0x61, 0x0a, 0x10, 0x72,
0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x5f, 0x62, 0x79, 0x5f, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18,
0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x37, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74,
0x61, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x70, 0x61,
0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x52, 0x65, 0x73, 0x75, 0x6c,
0x74, 0x73, 0x42, 0x79, 0x53, 0x68, 0x61, 0x72, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0e,
0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x42, 0x79, 0x53, 0x68, 0x61, 0x72, 0x64, 0x1a, 0x63,
0x0a, 0x13, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x42, 0x79, 0x53, 0x68, 0x61, 0x72, 0x64,
0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01,
0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x36, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65,
0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61,
0x74, 0x61, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x53, 0x68, 0x61, 0x72, 0x64,
0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a,
0x02, 0x38, 0x01, 0x22, 0x6b, 0x0a, 0x14, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x53,
0x68, 0x61, 0x72, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6b,
0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6b,
0x65, 0x79, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64,
0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x12, 0x21, 0x0a,
0x0c, 0x70, 0x69, 0x6e, 0x67, 0x5f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x73, 0x18, 0x03, 0x20,
0x01, 0x28, 0x08, 0x52, 0x0b, 0x70, 0x69, 0x6e, 0x67, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x74, 0x73,
0x22, 0x31, 0x0a, 0x15, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x53, 0x68, 0x61, 0x72,
0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x72, 0x65, 0x73,
0x75, 0x6c, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x07, 0x72, 0x65, 0x73, 0x75,
0x6c, 0x74, 0x73, 0x2a, 0x4a, 0x0a, 0x15, 0x4d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69,
0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x12, 0x0a, 0x0a, 0x06,
0x43, 0x55, 0x53, 0x54, 0x4f, 0x4d, 0x10, 0x00, 0x12, 0x0e, 0x0a, 0x0a, 0x4d, 0x4f, 0x56, 0x45,
0x54, 0x41, 0x42, 0x4c, 0x45, 0x53, 0x10, 0x01, 0x12, 0x15, 0x0a, 0x11, 0x43, 0x52, 0x45, 0x41,
0x54, 0x45, 0x4c, 0x4f, 0x4f, 0x4b, 0x55, 0x50, 0x49, 0x4e, 0x44, 0x45, 0x58, 0x10, 0x02, 0x42,
0x28, 0x5a, 0x26, 0x76, 0x69, 0x74, 0x65, 0x73, 0x73, 0x2e, 0x69, 0x6f, 0x2f, 0x76, 0x69, 0x74,
0x65, 0x73, 0x73, 0x2f, 0x67, 0x6f, 0x2f, 0x76, 0x74, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f,
0x76, 0x74, 0x63, 0x74, 0x6c, 0x64, 0x61, 0x74, 0x61, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x33,
}
var (
file_vtctldata_proto_rawDescOnce sync.Once
file_vtctldata_proto_rawDescData = file_vtctldata_proto_rawDesc
)
func file_vtctldata_proto_rawDescGZIP() []byte {
file_vtctldata_proto_rawDescOnce.Do(func() {
file_vtctldata_proto_rawDescData = protoimpl.X.CompressGZIP(file_vtctldata_proto_rawDescData)
})
return file_vtctldata_proto_rawDescData
}
var file_vtctldata_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
var file_vtctldata_proto_msgTypes = make([]protoimpl.MessageInfo, 139)
var file_vtctldata_proto_goTypes = []interface{}{
(MaterializationIntent)(0), // 0: vtctldata.MaterializationIntent
(*ExecuteVtctlCommandRequest)(nil), // 1: vtctldata.ExecuteVtctlCommandRequest
(*ExecuteVtctlCommandResponse)(nil), // 2: vtctldata.ExecuteVtctlCommandResponse
(*TableMaterializeSettings)(nil), // 3: vtctldata.TableMaterializeSettings
(*MaterializeSettings)(nil), // 4: vtctldata.MaterializeSettings
(*Keyspace)(nil), // 5: vtctldata.Keyspace
(*Shard)(nil), // 6: vtctldata.Shard
(*Workflow)(nil), // 7: vtctldata.Workflow
(*AddCellInfoRequest)(nil), // 8: vtctldata.AddCellInfoRequest
(*AddCellInfoResponse)(nil), // 9: vtctldata.AddCellInfoResponse
(*AddCellsAliasRequest)(nil), // 10: vtctldata.AddCellsAliasRequest
(*AddCellsAliasResponse)(nil), // 11: vtctldata.AddCellsAliasResponse
(*ApplyRoutingRulesRequest)(nil), // 12: vtctldata.ApplyRoutingRulesRequest
(*ApplyRoutingRulesResponse)(nil), // 13: vtctldata.ApplyRoutingRulesResponse
(*ApplyVSchemaRequest)(nil), // 14: vtctldata.ApplyVSchemaRequest
(*ApplyVSchemaResponse)(nil), // 15: vtctldata.ApplyVSchemaResponse
(*ChangeTabletTypeRequest)(nil), // 16: vtctldata.ChangeTabletTypeRequest
(*ChangeTabletTypeResponse)(nil), // 17: vtctldata.ChangeTabletTypeResponse
(*CreateKeyspaceRequest)(nil), // 18: vtctldata.CreateKeyspaceRequest
(*CreateKeyspaceResponse)(nil), // 19: vtctldata.CreateKeyspaceResponse
(*CreateShardRequest)(nil), // 20: vtctldata.CreateShardRequest
(*CreateShardResponse)(nil), // 21: vtctldata.CreateShardResponse
(*DeleteCellInfoRequest)(nil), // 22: vtctldata.DeleteCellInfoRequest
(*DeleteCellInfoResponse)(nil), // 23: vtctldata.DeleteCellInfoResponse
(*DeleteCellsAliasRequest)(nil), // 24: vtctldata.DeleteCellsAliasRequest
(*DeleteCellsAliasResponse)(nil), // 25: vtctldata.DeleteCellsAliasResponse
(*DeleteKeyspaceRequest)(nil), // 26: vtctldata.DeleteKeyspaceRequest
(*DeleteKeyspaceResponse)(nil), // 27: vtctldata.DeleteKeyspaceResponse
(*DeleteShardsRequest)(nil), // 28: vtctldata.DeleteShardsRequest
(*DeleteShardsResponse)(nil), // 29: vtctldata.DeleteShardsResponse
(*DeleteSrvVSchemaRequest)(nil), // 30: vtctldata.DeleteSrvVSchemaRequest
(*DeleteSrvVSchemaResponse)(nil), // 31: vtctldata.DeleteSrvVSchemaResponse
(*DeleteTabletsRequest)(nil), // 32: vtctldata.DeleteTabletsRequest
(*DeleteTabletsResponse)(nil), // 33: vtctldata.DeleteTabletsResponse
(*EmergencyReparentShardRequest)(nil), // 34: vtctldata.EmergencyReparentShardRequest
(*EmergencyReparentShardResponse)(nil), // 35: vtctldata.EmergencyReparentShardResponse
(*FindAllShardsInKeyspaceRequest)(nil), // 36: vtctldata.FindAllShardsInKeyspaceRequest
(*FindAllShardsInKeyspaceResponse)(nil), // 37: vtctldata.FindAllShardsInKeyspaceResponse
(*GetBackupsRequest)(nil), // 38: vtctldata.GetBackupsRequest
(*GetBackupsResponse)(nil), // 39: vtctldata.GetBackupsResponse
(*GetCellInfoRequest)(nil), // 40: vtctldata.GetCellInfoRequest
(*GetCellInfoResponse)(nil), // 41: vtctldata.GetCellInfoResponse
(*GetCellInfoNamesRequest)(nil), // 42: vtctldata.GetCellInfoNamesRequest
(*GetCellInfoNamesResponse)(nil), // 43: vtctldata.GetCellInfoNamesResponse
(*GetCellsAliasesRequest)(nil), // 44: vtctldata.GetCellsAliasesRequest
(*GetCellsAliasesResponse)(nil), // 45: vtctldata.GetCellsAliasesResponse
(*GetKeyspacesRequest)(nil), // 46: vtctldata.GetKeyspacesRequest
(*GetKeyspacesResponse)(nil), // 47: vtctldata.GetKeyspacesResponse
(*GetKeyspaceRequest)(nil), // 48: vtctldata.GetKeyspaceRequest
(*GetKeyspaceResponse)(nil), // 49: vtctldata.GetKeyspaceResponse
(*GetRoutingRulesRequest)(nil), // 50: vtctldata.GetRoutingRulesRequest
(*GetRoutingRulesResponse)(nil), // 51: vtctldata.GetRoutingRulesResponse
(*GetSchemaRequest)(nil), // 52: vtctldata.GetSchemaRequest
(*GetSchemaResponse)(nil), // 53: vtctldata.GetSchemaResponse
(*GetShardRequest)(nil), // 54: vtctldata.GetShardRequest
(*GetShardResponse)(nil), // 55: vtctldata.GetShardResponse
(*GetSrvKeyspaceNamesRequest)(nil), // 56: vtctldata.GetSrvKeyspaceNamesRequest
(*GetSrvKeyspaceNamesResponse)(nil), // 57: vtctldata.GetSrvKeyspaceNamesResponse
(*GetSrvKeyspacesRequest)(nil), // 58: vtctldata.GetSrvKeyspacesRequest
(*GetSrvKeyspacesResponse)(nil), // 59: vtctldata.GetSrvKeyspacesResponse
(*GetSrvVSchemaRequest)(nil), // 60: vtctldata.GetSrvVSchemaRequest
(*GetSrvVSchemaResponse)(nil), // 61: vtctldata.GetSrvVSchemaResponse
(*GetSrvVSchemasRequest)(nil), // 62: vtctldata.GetSrvVSchemasRequest
(*GetSrvVSchemasResponse)(nil), // 63: vtctldata.GetSrvVSchemasResponse
(*GetTabletRequest)(nil), // 64: vtctldata.GetTabletRequest
(*GetTabletResponse)(nil), // 65: vtctldata.GetTabletResponse
(*GetTabletsRequest)(nil), // 66: vtctldata.GetTabletsRequest
(*GetTabletsResponse)(nil), // 67: vtctldata.GetTabletsResponse
(*GetVSchemaRequest)(nil), // 68: vtctldata.GetVSchemaRequest
(*GetVSchemaResponse)(nil), // 69: vtctldata.GetVSchemaResponse
(*GetWorkflowsRequest)(nil), // 70: vtctldata.GetWorkflowsRequest
(*GetWorkflowsResponse)(nil), // 71: vtctldata.GetWorkflowsResponse
(*InitShardPrimaryRequest)(nil), // 72: vtctldata.InitShardPrimaryRequest
(*InitShardPrimaryResponse)(nil), // 73: vtctldata.InitShardPrimaryResponse
(*PingTabletRequest)(nil), // 74: vtctldata.PingTabletRequest
(*PingTabletResponse)(nil), // 75: vtctldata.PingTabletResponse
(*PlannedReparentShardRequest)(nil), // 76: vtctldata.PlannedReparentShardRequest
(*PlannedReparentShardResponse)(nil), // 77: vtctldata.PlannedReparentShardResponse
(*RebuildKeyspaceGraphRequest)(nil), // 78: vtctldata.RebuildKeyspaceGraphRequest
(*RebuildKeyspaceGraphResponse)(nil), // 79: vtctldata.RebuildKeyspaceGraphResponse
(*RebuildVSchemaGraphRequest)(nil), // 80: vtctldata.RebuildVSchemaGraphRequest
(*RebuildVSchemaGraphResponse)(nil), // 81: vtctldata.RebuildVSchemaGraphResponse
(*RefreshStateRequest)(nil), // 82: vtctldata.RefreshStateRequest
(*RefreshStateResponse)(nil), // 83: vtctldata.RefreshStateResponse
(*RefreshStateByShardRequest)(nil), // 84: vtctldata.RefreshStateByShardRequest
(*RefreshStateByShardResponse)(nil), // 85: vtctldata.RefreshStateByShardResponse
(*RemoveKeyspaceCellRequest)(nil), // 86: vtctldata.RemoveKeyspaceCellRequest
(*RemoveKeyspaceCellResponse)(nil), // 87: vtctldata.RemoveKeyspaceCellResponse
(*RemoveShardCellRequest)(nil), // 88: vtctldata.RemoveShardCellRequest
(*RemoveShardCellResponse)(nil), // 89: vtctldata.RemoveShardCellResponse
(*ReparentTabletRequest)(nil), // 90: vtctldata.ReparentTabletRequest
(*ReparentTabletResponse)(nil), // 91: vtctldata.ReparentTabletResponse
(*RunHealthCheckRequest)(nil), // 92: vtctldata.RunHealthCheckRequest
(*RunHealthCheckResponse)(nil), // 93: vtctldata.RunHealthCheckResponse
(*SetKeyspaceServedFromRequest)(nil), // 94: vtctldata.SetKeyspaceServedFromRequest
(*SetKeyspaceServedFromResponse)(nil), // 95: vtctldata.SetKeyspaceServedFromResponse
(*SetKeyspaceShardingInfoRequest)(nil), // 96: vtctldata.SetKeyspaceShardingInfoRequest
(*SetKeyspaceShardingInfoResponse)(nil), // 97: vtctldata.SetKeyspaceShardingInfoResponse
(*SetShardIsPrimaryServingRequest)(nil), // 98: vtctldata.SetShardIsPrimaryServingRequest
(*SetShardIsPrimaryServingResponse)(nil), // 99: vtctldata.SetShardIsPrimaryServingResponse
(*SetShardTabletControlRequest)(nil), // 100: vtctldata.SetShardTabletControlRequest
(*SetShardTabletControlResponse)(nil), // 101: vtctldata.SetShardTabletControlResponse
(*SetWritableRequest)(nil), // 102: vtctldata.SetWritableRequest
(*SetWritableResponse)(nil), // 103: vtctldata.SetWritableResponse
(*ShardReplicationPositionsRequest)(nil), // 104: vtctldata.ShardReplicationPositionsRequest
(*ShardReplicationPositionsResponse)(nil), // 105: vtctldata.ShardReplicationPositionsResponse
(*SleepTabletRequest)(nil), // 106: vtctldata.SleepTabletRequest
(*SleepTabletResponse)(nil), // 107: vtctldata.SleepTabletResponse
(*StartReplicationRequest)(nil), // 108: vtctldata.StartReplicationRequest
(*StartReplicationResponse)(nil), // 109: vtctldata.StartReplicationResponse
(*StopReplicationRequest)(nil), // 110: vtctldata.StopReplicationRequest
(*StopReplicationResponse)(nil), // 111: vtctldata.StopReplicationResponse
(*TabletExternallyReparentedRequest)(nil), // 112: vtctldata.TabletExternallyReparentedRequest
(*TabletExternallyReparentedResponse)(nil), // 113: vtctldata.TabletExternallyReparentedResponse
(*UpdateCellInfoRequest)(nil), // 114: vtctldata.UpdateCellInfoRequest
(*UpdateCellInfoResponse)(nil), // 115: vtctldata.UpdateCellInfoResponse
(*UpdateCellsAliasRequest)(nil), // 116: vtctldata.UpdateCellsAliasRequest
(*UpdateCellsAliasResponse)(nil), // 117: vtctldata.UpdateCellsAliasResponse
(*ValidateRequest)(nil), // 118: vtctldata.ValidateRequest
(*ValidateResponse)(nil), // 119: vtctldata.ValidateResponse
(*ValidateKeyspaceRequest)(nil), // 120: vtctldata.ValidateKeyspaceRequest
(*ValidateKeyspaceResponse)(nil), // 121: vtctldata.ValidateKeyspaceResponse
(*ValidateShardRequest)(nil), // 122: vtctldata.ValidateShardRequest
(*ValidateShardResponse)(nil), // 123: vtctldata.ValidateShardResponse
nil, // 124: vtctldata.Workflow.ShardStreamsEntry
(*Workflow_ReplicationLocation)(nil), // 125: vtctldata.Workflow.ReplicationLocation
(*Workflow_ShardStream)(nil), // 126: vtctldata.Workflow.ShardStream
(*Workflow_Stream)(nil), // 127: vtctldata.Workflow.Stream
(*Workflow_Stream_CopyState)(nil), // 128: vtctldata.Workflow.Stream.CopyState
(*Workflow_Stream_Log)(nil), // 129: vtctldata.Workflow.Stream.Log
nil, // 130: vtctldata.FindAllShardsInKeyspaceResponse.ShardsEntry
nil, // 131: vtctldata.GetCellsAliasesResponse.AliasesEntry
nil, // 132: vtctldata.GetSrvKeyspaceNamesResponse.NamesEntry
(*GetSrvKeyspaceNamesResponse_NameList)(nil), // 133: vtctldata.GetSrvKeyspaceNamesResponse.NameList
nil, // 134: vtctldata.GetSrvKeyspacesResponse.SrvKeyspacesEntry
nil, // 135: vtctldata.GetSrvVSchemasResponse.SrvVSchemasEntry
nil, // 136: vtctldata.ShardReplicationPositionsResponse.ReplicationStatusesEntry
nil, // 137: vtctldata.ShardReplicationPositionsResponse.TabletMapEntry
nil, // 138: vtctldata.ValidateResponse.ResultsByKeyspaceEntry
nil, // 139: vtctldata.ValidateKeyspaceResponse.ResultsByShardEntry
(*logutil.Event)(nil), // 140: logutil.Event
(*topodata.Keyspace)(nil), // 141: topodata.Keyspace
(*topodata.Shard)(nil), // 142: topodata.Shard
(*topodata.CellInfo)(nil), // 143: topodata.CellInfo
(*vschema.RoutingRules)(nil), // 144: vschema.RoutingRules
(*vschema.Keyspace)(nil), // 145: vschema.Keyspace
(*topodata.TabletAlias)(nil), // 146: topodata.TabletAlias
(topodata.TabletType)(0), // 147: topodata.TabletType
(*topodata.Tablet)(nil), // 148: topodata.Tablet
(topodata.KeyspaceIdType)(0), // 149: topodata.KeyspaceIdType
(*topodata.Keyspace_ServedFrom)(nil), // 150: topodata.Keyspace.ServedFrom
(topodata.KeyspaceType)(0), // 151: topodata.KeyspaceType
(*vttime.Time)(nil), // 152: vttime.Time
(*vttime.Duration)(nil), // 153: vttime.Duration
(*mysqlctl.BackupInfo)(nil), // 154: mysqlctl.BackupInfo
(*tabletmanagerdata.SchemaDefinition)(nil), // 155: tabletmanagerdata.SchemaDefinition
(*vschema.SrvVSchema)(nil), // 156: vschema.SrvVSchema
(*topodata.CellsAlias)(nil), // 157: topodata.CellsAlias
(*topodata.Shard_TabletControl)(nil), // 158: topodata.Shard.TabletControl
(*binlogdata.BinlogSource)(nil), // 159: binlogdata.BinlogSource
(*topodata.SrvKeyspace)(nil), // 160: topodata.SrvKeyspace
(*replicationdata.Status)(nil), // 161: replicationdata.Status
}
var file_vtctldata_proto_depIdxs = []int32{
140, // 0: vtctldata.ExecuteVtctlCommandResponse.event:type_name -> logutil.Event
3, // 1: vtctldata.MaterializeSettings.table_settings:type_name -> vtctldata.TableMaterializeSettings
0, // 2: vtctldata.MaterializeSettings.materialization_intent:type_name -> vtctldata.MaterializationIntent
141, // 3: vtctldata.Keyspace.keyspace:type_name -> topodata.Keyspace
142, // 4: vtctldata.Shard.shard:type_name -> topodata.Shard
125, // 5: vtctldata.Workflow.source:type_name -> vtctldata.Workflow.ReplicationLocation
125, // 6: vtctldata.Workflow.target:type_name -> vtctldata.Workflow.ReplicationLocation
124, // 7: vtctldata.Workflow.shard_streams:type_name -> vtctldata.Workflow.ShardStreamsEntry
143, // 8: vtctldata.AddCellInfoRequest.cell_info:type_name -> topodata.CellInfo
144, // 9: vtctldata.ApplyRoutingRulesRequest.routing_rules:type_name -> vschema.RoutingRules
145, // 10: vtctldata.ApplyVSchemaRequest.v_schema:type_name -> vschema.Keyspace
145, // 11: vtctldata.ApplyVSchemaResponse.v_schema:type_name -> vschema.Keyspace
146, // 12: vtctldata.ChangeTabletTypeRequest.tablet_alias:type_name -> topodata.TabletAlias
147, // 13: vtctldata.ChangeTabletTypeRequest.db_type:type_name -> topodata.TabletType
148, // 14: vtctldata.ChangeTabletTypeResponse.before_tablet:type_name -> topodata.Tablet
148, // 15: vtctldata.ChangeTabletTypeResponse.after_tablet:type_name -> topodata.Tablet
149, // 16: vtctldata.CreateKeyspaceRequest.sharding_column_type:type_name -> topodata.KeyspaceIdType
150, // 17: vtctldata.CreateKeyspaceRequest.served_froms:type_name -> topodata.Keyspace.ServedFrom
151, // 18: vtctldata.CreateKeyspaceRequest.type:type_name -> topodata.KeyspaceType
152, // 19: vtctldata.CreateKeyspaceRequest.snapshot_time:type_name -> vttime.Time
5, // 20: vtctldata.CreateKeyspaceResponse.keyspace:type_name -> vtctldata.Keyspace
5, // 21: vtctldata.CreateShardResponse.keyspace:type_name -> vtctldata.Keyspace
6, // 22: vtctldata.CreateShardResponse.shard:type_name -> vtctldata.Shard
6, // 23: vtctldata.DeleteShardsRequest.shards:type_name -> vtctldata.Shard
146, // 24: vtctldata.DeleteTabletsRequest.tablet_aliases:type_name -> topodata.TabletAlias
146, // 25: vtctldata.EmergencyReparentShardRequest.new_primary:type_name -> topodata.TabletAlias
146, // 26: vtctldata.EmergencyReparentShardRequest.ignore_replicas:type_name -> topodata.TabletAlias
153, // 27: vtctldata.EmergencyReparentShardRequest.wait_replicas_timeout:type_name -> vttime.Duration
146, // 28: vtctldata.EmergencyReparentShardResponse.promoted_primary:type_name -> topodata.TabletAlias
140, // 29: vtctldata.EmergencyReparentShardResponse.events:type_name -> logutil.Event
130, // 30: vtctldata.FindAllShardsInKeyspaceResponse.shards:type_name -> vtctldata.FindAllShardsInKeyspaceResponse.ShardsEntry
154, // 31: vtctldata.GetBackupsResponse.backups:type_name -> mysqlctl.BackupInfo
143, // 32: vtctldata.GetCellInfoResponse.cell_info:type_name -> topodata.CellInfo
131, // 33: vtctldata.GetCellsAliasesResponse.aliases:type_name -> vtctldata.GetCellsAliasesResponse.AliasesEntry
5, // 34: vtctldata.GetKeyspacesResponse.keyspaces:type_name -> vtctldata.Keyspace
5, // 35: vtctldata.GetKeyspaceResponse.keyspace:type_name -> vtctldata.Keyspace
144, // 36: vtctldata.GetRoutingRulesResponse.routing_rules:type_name -> vschema.RoutingRules
146, // 37: vtctldata.GetSchemaRequest.tablet_alias:type_name -> topodata.TabletAlias
155, // 38: vtctldata.GetSchemaResponse.schema:type_name -> tabletmanagerdata.SchemaDefinition
6, // 39: vtctldata.GetShardResponse.shard:type_name -> vtctldata.Shard
132, // 40: vtctldata.GetSrvKeyspaceNamesResponse.names:type_name -> vtctldata.GetSrvKeyspaceNamesResponse.NamesEntry
134, // 41: vtctldata.GetSrvKeyspacesResponse.srv_keyspaces:type_name -> vtctldata.GetSrvKeyspacesResponse.SrvKeyspacesEntry
156, // 42: vtctldata.GetSrvVSchemaResponse.srv_v_schema:type_name -> vschema.SrvVSchema
135, // 43: vtctldata.GetSrvVSchemasResponse.srv_v_schemas:type_name -> vtctldata.GetSrvVSchemasResponse.SrvVSchemasEntry
146, // 44: vtctldata.GetTabletRequest.tablet_alias:type_name -> topodata.TabletAlias
148, // 45: vtctldata.GetTabletResponse.tablet:type_name -> topodata.Tablet
146, // 46: vtctldata.GetTabletsRequest.tablet_aliases:type_name -> topodata.TabletAlias
148, // 47: vtctldata.GetTabletsResponse.tablets:type_name -> topodata.Tablet
145, // 48: vtctldata.GetVSchemaResponse.v_schema:type_name -> vschema.Keyspace
7, // 49: vtctldata.GetWorkflowsResponse.workflows:type_name -> vtctldata.Workflow
146, // 50: vtctldata.InitShardPrimaryRequest.primary_elect_tablet_alias:type_name -> topodata.TabletAlias
153, // 51: vtctldata.InitShardPrimaryRequest.wait_replicas_timeout:type_name -> vttime.Duration
140, // 52: vtctldata.InitShardPrimaryResponse.events:type_name -> logutil.Event
146, // 53: vtctldata.PingTabletRequest.tablet_alias:type_name -> topodata.TabletAlias
146, // 54: vtctldata.PlannedReparentShardRequest.new_primary:type_name -> topodata.TabletAlias
146, // 55: vtctldata.PlannedReparentShardRequest.avoid_primary:type_name -> topodata.TabletAlias
153, // 56: vtctldata.PlannedReparentShardRequest.wait_replicas_timeout:type_name -> vttime.Duration
146, // 57: vtctldata.PlannedReparentShardResponse.promoted_primary:type_name -> topodata.TabletAlias
140, // 58: vtctldata.PlannedReparentShardResponse.events:type_name -> logutil.Event
146, // 59: vtctldata.RefreshStateRequest.tablet_alias:type_name -> topodata.TabletAlias
146, // 60: vtctldata.ReparentTabletRequest.tablet:type_name -> topodata.TabletAlias
146, // 61: vtctldata.ReparentTabletResponse.primary:type_name -> topodata.TabletAlias
146, // 62: vtctldata.RunHealthCheckRequest.tablet_alias:type_name -> topodata.TabletAlias
147, // 63: vtctldata.SetKeyspaceServedFromRequest.tablet_type:type_name -> topodata.TabletType
141, // 64: vtctldata.SetKeyspaceServedFromResponse.keyspace:type_name -> topodata.Keyspace
149, // 65: vtctldata.SetKeyspaceShardingInfoRequest.column_type:type_name -> topodata.KeyspaceIdType
141, // 66: vtctldata.SetKeyspaceShardingInfoResponse.keyspace:type_name -> topodata.Keyspace
142, // 67: vtctldata.SetShardIsPrimaryServingResponse.shard:type_name -> topodata.Shard
147, // 68: vtctldata.SetShardTabletControlRequest.tablet_type:type_name -> topodata.TabletType
142, // 69: vtctldata.SetShardTabletControlResponse.shard:type_name -> topodata.Shard
146, // 70: vtctldata.SetWritableRequest.tablet_alias:type_name -> topodata.TabletAlias
136, // 71: vtctldata.ShardReplicationPositionsResponse.replication_statuses:type_name -> vtctldata.ShardReplicationPositionsResponse.ReplicationStatusesEntry
137, // 72: vtctldata.ShardReplicationPositionsResponse.tablet_map:type_name -> vtctldata.ShardReplicationPositionsResponse.TabletMapEntry
146, // 73: vtctldata.SleepTabletRequest.tablet_alias:type_name -> topodata.TabletAlias
153, // 74: vtctldata.SleepTabletRequest.duration:type_name -> vttime.Duration
146, // 75: vtctldata.StartReplicationRequest.tablet_alias:type_name -> topodata.TabletAlias
146, // 76: vtctldata.StopReplicationRequest.tablet_alias:type_name -> topodata.TabletAlias
146, // 77: vtctldata.TabletExternallyReparentedRequest.tablet:type_name -> topodata.TabletAlias
146, // 78: vtctldata.TabletExternallyReparentedResponse.new_primary:type_name -> topodata.TabletAlias
146, // 79: vtctldata.TabletExternallyReparentedResponse.old_primary:type_name -> topodata.TabletAlias
143, // 80: vtctldata.UpdateCellInfoRequest.cell_info:type_name -> topodata.CellInfo
143, // 81: vtctldata.UpdateCellInfoResponse.cell_info:type_name -> topodata.CellInfo
157, // 82: vtctldata.UpdateCellsAliasRequest.cells_alias:type_name -> topodata.CellsAlias
157, // 83: vtctldata.UpdateCellsAliasResponse.cells_alias:type_name -> topodata.CellsAlias
138, // 84: vtctldata.ValidateResponse.results_by_keyspace:type_name -> vtctldata.ValidateResponse.ResultsByKeyspaceEntry
139, // 85: vtctldata.ValidateKeyspaceResponse.results_by_shard:type_name -> vtctldata.ValidateKeyspaceResponse.ResultsByShardEntry
126, // 86: vtctldata.Workflow.ShardStreamsEntry.value:type_name -> vtctldata.Workflow.ShardStream
127, // 87: vtctldata.Workflow.ShardStream.streams:type_name -> vtctldata.Workflow.Stream
158, // 88: vtctldata.Workflow.ShardStream.tablet_controls:type_name -> topodata.Shard.TabletControl
146, // 89: vtctldata.Workflow.Stream.tablet:type_name -> topodata.TabletAlias
159, // 90: vtctldata.Workflow.Stream.binlog_source:type_name -> binlogdata.BinlogSource
152, // 91: vtctldata.Workflow.Stream.transaction_timestamp:type_name -> vttime.Time
152, // 92: vtctldata.Workflow.Stream.time_updated:type_name -> vttime.Time
128, // 93: vtctldata.Workflow.Stream.copy_states:type_name -> vtctldata.Workflow.Stream.CopyState
129, // 94: vtctldata.Workflow.Stream.logs:type_name -> vtctldata.Workflow.Stream.Log
152, // 95: vtctldata.Workflow.Stream.Log.created_at:type_name -> vttime.Time
152, // 96: vtctldata.Workflow.Stream.Log.updated_at:type_name -> vttime.Time
6, // 97: vtctldata.FindAllShardsInKeyspaceResponse.ShardsEntry.value:type_name -> vtctldata.Shard
157, // 98: vtctldata.GetCellsAliasesResponse.AliasesEntry.value:type_name -> topodata.CellsAlias
133, // 99: vtctldata.GetSrvKeyspaceNamesResponse.NamesEntry.value:type_name -> vtctldata.GetSrvKeyspaceNamesResponse.NameList
160, // 100: vtctldata.GetSrvKeyspacesResponse.SrvKeyspacesEntry.value:type_name -> topodata.SrvKeyspace
156, // 101: vtctldata.GetSrvVSchemasResponse.SrvVSchemasEntry.value:type_name -> vschema.SrvVSchema
161, // 102: vtctldata.ShardReplicationPositionsResponse.ReplicationStatusesEntry.value:type_name -> replicationdata.Status
148, // 103: vtctldata.ShardReplicationPositionsResponse.TabletMapEntry.value:type_name -> topodata.Tablet
121, // 104: vtctldata.ValidateResponse.ResultsByKeyspaceEntry.value:type_name -> vtctldata.ValidateKeyspaceResponse
123, // 105: vtctldata.ValidateKeyspaceResponse.ResultsByShardEntry.value:type_name -> vtctldata.ValidateShardResponse
106, // [106:106] is the sub-list for method output_type
106, // [106:106] is the sub-list for method input_type
106, // [106:106] is the sub-list for extension type_name
106, // [106:106] is the sub-list for extension extendee
0, // [0:106] is the sub-list for field type_name
}
func init() { file_vtctldata_proto_init() }
func file_vtctldata_proto_init() {
if File_vtctldata_proto != nil {
return
}
if !protoimpl.UnsafeEnabled {
file_vtctldata_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ExecuteVtctlCommandRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ExecuteVtctlCommandResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*TableMaterializeSettings); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*MaterializeSettings); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*Keyspace); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*Shard); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*Workflow); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*AddCellInfoRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*AddCellInfoResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*AddCellsAliasRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*AddCellsAliasResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ApplyRoutingRulesRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ApplyRoutingRulesResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ApplyVSchemaRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ApplyVSchemaResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ChangeTabletTypeRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ChangeTabletTypeResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*CreateKeyspaceRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*CreateKeyspaceResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*CreateShardRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*CreateShardResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*DeleteCellInfoRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*DeleteCellInfoResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*DeleteCellsAliasRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*DeleteCellsAliasResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*DeleteKeyspaceRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*DeleteKeyspaceResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*DeleteShardsRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*DeleteShardsResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*DeleteSrvVSchemaRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*DeleteSrvVSchemaResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*DeleteTabletsRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[32].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*DeleteTabletsResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[33].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*EmergencyReparentShardRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[34].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*EmergencyReparentShardResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[35].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*FindAllShardsInKeyspaceRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[36].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*FindAllShardsInKeyspaceResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[37].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetBackupsRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[38].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetBackupsResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[39].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetCellInfoRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[40].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetCellInfoResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[41].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetCellInfoNamesRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[42].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetCellInfoNamesResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[43].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetCellsAliasesRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[44].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetCellsAliasesResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[45].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetKeyspacesRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[46].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetKeyspacesResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[47].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetKeyspaceRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[48].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetKeyspaceResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[49].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetRoutingRulesRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[50].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetRoutingRulesResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[51].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetSchemaRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[52].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetSchemaResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[53].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetShardRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[54].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetShardResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[55].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetSrvKeyspaceNamesRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[56].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetSrvKeyspaceNamesResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[57].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetSrvKeyspacesRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[58].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetSrvKeyspacesResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[59].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetSrvVSchemaRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[60].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetSrvVSchemaResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[61].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetSrvVSchemasRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[62].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetSrvVSchemasResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[63].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetTabletRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[64].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetTabletResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[65].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetTabletsRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[66].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetTabletsResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[67].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetVSchemaRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[68].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetVSchemaResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[69].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetWorkflowsRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[70].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetWorkflowsResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[71].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*InitShardPrimaryRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[72].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*InitShardPrimaryResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[73].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*PingTabletRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[74].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*PingTabletResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[75].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*PlannedReparentShardRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[76].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*PlannedReparentShardResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[77].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*RebuildKeyspaceGraphRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[78].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*RebuildKeyspaceGraphResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[79].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*RebuildVSchemaGraphRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[80].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*RebuildVSchemaGraphResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[81].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*RefreshStateRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[82].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*RefreshStateResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[83].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*RefreshStateByShardRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[84].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*RefreshStateByShardResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[85].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*RemoveKeyspaceCellRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[86].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*RemoveKeyspaceCellResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[87].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*RemoveShardCellRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[88].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*RemoveShardCellResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[89].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ReparentTabletRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[90].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ReparentTabletResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[91].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*RunHealthCheckRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[92].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*RunHealthCheckResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[93].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SetKeyspaceServedFromRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[94].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SetKeyspaceServedFromResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[95].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SetKeyspaceShardingInfoRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[96].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SetKeyspaceShardingInfoResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[97].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SetShardIsPrimaryServingRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[98].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SetShardIsPrimaryServingResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[99].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SetShardTabletControlRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[100].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SetShardTabletControlResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[101].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SetWritableRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[102].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SetWritableResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[103].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ShardReplicationPositionsRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[104].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ShardReplicationPositionsResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[105].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SleepTabletRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[106].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SleepTabletResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[107].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*StartReplicationRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[108].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*StartReplicationResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[109].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*StopReplicationRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[110].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*StopReplicationResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[111].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*TabletExternallyReparentedRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[112].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*TabletExternallyReparentedResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[113].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*UpdateCellInfoRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[114].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*UpdateCellInfoResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[115].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*UpdateCellsAliasRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[116].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*UpdateCellsAliasResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[117].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ValidateRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[118].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ValidateResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[119].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ValidateKeyspaceRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[120].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ValidateKeyspaceResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[121].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ValidateShardRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[122].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ValidateShardResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[124].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*Workflow_ReplicationLocation); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[125].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*Workflow_ShardStream); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[126].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*Workflow_Stream); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[127].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*Workflow_Stream_CopyState); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[128].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*Workflow_Stream_Log); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vtctldata_proto_msgTypes[132].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetSrvKeyspaceNamesResponse_NameList); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: file_vtctldata_proto_rawDesc,
NumEnums: 1,
NumMessages: 139,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_vtctldata_proto_goTypes,
DependencyIndexes: file_vtctldata_proto_depIdxs,
EnumInfos: file_vtctldata_proto_enumTypes,
MessageInfos: file_vtctldata_proto_msgTypes,
}.Build()
File_vtctldata_proto = out.File
file_vtctldata_proto_rawDesc = nil
file_vtctldata_proto_goTypes = nil
file_vtctldata_proto_depIdxs = nil
}
|
<gh_stars>0
// Copyright 2017 Avaya Cloud Inc. All rights reserved.
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file.
package zang
import (
"fmt"
)
// ListIpAccessLists -
func (c *Client) ListIpAccessLists(params map[string]string) (resp *Response, err error) {
if cerr := c.Config.Validate(); cerr != nil {
return nil, cerr
}
resp, err = c.Request.Get(
fmt.Sprintf("%s/SIP/IpAccessControlLists", c.Config.AccountSid),
params,
)
return
}
// GetIpAccessList -
func (c *Client) GetIpAccessList(sid string) (resp *Response, err error) {
if cerr := c.Config.Validate(); cerr != nil {
return nil, cerr
}
if verr := ValidateSid(sid); err != nil {
return nil, verr
}
resp, err = c.Request.Get(
fmt.Sprintf("%s/SIP/IpAccessControlLists/%s", c.Config.AccountSid, sid),
map[string]string{},
)
return
}
// CreateIpAccessList -
func (c *Client) CreateIpAccessList(params map[string]string) (resp *Response, err error) {
if cerr := c.Config.Validate(); cerr != nil {
return nil, cerr
}
resp, err = c.Request.Create(
fmt.Sprintf("%s/SIP/IpAccessControlLists", c.Config.AccountSid),
params,
)
return
}
// UpdateIpAccessList -
func (c *Client) UpdateIpAccessList(sid string, params map[string]string) (resp *Response, err error) {
if cerr := c.Config.Validate(); cerr != nil {
return nil, cerr
}
if verr := ValidateSid(sid); err != nil {
return nil, verr
}
resp, err = c.Request.Update(
fmt.Sprintf("%s/SIP/IpAccessControlLists/%s", c.Config.AccountSid, sid),
params,
)
return
}
// DeleteIpAccessList -
func (c *Client) DeleteIpAccessList(sid string) (resp *Response, err error) {
if cerr := c.Config.Validate(); cerr != nil {
return nil, cerr
}
if verr := ValidateSid(sid); err != nil {
return nil, verr
}
resp, err = c.Request.Delete(
fmt.Sprintf("%s/SIP/IpAccessControlLists/%s", c.Config.AccountSid, sid),
map[string]string{},
)
return
}
// ListSipIpAddresses -
func (c *Client) ListSipIpAddresses(ipAccessListSid string, params map[string]string) (resp *Response, err error) {
if cerr := c.Config.Validate(); cerr != nil {
return nil, cerr
}
resp, err = c.Request.Get(
fmt.Sprintf("%s/SIP/IpAccessControlLists/%s/IpAddresses", c.Config.AccountSid, ipAccessListSid),
params,
)
return
}
// GetSipIpAddress -
func (c *Client) GetSipIpAddress(ipAccessListSid string, sid string) (resp *Response, err error) {
if cerr := c.Config.Validate(); cerr != nil {
return nil, cerr
}
if verr := ValidateSid(sid); err != nil {
return nil, verr
}
resp, err = c.Request.Get(
fmt.Sprintf("%s/SIP/IpAccessControlLists/%s/IpAddresses/%s", c.Config.AccountSid, ipAccessListSid, sid),
map[string]string{},
)
return
}
// CreateSipIpAddress -
func (c *Client) CreateSipIpAddress(ipAccessListSid string, params map[string]string) (resp *Response, err error) {
if cerr := c.Config.Validate(); cerr != nil {
return nil, cerr
}
resp, err = c.Request.Create(
fmt.Sprintf("%s/SIP/IpAccessControlLists/%s/IpAddresses", c.Config.AccountSid, ipAccessListSid),
params,
)
return
}
// UpdateSipIpAddresses -
func (c *Client) UpdateSipIpAddress(ipAccessListSid string, sid string, params map[string]string) (resp *Response, err error) {
if cerr := c.Config.Validate(); cerr != nil {
return nil, cerr
}
if verr := ValidateSid(sid); err != nil {
return nil, verr
}
resp, err = c.Request.Update(
fmt.Sprintf("%s/SIP/IpAccessControlLists/%s/IpAddresses/%s", c.Config.AccountSid, ipAccessListSid, sid),
params,
)
return
}
// DeleteSipIpAddress -
func (c *Client) DeleteSipIpAddress(ipAccessListSid string, sid string) (resp *Response, err error) {
if cerr := c.Config.Validate(); cerr != nil {
return nil, cerr
}
if verr := ValidateSid(sid); err != nil {
return nil, verr
}
resp, err = c.Request.Delete(
fmt.Sprintf("%s/SIP/IpAccessControlLists/%s/IpAddresses/%s", c.Config.AccountSid, ipAccessListSid, sid),
map[string]string{},
)
return
}
|
Image copyright Jon Hall NSPCC Image caption Of the 100 cases of 'honour' crime looked at, 49 involved mothers
Mothers are the "unseen force" behind so-called honour-based abuse, inflicting violence on their daughters, a study has found.
Research by Rachael Aplin, a criminologist from Leeds Beckett University, said this was often unrecognised by police.
Of the 100 "honour" crimes she studied, 49 involved mothers - but this was often not recorded in crime reports.
Cases included violence to daughters, sometimes to induce an abortion.
She said the focus on any action taken against perpetrators should be on both males and females.
Mrs Aplin, a senior lecturer in criminology at the university, is on a career break from her role as a police detective sergeant.
Image caption Rachael Aplin said police and social services needed to "reassess"
She said: "The level of involvement of mothers in these cases was a real surprise, as was the level to which this wasn't acknowledged in police reporting.
"As many victims are children, there is a risk that agencies place them back in their mothers' care, mistakenly believing that this will ensure their protection.
"Law enforcement and social services need to reassess their strategies for dealing with honour-based abuse, taking full account of the role of mothers, to ensure children and young women are not returned to, or remain in, dangerous situations."
'She would hit me with a rolling pin'
"Sadir", who was born in Bradford to Afghan parents, was taken into care after being abused by her mother who tried to force her into marriage.
Speaking to the BBC, she described her mother as the main perpetrator, saying she was regularly beaten as a child.
From the age of nine she was told she could not play out, but had to learn how to cook in order to be "marriage material".
Now 35, she said: "I would get physically battered if I didn't cook chapatis or if the chapatis weren't round enough.
"My mum would get the rolling pin out and physically chastise me with it. So she'd punish me and then when Dad came home he'd punish me also because I didn't listen to my mum.
"I felt numb, sore. I was in shock; I couldn't believe she would hit me with a rolling pin, but then after a while you got used to it and it was a normal experience getting hit.
"You wouldn't dare tell anyone you were getting physically chastised at home, you'd just keep it to yourself and go to school and come back."
At 13 years old, she came home to her own surprise engagement party after her mother had planned for her to marry her adult cousin in Afghanistan, whom she had never met.
"We never used to have guests round so I asked my mum whose party is was and she said 'it's an engagement party'. I said 'well, who's getting married?'. I got a bit excited and she said, 'it's your engagement party, I want you to go upstairs and get dressed'.
"I was presented with a photo of a man, my mum's nephew in Afghanistan. I was supposed to marry this guy. I'd never met him; he was an adult and I was 13, a child.
"From that day onwards I knew I was going to run away."
Image caption 'Honour' abuse is normally inflicted on women who are said to have "shamed" their community
"Honour" abuse is usually associated with women from Muslim, Sikh or Hindu backgrounds and happens when they are seen to have "shamed" their community. It can also affect men, with some charities saying male abuse is underreported.
In Mrs Aplin's research, the abuse perpetrated by mothers included hitting, kicking and slapping, assault with household objects, cutting off daughters' hair and deception in order to encourage a fleeing victim back home.
Other behaviours included threatening to kill the victim or throw them downstairs, bartering to sell them, false imprisonment, emotional blackmail, confiscation of passports, bank cards and mobile phones and emotional blackmail.
'Women as suspects'
Mrs Alpin said: "The instinctive reaction from the public and from police officers and social workers is that mothers protect and nurture and love their children. But actually we need to rethink that.
"Mothers are the key perpetrators in abuse against daughters, and this is mostly abuse pre-marriage. So it's not necessarily abuse against wives once they've been forced into marriage."
Jasvinder Sanghera founded the charity Karma Nirvana to support victims of "honour" abuse and forced marriage, which currently receives about 850 calls a month.
She said: "What they need to acknowledge is that when they are risk assessing or investigating cases they have also got to consider women as suspects, so that they are investigating them, they are holding them to account.
"They need to be recognising that the victims are not safe with these females." |
If you’ve ever wanted to fill your house with Star Wars furnishings, now you can, thanks to the Star Wars/Premium Home Collection from Japanese furniture manufacturer IDC Otsuka.
The 150-piece plus collection includes cushions, rugs, tableware, ukiyo-e woodblock prints, coat hangers, and even a variety of bobbly-headed Japanese kokeshi dolls.
The items will be available from the IDC Otsuka Furniture Shinjuku showroom from 14 November to mid-January next year. Located in a special ‘pop-up’ area of the showroom, there will be 51 types of fabric items, including curtains, tapestries and rugs, exclusive to the store.
There will also be 20 types of limited-edition cushions on sale for 3,240 yen (US$26.35) each.
One of the most coveted and expensive items available are the ukiyo-e woodblock prints, available in three designs for 54,000 yen ($439.36) each. Featuring Darth Vader, a scene from the Battle of Hoth and Queen Amidala with R2-D2, these Japanese-styled artworks come with individual serial numbers and are limited to only 200 prints each. Officially approved by Lucasfilm, these will be incredibly popular.
And if kooky everyday items are more your thing, there are coat hangers for 3,240 yen each.
▼ Tumblers from 2,376 yen.
▼ Four-piece plate sets for 2,160 yen.
▼ And these gorgeous Japanese kokeshi dolls, in five character designs, for 5,400 yen each.
With more than 150 items available, there’s much more exciting Star Wars-related homeware to discover at their Shinjuku showroom. Be sure to stop by and check them out—you’ll need something to go alongside your life-size, remote control R2-D2 fridge, after all…
Shop Information
IDC Otsuka Furniture Shinjuku Showroom/IDC大塚家具 新宿ショールーム
Address: Tokyo-to, Shinjuku-ku, Shinjuku 3-33-1
東京都新宿区新宿3-33-1
Open: 10:30 a.m. – 8:00 p.m.
Website
Source: Otakomu
Images: IDC Otsuka, Rakuten Ichiba/rcmdva |
package com.zw.platform.domain.redis;
import com.zw.platform.domain.basicinfo.form.DeviceGroupForm;
import com.zw.platform.domain.basicinfo.form.SimGroupForm;
import com.zw.platform.domain.basicinfo.form.VehicleGroupForm;
import lombok.Data;
import java.util.HashSet;
import java.util.Set;
/**
* 封装信息配置导入绑定的车、设备、simcard用来维护没有绑定的缓存
*/
@Data
public class RedisBindingBean {
private Set<VehicleGroupForm> vehicleGroupForms;
private Set<VehicleGroupForm> peopleGroupFprms;
private Set<VehicleGroupForm> thingGroupFprms;
private Set<DeviceGroupForm> deviceGroupForms;
private Set<SimGroupForm> simGroupForms;
public RedisBindingBean() {
vehicleGroupForms = new HashSet<>();
peopleGroupFprms = new HashSet<>();
thingGroupFprms = new HashSet<>();
deviceGroupForms = new HashSet<>();
simGroupForms = new HashSet<>();
}
public void addVehicleGroup(VehicleGroupForm form) {
vehicleGroupForms.add(form);
}
public void addPeopleGroup(VehicleGroupForm form) {
peopleGroupFprms.add(form);
}
public void addThingGroup(VehicleGroupForm form) {
thingGroupFprms.add(form);
}
public void addDeviceGroup(DeviceGroupForm form) {
deviceGroupForms.add(form);
}
public void addSimGroup(SimGroupForm form) {
simGroupForms.add(form);
}
}
|
Rethinking the literacy capabilities of pre-service primary teachers in testing times
This paper demonstrates how teacher accreditation requirements can be responsibly aligned with a scholarly impetus to incorporate digital literacies to prepare pre-service teachers to meet changing educational needs and practices. The assessment initiatives introduced in the newly constructed four year undergraduate Bachelor of Education program at one Australian university are described and analysed in light of the debates surrounding pre-service primary teachers' literacy capabilities. The findings and subsequent discussion have implications for all literacy teacher educators concerned about the impact of standardised assessment practices on the professional future of teachers. |
/* test padding and override value for specific view bound */
public void testPaddingOverrideValues() {
View view = DynamicView.createView(
context,
dummyJsonObj
.addProperty(new DynamicPropertyJsonBuilder().setName(NAME.PADDING).setType(TYPE.DIMEN).setValue(2).build())
.addProperty(new DynamicPropertyJsonBuilder().setName(NAME.PADDING_LEFT).setType(TYPE.DIMEN).setValue(4).build())
.addProperty(new DynamicPropertyJsonBuilder().setName(NAME.PADDING_TOP).setType(TYPE.DIMEN).setValue(6).build())
.addProperty(new DynamicPropertyJsonBuilder().setName(NAME.PADDING_RIGHT).setType(TYPE.DIMEN).setValue(8).build())
.addProperty(new DynamicPropertyJsonBuilder().setName(NAME.PADDING_BOTTOM).setType(TYPE.DIMEN).setValue(10).build())
.build());
assertEquals(view.getPaddingLeft(), 4);
assertEquals(view.getPaddingTop(), 6);
assertEquals(view.getPaddingRight(), 8);
assertEquals(view.getPaddingBottom(), 10);
} |
t=int(input())
for _ in range(t):
n,m,x,y=map(int, input().split(" "))
count=0
for i in range(n):
patt=input().split("*")
if y<2*x:
for i in range(len(patt)):
# if len(patt[i]) == 1:
# count+=x
# elif :
count+=(len(patt[i])//2)*y + (len(patt[i])%2)*x
else:
for i in range(len(patt)):
count+=len(patt[i])*x
print(count)
# .*..*....**.**...*
# .***.*.*..*..****.
# ..*..*..*..*..*..*
# if 1x2 is cheaper
# .*..*....**.**...*
# 1 2 2 2 1 2 1
# if 1x1 is cheaper
# .*..*....**.**...*
# 1 11 1111 1 111
|
def last_mcd_runs(self) -> torch.Tensor:
if not self.keep_runs:
raise ValueError(
"mcd_runs: You should set `keep_runs=True` to properly use this method"
)
return self._mcd_runs |
<filename>Example/NCRAutocompleteSearchField.h
//
// NCAutocompleteTextView.h
// Example
//
// Created by <NAME> on 9/28/14.
// Copyright (c) 2014 Null Creature. All rights reserved.
//
#import <Cocoa/Cocoa.h>
@protocol NCRAutocompleteTableViewDelegate <NSObject>
@optional
- (NSImage *)textField:(NSTextField *)textField imageForCompletion:(NSString *)word;
- (NSArray *)textField:(NSTextField *)textField completions:(NSArray *)words forPartialWordRange:(NSRange)charRange indexOfSelectedItem:(NSInteger *)index;
@end
@interface NCRAutocompleteSearchField : NSSearchField <NSTableViewDataSource, NSTableViewDelegate, NSTextFieldDelegate, NSControlTextEditingDelegate>
@property(nonatomic, weak) id<NCRAutocompleteTableViewDelegate> autocompleteDelegate;
@end
|
/** updates this level, causing everything inside it to update */
public void update() {
final long dMS = System.currentTimeMillis() - prevFrameMS;
if (aLevelExists) {
LinkedList<Entity2D> toRemove = new LinkedList<Entity2D>();
if (entities.size() < 600)
addEntity(b.clone().setVelocityWithAngle(Math.random() * 300, Math.random() * 0.01 + 0.005));
for (Entity2D e : entities) {
TestLogger.logEntityPositionData(e);
e.updatePosition(dMS, entities);
if (e instanceof Player) {
} else {
if (!isRectangleInWindow(e.getHitbox(), 40))
toRemove.add(e);
}
if (e instanceof Bullet) {
if (e.overlaps(player)) {
player.getHealth().add(-((Bullet) e).getDamage());
toRemove.add(e);
}
}
}
for (Entity2D e : toRemove)
removeEntity(e);
}
prevFrameMS = System.currentTimeMillis();
} |
Potato leafroll virus: a classic pathogen shows some new tricks.
UNLABELLED
SUMMARY Taxonomy: PLRV is the type species of the genus Polerovirus, in the family Luteoviridae. Isolates are known from most continents, presumably all spread in potato material derived from the Andean region of South America. Physical properties: PLRV particles are isometric and c. 25 nm in diameter. They contain one major (c. 23 kDa) and one minor (c. 80 kDa) protein. The genome is a single 5.8 kb positive sense RNA that has neither a 5'-cap nor 3' poly(A) but carries a VPg.
HOST RANGE
PLRV has a limited host range; about 20 largely solanaceous species have been infected experimentally. PLRV is a common pathogen of potato, and closely related isolates are occasionally found in tomato, but no other crops are affected.
SYMPTOMS
Infection, especially from infected seed potato stocks, causes leafrolling and stunting, the extent depending on the potato cultivar. Biological properties: The biology of PLRV is that of a classic luteovirus. Its isometric particles are persistently transmitted by aphids in a non-propagative manner, it multiplies largely in phloem tissue and disease symptoms reflect this localization. A decade or so of molecular study has revealed the many features of PLRV that are characteristic of its family. Key attractions: In recent years some interesting features of PLRV have emerged that are the focus of further investigation. These are, its phloem confinement, its movement in infected plants, its ability to suppress gene silencing and new ideas about the structure of its particles. This review describes the background to PLRV and points towards these new developments. |
// prepareTLS will look in the os environment for a certfile and a keyfile
// both values will be trimmed for trailing or leading spaces and the files will be
// checked for existence and accessibility. If all is good both file names will be returned and
// the boolean value useTLS will return true
func prepareTLS() (certFile string, keyFile string, useTLS bool) {
certFile = strings.Trim(os.Getenv("TLS_CERTFILE"), " ")
if certFile == "" {
log.Debug("TLS Certfile was not set")
return "", "", false
}
if _, err := os.OpenFile(certFile, os.O_RDONLY, 0600); os.IsNotExist(err) || os.IsPermission(err) {
log.Warnf("TLS Certfile was set to %s, but cannot be accessed: %s", certFile, err)
return "", "", false
}
keyFile = strings.Trim(os.Getenv("TLS_KEYFILE"), " ")
if keyFile == "" {
log.Debug("TLS Keyfile was not set")
return "", "", false
}
if _, err := os.OpenFile(keyFile, os.O_RDONLY, 0600); os.IsNotExist(err) || os.IsPermission(err) {
log.Warnf("TLS Keyfile was set to %s, but cannot be accessed: %s", keyFile, err)
return "", "", false
}
return certFile, keyFile, true
} |
/*
* Send an empty message
* Empty message is used to extend credits to peer to for keep live
* while there is no upper layer payload to send at the time
*/
static int smbd_post_send_empty(struct smbd_connection *info)
{
info->count_send_empty++;
return smbd_post_send_sgl(info, NULL, 0, 0);
} |
#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <vector>
#include <string>
#include <sstream>
#include <map>
#include <ctime>
#include <cmath>
#include <cassert>
#include <numeric>
#include <algorithm>
using namespace std;
#define N 105
#define M 5200
#define ll long long
#define inf 0x7fffffff
#define lson (id<<1)
#define rson (id<<1|1)
#define eps 1e-6
#define pii pair<int,int>
#define pdd pair<double,int>
#define MP(i,j) make_pair(i,j)
#define It map<int,int>::iterator
#define X first
#define Y second
int n, m, dp[N << 1];
struct Node {
int t, w;
void read() {
scanf("%d%d", &t, &w);
}
friend bool operator<(const Node &a, const Node &b) {
if (a.w == b.w)
return a.t < b.t;
else
return a.w > b.w;
}
} node[N];
int main() {
#ifndef ONLINE_JUDGE
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
#endif
// int n, m, k;
// int cas, pcas = 1;
// scanf("%d", &cas);
while (scanf("%d", &n) != EOF) {
int wsum = 0, tsum = 0, ans = 0x3f3f3f3f;
for (int i = 1; i <= n; i++) {
node[i].read();
tsum += node[i].t;
wsum += node[i].w;
}
//sort(node + 1, node + 1 + n);
for (int i = 1; i <= tsum; i++)
dp[i] = -11;
for (int i = 1; i <= n; i++) {
for (int j = tsum; j >= node[i].t; j--)
dp[j] = max(dp[j], dp[j - node[i].t] + node[i].w);
}
for (int j = 0; j <= tsum; j++) {
if (j >= wsum - dp[j]) {
printf("%d\n", j);
break;
}
}
}
return 0;
} |
/**
* \brief read the status of spi flash
* \return current status of spi flash
*/
uint32_t flash_read_status(void)
{
uint8_t local_buf[2];
DEV_SPI_TRANSFER cmd_xfer;
local_buf[0] = RDSR;
DEV_SPI_XFER_SET_TXBUF(&cmd_xfer, local_buf, 0, 1);
DEV_SPI_XFER_SET_RXBUF(&cmd_xfer, local_buf, 1, 1);
DEV_SPI_XFER_SET_NEXT(&cmd_xfer, NULL);
if (spi_send_cmd(&cmd_xfer) == 0)
{
return (uint32_t)local_buf[0];
}
else
{
return SPI_FLASH_NOT_VALID;
}
} |
<reponame>rafalp/misago-client
import React from "react"
export interface ButtonProps {
block?: boolean
className?: string | null
disabled?: boolean
elementRef?: React.MutableRefObject<HTMLButtonElement | null>
icon?: string
image?: React.ReactNode
loading?: boolean
responsive?: boolean
small?: boolean
text?: React.ReactNode
outline?: boolean
onClick?: (event: React.MouseEvent<HTMLButtonElement, MouseEvent>) => void
}
|
def remove_tags(self, tags, auth, save=True):
if not tags:
raise InvalidTagError
for tag in tags:
tag_obj = Tag.objects.get(name=tag)
self.tags.remove(tag_obj)
params = self.log_params
params['tag'] = tag
self.add_log(
action=self.log_class.TAG_REMOVED,
params=params,
auth=auth,
save=False,
)
if save:
self.save()
return True |
/**
* Created by TwoFlyLiu on 2019/8/12.
*/
public class BookListServiceImpl implements BookListService {
@Override
public List<BookList> find(String name, String author) {
return DataSupport.where("bookname=? and bookauthor=?", name, author).find(BookList.class);
}
} |
#include <iostream>
#include <vector>
#include <map>
#include <string>
using namespace std;
struct link_dat{
link_dat(){}
link_dat(int l, int u, int r, int d, const string &p)
:l(l), u(u), r(r), d(d), p(p) {}
bool in(int x, int y){
return (x>=l && x<=r && y>=u && y<=d);
}
int l, u, r, d;
string p;
};
int main()
{
for (int n; cin>>n, !(n==0); ){
int w, h; cin>>w>>h;
map<string, vector<link_dat> > page;
string home;
for (int i=0; i<n; i++){
string name; cin>>name;
int m; cin>>m;
if (i==0) home=name;
vector<link_dat> links;
for (int j=0; j<m; j++){
int l, u, r, d; cin>>l>>u>>r>>d;
string p; cin>>p;
links.push_back(link_dat(l, u, r, d, p));
}
page[name]=links;
}
vector<string> hist;
hist.push_back(home);
int cursor=0;
int m; cin>>m;
for (int i=0; i<m; i++){
/*
for (int j=0; j<hist.size(); j++){
if (j==cursor) cout<<"* "; else cout<<" ";
cout<<hist[j]<<endl;
}
cout<<"====="<<endl;
*/
string cmd; cin>>cmd;
if (cmd=="show"){
cout<<hist[cursor]<<endl;
}
else if (cmd=="forward"){
cursor++;
cursor=min(cursor, (int)(hist.size()-1));
}
else if (cmd=="back"){
cursor--;
cursor=max(0, cursor);
}
else if (cmd=="click"){
int x, y; cin>>x>>y;
vector<link_dat> &links=page[hist[cursor]];
for (int i=0; i<links.size(); i++){
if (links[i].in(x, y)){
hist.resize(cursor+1);
hist.push_back(links[i].p);
cursor++;
break;
}
}
}
}
}
return 0;
} |
<reponame>quantnetwork/overledger-sdk-javascript
/**
* The list of transaction sub-type options for hyperledger_fabric
* (to be expanded in the future)
* /
/**
* @memberof module:overledger-dlt-hyperledger_fabric
*/
export enum TransactionHyperledgerFabricSubTypeOptions {
SMART_CONTRACT_DEPLOY = 'SMART_CONTRACT_DEPLOY',
SMART_CONTRACT_INVOCATION = 'SMART_CONTRACT_INVOCATION',
}
export default TransactionHyperledgerFabricSubTypeOptions;
|
Homicide: Insidiousness; Withdrawal from Attempt
The defendant had been convicted under juvenile law of murder in the first degree (Mord) on three counts and three counts of causing bodily harm by using dangerous means (gefährliche Körperverletzung) together with a road traffic offence. The defendant had been to a party at his football club and had apparently been so drunk or tired that he fell asleep at the table. While he was asleep, somebody cut off a tuft of his hair. When he woke up he worked himself into a rage about this practical joke and left the party at around 1.15 am. To cool his temper he took the family car and drove off. At around 3.30 am he got on to the motorway and intentionally took the wrong slip road so that he was driving in the opposite direction to that of the motorway lane he was using. At first he drove on the shoulder without turning on the lights, although he realised that there was a car coming towards him at a distance of about 500 m. At some stage he moved from the shoulder to the right lane of the main road, still without lights. His intention was to commit suicide by crashing into the oncoming car, and he was aware that this might cause the death of or grievous bodily harm to the driver and passengers in the other car. He knew that the other driver had no chance of spotting his car because he had not switched on the lights, and would thus have no chance of avoiding a collision. At a point when a collision could objectively no longer have been avoided even by an emergency braking, the defendant—as the trial court could not exclude on the evidence—gave up his suicidal intent and switched on his lights to alert the other driver to his presence. The driver unsuccessfully tried to swerve to the left and the two cars crashed when the speed of the accused’s car was 117 kph, but due to the swerve only the respective right-hand front ends made contact. There were six people in the other car, three of whom were killed; the other three were seriously injured. The defendant was given a juvenile sentence of four years and was disqualified from driving for a minimum period of two years. The defendant and the prosecution appealed. The prosecution applied to have a conviction for three cases of attempted murder (of the three injured passengers) added and for the sentence to be increased. HELD, DISMISSING BOTH APPEALS, the trial court had correctly convicted and sentenced the defendant and that he had voluntarily withdrawn from the attempted murder of the three other passengers. As a preliminary matter, the BGH found that this was no case of diminished or excluded responsibility, which had been pleaded by the defendant. |
// Workaround for: https://github.com/bazelbuild/rules_nodejs/issues/1265
/// <reference types="arcgis-js-api" />
import { Injectable } from '@angular/core';
import { SbbEsriTypesService } from '../esri-types/esri-types.service';
import { SbbMarkerSymbolFactory } from './marker-symbol-factory/marker-symbol.factory';
@Injectable({
providedIn: 'root',
})
export class SbbGraphicService {
private _markerSymbolFactory: SbbMarkerSymbolFactory;
constructor(private _esri: SbbEsriTypesService) {
this._markerSymbolFactory = new SbbMarkerSymbolFactory(this._esri);
}
/** Adds a new point graphic at given loation to the map/scene. */
addNewGraphicToMap(point: __esri.Point, mapView: __esri.MapView | __esri.SceneView) {
const markerGraphic = this._createPointGraphic(point);
mapView.graphics.removeAll();
mapView.graphics.add(markerGraphic);
}
/** @docs-private */
private _createPointGraphic(geometryPoint: __esri.Point): __esri.Graphic {
const point = this._createGeometryPoint(geometryPoint);
const markerSymbol = this._markerSymbolFactory.createCircleSymbol();
const graphicProperties: __esri.GraphicProperties = {
geometry: point,
symbol: markerSymbol,
};
return new this._esri.Graphic(graphicProperties);
}
/** @docs-private */
private _createGeometryPoint(geometry: any): __esri.Point {
const pointProperties: __esri.PointProperties = {
x: geometry.x,
y: geometry.y,
spatialReference: geometry.spatialReference,
};
return new this._esri.Point(pointProperties);
}
}
|
<filename>main.go<gh_stars>1-10
package main
import (
"encoding/json"
"fmt"
"io/ioutil"
"log"
"net/http"
"net/url"
"os"
"runtime"
"strconv"
"strings"
"sync"
"github.com/PuerkitoBio/goquery"
"github.com/gocarina/gocsv"
)
type (
Tender struct {
Title string `json:"title" csv:"title"`
Category string `json:"category" csv:"category"`
Ministry string `json:"ministry" csv:"ministry"`
Company string `json:"company" csv:"company"`
Value int64 `json:"value" csv:"value"`
Reason string `json:"reason" csv:"reason"`
}
)
const target = "http://myprocurement.treasury.gov.my/templates/theme427/rttender.php"
// hardcoded page number
const pageNum = 15
func main() {
// bootstrapping
runtime.GOMAXPROCS(runtime.NumCPU())
os.MkdirAll("downloads", 0755)
downloadState := make(chan struct{}, 1)
processState := make(chan struct{}, 1)
jobChans := make([]chan error, pageNum)
docsChan := make(chan int) // variable length, execution state not guaranteed
var downloaderWg sync.WaitGroup
downloaderWg.Add(15)
for i := 0; i < pageNum; i++ {
workerChan := make(chan error, 1)
go downloadHTML(i+1, workerChan, docsChan)
jobChans[i] = workerChan
}
go func() {
for _, errChan := range jobChans {
if err := <-errChan; err != nil {
fmt.Println(err)
}
downloaderWg.Done()
}
downloaderWg.Wait()
downloadState <- struct{}{}
}()
go processDocument(docsChan, processState)
var wg sync.WaitGroup
wg.Add(2)
go func() {
for {
select {
case <-downloadState:
fmt.Println("just downloaded everything, still processing...")
wg.Done()
close(docsChan)
case <-processState:
fmt.Println("done with processing!")
wg.Done()
}
}
}()
wg.Wait()
fmt.Println("done!")
}
func processDocument(doc chan int, processState chan struct{}) {
tenders := make([]*Tender, 0)
for {
d, more := <-doc
if more {
info, err := extractData(d)
if err != nil {
fmt.Println(err)
} else {
tenders = append(tenders, info...)
}
} else {
break
}
}
dump, err := json.Marshal(tenders)
if err != nil {
fmt.Println(err)
}
if err := ioutil.WriteFile("results.json", dump, 0644); err != nil {
fmt.Println(err)
}
csvDump, err := gocsv.MarshalBytes(tenders)
if err != nil {
fmt.Println(err)
}
if err := ioutil.WriteFile("results.csv", csvDump, 0644); err != nil {
fmt.Println(err)
}
processState <- struct{}{}
}
func extractData(docNum int) ([]*Tender, error) {
filepath := fmt.Sprintf("downloads/%d.html", docNum)
reader, err := os.Open(filepath)
if err != nil {
fmt.Printf("error opening file, %v", err)
return nil, err
}
soup, err := goquery.NewDocumentFromReader(reader)
if err != nil {
fmt.Printf("error parsing file, %v", err)
return nil, err
}
tenders := make([]*Tender, 0)
soup.Find("table tbody tr:not(:first-child)").Each(func(i int, cols *goquery.Selection) {
tender := &Tender{}
cols.Find("td:not(:first-child)").Each(func(i int, content *goquery.Selection) {
td := content.Text()
td = strings.TrimSpace(td)
td = strings.Replace(td, "\t", "", -1)
switch i {
case 0:
tender.Title = td
case 1:
tender.Category = td
case 2:
tender.Ministry = td
case 3:
tender.Company = td
case 4:
stringVal := strings.Replace(td, ",", "", -1)
// forgive my cheap hack
val, err := strconv.ParseInt(strings.Split(stringVal, ".")[0], 10, 64)
if err != nil {
log.Println(err)
}
tender.Value = val
case 5:
tender.Reason = td
}
})
tenders = append(tenders, tender)
})
return tenders, nil
}
func downloadHTML(pageNum int, workerChan chan error, docsChan chan int) {
client := &http.Client{}
params := url.Values{}
params.Set("page", fmt.Sprintf("%d", pageNum))
mark := fmt.Sprintf("%s?%s", target, params.Encode())
req, err := http.NewRequest("GET", mark, nil)
if err != nil {
// no retry, thanks
workerChan <- err
return
}
resp, err := client.Do(req)
if err != nil {
workerChan <- err
return
}
defer resp.Body.Close()
// has to read them first
// consume more memory, should copy to file directly
// but good for parsing work, TODO
content, err := ioutil.ReadAll(resp.Body)
if err != nil {
workerChan <- err
return
}
filename := fmt.Sprintf("downloads/%d.html", pageNum)
// this is so going to block
if err := ioutil.WriteFile(filename, content, 0644); err != nil {
workerChan <- err
return
}
// finished safely
workerChan <- nil
docsChan <- int(pageNum)
}
|
The syntax and pragmatics of embedded yes/no questions
The paper investigates the distribution of English if and whether as complementizers for polar questions in extensional contexts, and specifically the restriction of if-questions to negative contexts. I will criticize the recent analysis by Adger and Quer (2001) and suggest that markedness of embedded ifquestions in certain contexts arises through the conspiracy of several factors. I follow Bolinger (1979) in assuming that the question “if S” presupposes an (ir)relevance asymmetry between the proposition denoted by S and its negation. I argue that this leads to competition between embedded if-questions and that-clauses in the relevant constellations, which in turn excludes the if-question as the less optimal variant. 1 Embedded questions In English, like in many other languages, questions can occur as subordinate clauses under a matrix verb. The matrix verb can be one of questioning, doubting or wondering, like in example (1). The embedded clause here denotes a question and reports that the subject poses or could pose the question, mentally or explicitly, to himself or to others. (1) Susan wondered/asked/did not know who was the murderer. Susan wondered/asked/did not know whether Jones was the murderer. This kind of example, also called extensional question embedding, contrasts semantically with examples where the subject holds a certain mental attitude towards the correct answers of the embedded question, like in (2): (2) Elsie knew/told me/discovered who took the book. Elsie knew/told/disclosed whether Jones took the book. These predicates have also been called intensional question embeddings. Finer classifications of question embedding verbs have been proposed in the literature (Ginzburg 1996, Lahiri 2002 Ginzburg and Sag 2000), starting from seminal work by Karttunen (1978). The present paper is focused on embedded yes/no questions in intensional contexts, and more specifically on the distribution of the complementizers if and whether in such embeddings. I will argue that these complementizers carry different presuppositions and that intensional question embeddings compete with embedded that clauses. It will be shown that the distribution of if and whether in positive and negated question embedding contexts can be derived from pragmatic factors. This counters a recent proposal by Adger and Quer (2001) who offer a feature-based analyses of the |
def verify_password(password, passlib_hash):
password_matches = pbkdf2_sha256.verify(password, passlib_hash)
return password_matches |
def kill(self, timeout=TIMEOUT):
super(Agent, self).kill()
if self.proc is None:
return
try:
def no_slaves(data):
return len(data["slaves"]) == 0
http.get_json(self.flags["master"], "slaves", no_slaves, timeout)
except Exception as exception:
raise CLIException("Could not get '/slaves' endpoint as"
" JSON with 0 agents in it: {error}"
.format(error=exception)) |
<reponame>JoshMerlino/octoclient
import React, { Dispatch, SetStateAction, useEffect, useState } from "react";
import api from "../api";
export default function useAPI<T>(endpoint: string, args?: RequestInit): [ T | null | false, () => void, Dispatch<SetStateAction<T | null | false>> ] {
// Initialize state
const [ state, setState ] = useState<T | null | false>(null);
// Function to refresh the current state
function refresh() {
api(endpoint, args)
.then(response => response.json())
.then(response => {
if ("error" in response) return setState(false);
if (response.name === null) return setState(false);
setState(<T>response);
});
}
// Refresh the state on mount so that it exists
useEffect(refresh, []);
// Return state and controls
return [ state, refresh, setState ];
}
|
A rendering of Sky One from BSB's press materials BSB The Burj Khalifa, currently the world's tallest building, took five years to construct.
But Broad Sustainable Building, a Chinese construction company, says it will build the world's new tallest building—the so-called Sky City in Changsha, the provincial capital of Hunan Province—in just 90 days.
If all goes as planned, the building will stand 838 meters, 10 meters higher than the Burj.
If anyone can do it, it's BSB. The company was behind a three-story building that went up in nine days and a 30-story hotel constructed in just 15 days.
According to CNNGo, the 220-story Sky City will cost around $628 million to construct; in comparison the Burj cost an estimated $1.5 billion.
The building, which is slated for completion in January 2013, will be mixed use, with luxury apartments, low income housing, and space for businesses and retail, according to the company. It will also be earthquake-resistant and have 31 high-speed elevators to take visitors to the upper-level observation decks, the company said.
BSB plans to do the work at light-speed by using a proprietary prefabrication technique.
The company reportedly received approval from the local government last week, but is still waiting for a green light from the central government, according to Inhabitat. But if and when that's all squared away, expect Sky City to rise in almost no time at all.
Still skeptical? Check out this ridiculous time-lapse video of BSB's 30-story hotel, which went up in just 15 days last year. |
package com.journaldev.mongodb.dao;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.bson.types.ObjectId;
import org.omg.PortableInterceptor.USER_EXCEPTION;
import com.journaldev.mongodb.converter.UserConverter;
import com.journaldev.mongodb.model.User;
import com.mongodb.BasicDBObjectBuilder;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.DBObject;
import com.mongodb.MongoClient;
//DAO class for different MongoDB CRUD operations
//take special note of "id" String to ObjectId conversion and vice versa
//also take note of "_id" key for primary key
public class MongoDBUsersDAO {
private DBCollection col;
public MongoDBUsersDAO(MongoClient mongo) {
this.col = mongo.getDB("SpyderDB").getCollection("Users");
}
public User createUser(User p) {
User temp_user = getUserByName(p.getUserName());
if (temp_user == null) {
DBObject doc = UserConverter.toDBObject(p);
this.col.insert(doc);
ObjectId id = (ObjectId) doc.get("_id");
p.setId(id.toString());
return p;
}
return temp_user;
}
public void updateUser(User p) {
DBObject query = BasicDBObjectBuilder.start()
.append("_id", new ObjectId(p.getId())).get();
this.col.update(query, UserConverter.toDBObject(p));
}
public List<User> readAllUsers() {
List<User> data = new ArrayList<User>();
DBCursor cursor = col.find();
while (cursor.hasNext()) {
DBObject doc = cursor.next();
User p = UserConverter.toUser(doc);
data.add(p);
}
return data;
}
public void deleteUser(User p) {
DBObject query = BasicDBObjectBuilder.start()
.append("_id", new ObjectId(p.getId())).get();
this.col.remove(query);
}
public User readUser(User p) {
DBObject query = BasicDBObjectBuilder.start()
.append("_id", new ObjectId(p.getId())).get();
DBObject data = this.col.findOne(query);
return UserConverter.toUser(data);
}
public Set<User> getAllUsers(Set<String> user_id_list) {
Set<User> result = new HashSet<User>();
for (String id : user_id_list) {
DBObject query = BasicDBObjectBuilder.start()
.append("user_name",id).get();
DBObject data = this.col.findOne(query);
if (data != null) {
result.add(UserConverter.toUser(data));
}
}
return result;
}
public User getUserByName(String user_name) {
DBObject query = BasicDBObjectBuilder.start()
.append("user_name", user_name).get();
DBObject data = this.col.findOne(query);
if (data != null) {
return UserConverter.toUser(data);
}
return null;
}
public User getUserByQuery(String user_name, String password) {
DBObject query = BasicDBObjectBuilder.start()
.append("user_name", user_name).append("password", password)
.get();
DBObject data = this.col.findOne(query);
if (data != null) {
return UserConverter.toUser(data);
}
return null;
}
public List<User> getAllUsersWithSameMac(String mac_address,String user_name){
List<User> result = new ArrayList<User>();
DBCursor cursor = col.find();
while (cursor.hasNext()) {
DBObject doc = cursor.next();
User p = UserConverter.toUser(doc);
if(p.getMacAddress() != null && p.getMacAddress().equals(mac_address) && !p.getUserName().equals(user_name)){
result.add(p);
}
}
return result;
}
public void clear_mac_addresses(List<User> user_list){
for(User user: user_list){
user.setMacAddress(null);
updateUser(user);
}
}
}
|
Frequency-Dependent Selection in Randomly Mating Populations
A general model which accommodates different fitness values of an individual in association with each other type of individual is studied. The model in conjunction with population composition, in which individuals are assumed to be dispersed at random, determines the relative fitness values of individuals. Expressions for the change in gene frequency and for the mean are derived for one locus with two alleles in a random mating population. Equilibrium and max/min mean compositions generally require solving third-degree equations, but explicit expressions are found for models with general levels of dominance and some of their variants. Protected polymorphisms, genetic loads, inbreeding depressions, and the cost of a gene substitution are also considered. Many additional features of the statics and dynamics of populations are introduced with the effects of population composition on fitnesses. A single globally stable equilibrium can exist without any dominance. There may be multiple equilibria, up to three, with various stability characteristics, some of which are protected polymorphisms. There need not be any correspondence between compositions for max/min means and those for equilibria. Inbreeding depressions may be curvilinear, and even stable equilibrium populations may show negative inbreeding depressions. Very different models may give the same genetic load. The number of genetic deaths required for a gene substitution may be as few as twice the population size. One appeal of the model is that it encompasses several classes of models, including those with constant fitness values, and thus provides a basis for determining the appropriate model. After considering alternative experiments and measures of discrimination, we conclude that only survival values of the genotypes for several population compositions would be sufficient to discriminate between certain models. |
I’m dating myself, but the recent hysteria over the alleged "humanitarian catastrophe" which absolutely required quick US military intervention in Iraq – accompanied by familiar cries of "Genocide!" and numbers as high as 100,000 potential victims – brings to mind Emily Litella. Played by Gilda Radner on "Saturday Night Live" in the 1970s – I told you I was dating myself – the hearing-challenged Emily would appear on SNL’s "newscasts" giving her usually strong opinions on matters large and small, to be invariably corrected by the news anchor who would say something like: "No Emily, he didn’t say genocide – he said insecticide!" To which she would invariably turn her face to the audience and say "Never mind …"
Even as the professional sob sisters of the War Party were demanding US military action to "save" the Yazidis – an obscure Iraqi religious sect whose historic home on Mount Sinjar, in Kurdistan, was ringed with ISIS jihadis – the Pentagon was saying: "Never mind …":
"Several thousand Yazidis remain on the mountain, a senior United States official said, but not the tens of thousands who originally were believed to be there. Some of the people who remain on Mount Sinjar indicated to American forces that they considered the mountain to be a place of refuge and a home, and did not want to leave, a second United States official said."
According to the Times, while national security advisor Benjamin Rhodes was telling reporters ground troops may be on the way, and the neocons and their "progressive" enablers were working themselves into a fit of frothy-mouthed self-righteousness, eagerly anticipating another world-saving crusade, a "secret team of Marines and Special Operations forces were already on the ground" assessing the scope of the alleged crisis. And what did the Yazidis tell them? "We want to stay put!"
The lovable Yazidis, it seems, aren’t as bad off as Kurdistan’s public relations propagandists over at Patton Boggs – and their media megaphones – were telling us. According to CNN:
"Once believed to be in the tens of thousands, the number of Yazidis in the mountains is "now in the low thousands," Brett McGurk, a deputy assistant secretary of state, told CNN on Wednesday."
Never mind …
The yelps of disappointment could be heard all the way from Erbil. As the Times put it, "The speed with which the Obama administration announced that the siege had been broken may cause some consternation overseas."
You bet. Within hours the Kurds were complaining of abandonment, a theme we’re likely to hear more of in the near future: the Kurdish governor of Dahuk province sounded disappointed as he averred he’d been told to expect at least 15,000 Yazidis to be airlifted from Mount Singar.
So where’s my humanitarian catastrophe, dude? Apparently nowhere to be seen.
Oh, but there are "thousands" still up on Mount Bullshit, the "sick and elderly," we’re told – they must’ve been playing hide-and-seek when our Special Forces dropped in to check up on them. And just to cover all possible bases, now the Kurds and their neocon allies have come up with a new story: there’s another mountain, this time in Lebanon, which "jihadists" have surrounded and where thousands of victims of a potential "genocide" are sadly awaiting a horrible fate. Send in the Marines!
The truth or falsehood of these stories no longer seems to matter, however. As Rachel Maddow pointed out in her Wednesday night broadcast, this is turning into one of the fastest escalations of a military conflict in recent memory: from "no intervention" to "no troops on the ground" to "the Yanks are coming," the escalator didn’t take long to get very close to the top floor.
The same tiresome scenario has been playing out for years all over the world: in the 1990s it was the Kosovars, whose condition was hardly enviable, but who – as it turned out – were just as guilty as their Serbian overlords in murdering, raping, and looting once they’d gotten the upper hand. (And no one has ever accused the Serbs of organ-trafficking, an accusation leveled against the top leadership of Kosovo that has much grisly evidence to back it up.)
Then it was the Libyans’ turn, who told us the evil Gaddafi was about to commit "genocide" in Benghazi, where 100,000-plus victims were about to be massacred – unless we joined the battle on the rebels’ side.
Soon after that fiasco, it was the Syrian rebels’ turn: we were told Syrian despot Bashar al-Assad, on the brink of winning his war against local jihadis affiliated with al-Qaeda, had inexplicably decided to use "poison gas." This narrative was supposed to conjure images of Saddam Hussein gassing the Kurds in the 1990s (with gas supplied by his US allies). There was just one problem with this allegation: it wasn’t true. Indeed, from the discernible evidence – as cited by UN war crimes prosecutor Carla del Ponte and US journalist Seymour Hersh – it was likely the rebels were themselves the culprits.
Now the Kurdish Yazidis, who gained world fame on account of the War Party’s cock-and-bull story, have had their turn as the stars in yet another "humanitarian catastrophe" drama – one which turned out, like all the others, to be as phony as the altruistic motives of Bill Kristol and his fellow neocons.
It’s a game with a long pedigree, one that stretches all the way back to World War I when British propagandists spread the story that German soldiers were bayoneting Belgian babies. Indeed, images of children suffering at the hands of the Hated Enemy play a central role in this genre: it’s a form of child pornography modified to suit the purposes of the war propagandist. You’ll recall that a major impetus for the first Gulf war was a congressional hearing presided over by the late Rep. Tom Lantos featuring testimony by a tearful Kuwaiti woman who claimed she had personally witnessed Iraqi soldiers overturning incubators in a Kuwaiti hospital, as tots were trampled underfoot by rampaging invaders. The woman turned out to be the daughter of the Kuwaiti ambassador, her story a total fabrication.
But it was too late to stop the momentum of the War Party, which had already mobilized the political class behind their ersatz crusade for moral righteousness. The truth didn’t come out until later – and by that time US soldiers were already in Iraq, writing the first chapter in the story of the biggest blunder in American military history.
The same method is being used today to drag us back into Iraq: less than 24 hours after the "no boots on the ground" pledge by the administration was uttered US officials were already telling us "Well, maybe we’ll have boots on the ground." And this morning [Thursday], we hear that US troops are on their way back to Anbar province:
"Governor Dulaimi said in a telephone interview: ‘Our first goal is the air support. Their technology capability will offer a lot of intelligence information and monitoring of the desert and many things which we are in need of. No date was decided but it will be very soon and there will be a presence for the Americans in the western area.’"
As I said when this latest faux "crisis" broke out, this was never about the Yazidis. The United States is trying to salvage what it can from the ruins of Iraq, and it is doing so in order to 1) establish an independent Kurdish state, 2) appease the Israelis, who have a longstanding alliance with Erbil, and 3) satisfy the demands of the War Party here at home, which is ideologically committed to justifying a war that should never have been fought in the first place.
So we’re on our way back to Fallujah, of all places, scene of our greatest atrocities against the civilian population of Iraq and also of the vaunted "surge," which the War Party considers its finest hour. And all brought to you by a President who campaigned on his promise to get us out of that hellhole – and who has ceaselessly touted his alleged success in bringing that shameful chapter in our history to a close.
It’s been over 60 days since the Obama administration first notified Congress of the President’s intent to send troops back into Iraq – past the deadline set by the War Powers Act that is supposed to trigger either a vote in Congress or withdrawal. Where is Congress? On vacation – not only from their jobs, but from reality.
How about giving them a call to remind them of their constitutional duty?
And while I’m making requests of my readers: if you’ve visited the front page of Antiwar.com, you’ll know we’re in the midst of our summer fundraising campaign – and do I really have to hector you to send in a little moolah? Do I actually have to spend a couple hundred words detailing why it is absolutely necessary for Antiwar.com to continue to exist? Or is the foregoing sufficient to convince you?
If it isn’t sufficient, then I don’t know what would convince you. Perhaps the beginning of World War III – although I think the start of Iraq War III should be quite enough.
Please: make your tax-deductible contribution to Antiwar.com today – because tomorrow may be too late.
NOTES IN THE MARGIN
You can check out my Twitter feed by going here. But please note that my tweets are sometimes deliberately provocative, often made in jest, and largely consist of me thinking out loud.
I’ve written a couple of books, which you might want to peruse. Here is the link for buying the second edition of my 1993 book, Reclaiming the American Right: The Lost Legacy of the Conservative Movement, with an Introduction by Prof. George W. Carey, a Foreword by Patrick J. Buchanan, and critical essays by Scott Richert and David Gordon (ISI Books, 2008).
You can buy An Enemy of the State: The Life of Murray N. Rothbard (Prometheus Books, 2000), my biography of the great libertarian thinker, here.
Read more by Justin Raimondo |
def JitterEnabled(self):
return self._get_attribute('jitterEnabled') |
If you're planning on escaping winter for a little Florida sun, you may have some company on the beach—approximately 10,000 to 12,000 blacktip sharks.
In an ariel video captured by Stephen Kajiura, a professor of biological sciences at Florida Atlantic University who researches the migrating sharks, the ocean is filled with tiny black dots hovering just off the shore for 80 miles, from Miami to Jupiter Inlet. Each of those dots is a blacktip shark. You can check it out on Instagram, too.
@sharkmigration block-cam footage obtained by affixing a camera to a concrete block and placing it in the shallow water (<2m depth) near shore. A video posted by Colgan Foundation (@colganfoundation) on Feb 17, 2016 at 6:23pm PST
Much like your grandparents, the sharks migrate to Florida every winter and for much the same reason—to bask in the warm coastal waters and pig out on the fresh local fish.
In an interview with Live Science, Kajiura said that the current estimate of finned visitors is probably "a gross underestimate" of how many sharks actually are lurking in the ocean, because it only includes the ones that are visible in the shallow waters. "We see lots more sharks on the other side of the plane, so there's a lot more out there that we're simply not counting in the survey," Kajiura said.
While the idea of thousands of feeding sharks sounds daunting (or at least a good excuse to stay inland and, say, finally visit Pittsburgh), shark researchers claim that tourists have nothing to worry about. According to Kajiura, "they're not curious types," and typically have little interest in people. Exercise common sense and perhaps avoid wearing reflective watches or jewelry (which might be mistaken for the sharks' prey) just to be sure.
Kajiura thinks the sharks are a great addition to the roster of activities that Florida has to offer tourists. "You can literally sit on the beach and you can watch the blacktips jumping and spinning and splashing back into the water," Kajiura said. "They're not out to get you , you're not part of their diet, so you may as well go to the beach and enjoy the phenomenon."
The sharks are expected to stick around the Florida coast until mid-to late March, and then head north.
Other articles from Travel + Leisure: |
/// Parses string-key: value
fn parse_key_value<I: Input<Token=u8>>(i: I) -> ParseResult<I, (String, Value), Error> {
parse_string(i).bind(|i, s|
skip_while(i, is_whitespace).then(|i|
token(i, b':').then(|i|
skip_while(i, is_whitespace).then(|i|
parse(i).map(|v| (s, v))))))
} |
<reponame>wyan/ack<gh_stars>100-1000
#include "f2c.h"
double r_asin(x)
real *x;
{
double asin();
return( asin(*x) );
}
|
/**
*
* @author Victor de Lucca
*/
@WebFilter(filterName = "filter",
urlPatterns = {"/User","/ServiceForms", "/manageProduct"},
servletNames = {"HomeServlet", "manageProduct", "manageService", "manageUser", "manageCliente", "searchProduct",
"searchService", "searchUser", "searchCliente", "user", "service", "product", "cliente"})
public class FilterServlet implements Filter {
@Override
public void init(FilterConfig filterConfig)
throws ServletException {
}
@Override
public void doFilter(ServletRequest request,
ServletResponse response,
FilterChain chain)
throws IOException, ServletException {
HttpServletRequest httpRequest = (HttpServletRequest) request;
HttpServletResponse httpResponse = (HttpServletResponse) response;
HttpSession sessao = httpRequest.getSession();
// 1) Verificar se usuario esta autenticado
if (sessao.getAttribute("usuario") == null) {
httpResponse.sendRedirect(httpRequest.getContextPath() + "/login");
return;
}
User user = (User) sessao.getAttribute("usuario");
chain.doFilter(request, response);
// 2) Usuario logado, verifica se tem autorizacao para acessar recurso
/*if (verificarAcesso(user, httpRequest, httpResponse)) {
// Acesso ao recurso está liberado
chain.doFilter(request, response);
} else {
// Usuario nao tem autorizacao para acessar pagina
httpResponse.sendRedirect(httpRequest.getContextPath() + "/erro-autorizado.jsp");
}*/
}
private static boolean verificarAcesso(User user,
HttpServletRequest request, HttpServletResponse response) {
String paginaAcessada = request.getRequestURI();
String pagina = paginaAcessada.replace(request.getContextPath(), "");
if (pagina.endsWith("/ProductForms")
&& user.getType().compareToIgnoreCase("ESTOQUISTA") != 0
|| user.getType().compareToIgnoreCase("admin") != 0) {
return false;
} else if (pagina.endsWith("/ServiceForms") || pagina.endsWith("/ClienteForm")
&& (user.getType().compareToIgnoreCase("GERENTE") !=0 || user.getType().compareToIgnoreCase("VENDEDOR") != 0
|| user.getType().compareToIgnoreCase("admin") != 0)) {
return false;
} else if(pagina.startsWith("/User")
&& (user.getType().compareToIgnoreCase("TI") == 0 || user.getType().compareToIgnoreCase("admin") == 0)) {
return true;
}
return true;
}
@Override
public void destroy() {
}
} |
/*
* Ficheiro que possui todas as funções de gestão da Base de dados
*/
#include "sgbd.h"
/************************************
* Motor SGBD *
************************************/
//Criar Base de Dados vazia
SGBD *criarBaseDados(){
SGBD * baseDados = calloc(1, sizeof(SGBD));
if (!baseDados){
wprintf(L"Erro %d: Impossível alocar memória para Base de Dados", _ERR_MEMORYALLOC);
exit(_ERR_MEMORYALLOC);
}
baseDados->alunos = criarListaAluno();
baseDados->inscricoes = criarListaPastas();
baseDados->ucs = criarListaUC();
return baseDados;
}
//Libertar Memoria Base Dados
int libertarBD(SGBD * bd){
if(!bd){
wprintf(L"Erro %d: Não foi possivel libertar memória!", _ERR_MEMORYFREE);
return _ERR_MEMORYFREE;
}
if(bd->alunos){
libertarListaAluno(bd->alunos);
bd->alunos = NULL;
}
if(bd->ucs){
libertarListaUC(bd->ucs);
bd->ucs = NULL;
}
if(bd->inscricoes){
libertarListaPasta(bd->inscricoes);
bd->inscricoes = NULL;
}
free(bd);
bd=NULL;
return _SUCESSO;
}
//Gravar informação da bd nos ficheiros novamente
int gravarDados(SGBD * bd){
if(!bd){
wprintf(L"Erro %d: Base de Dados não existe\n");
return _ERR_RESOURCENOTFOUND;
}
//Gravar ficheiro de UCS
gravarUCTexto(bd->ucs);
//Gravar ficheiro de Alunos
gravarAlunosTexto(bd->alunos);
//Gravar ficheiro de inscrições
gravarInscricoesTexto(bd->inscricoes);
return _SUCESSO;
}
//Ler informação dos ficheiros
int carregarFicheiros(SGBD * bd){
if(!bd){
wprintf(L"Erro %d: Base de Dados não existe\n");
return _ERR_RESOURCENOTFOUND;
}
//Carregar ficheiro de UCS
lerUCTexto(bd->ucs);
//Carregar ficheiro de Alunos
lerListaAlunos(bd->alunos);
//Carregar ficheiro de inscrições
lerInscricoesTexto(bd->inscricoes);
return _SUCESSO;
}
//Validar Inscriçoes
int validarInscricoes(SGBD * bd, ALUNO * aluno, wchar_t * ano, int ects){
return validarInscricao(aluno,bd->ucs,ects,ano,bd->inscricoes);
}
//Calcular Propinas para o ultimo Ano
void calcularPropinas(SGBD * bd, ALUNO * aluno){
NO_PASTA * aux = obterAnoLetivoRecente(bd->inscricoes);
if(aux){
//Verifica se o aluno é residente ou estrangeiro e se é o 1ºanoou não
int opcao = condicaoPropina(aluno,bd->inscricoes);
int ects = 0;
//Obtem o final da lista o ano letivo mais recente
NO * temp = aux->cauda;
//Percorre a lista e soma o valor das ECTS a que o aluno está inscrito
for(int i =0; i<aux->elementos; i++){
temp = temp->proximo;
if(temp->elemento->numeroAluno == aluno->numero){
ects += obterECTS(obterUCNum(temp->elemento->numeroUC,bd->ucs));
}
}
aluno->propina = calculoPropina(ects,opcao);
}
}
//Cálculo da propina mediante condicão do estudante
int calculoPropina(int ects, int opcao) {
int propina;
if(opcao == 1) //Residente 1º ano
propina = 80 + 15 * ects;
else if(opcao == 2) //Residente não 1º ano
propina = 15 * ects;
else if(opcao == 3) //Estrangeiro 1º ano
propina = 80 + 15 * 1.2 * ects;
else if (opcao == 4) //Estrangeiro não 1º ano
propina = 15 * 1.2 * ects;
return propina;
}
//Verifica estatuto de residente do estudante e se é 1º inscrição
int condicaoPropina(ALUNO * aluno, LISTA_PASTA * inscricao) {
int opcao;
int res=wcscmp(L"Portugal",aluno->pais);
if(res == 0)
opcao = 1;
else
opcao = 3;
opcao += verificaInscricoesAnterioresAluno(aluno,obterAnoLetivoRecente(inscricao)->chave, inscricao);
return opcao;
}
/************************************
* Report A *
************************************/
//Gerar Report A
REP_A * gerarReportA(SGBD * bd){
int i,j, ects;
REP_A * reportA = criarListaReportA(); //Inicializa a lista do report A
NO_PASTA * pastaCorrente = obterAnoLetivoRecente(bd->inscricoes); //pasta do ano corrente
NO * no = pastaCorrente->cauda; //No de cada inscrição na pasta do ano corrente
ALUNO * aluno;
for(i=0; i < pastaCorrente->elementos; i++){ //Gerar tantos nós conforme o número de alunos inscritos
if(verificaElementoRepA(no->elemento->numeroAluno, reportA)){ //Verifica se o aluno já têm um nó no report
no = no->proximo;
continue;
}
aluno = obterAlunoNum(no->elemento->numeroAluno, bd->alunos); //Obter aluno em questão para extrair dados necessários
adicionarElementoRepA(criarElementoReportA(aluno->numero,aluno->nome,0,L"N/A"),reportA); //Caso não exista é adicionado
no = no->proximo;
}
No_REP_A * noReportA = reportA->cauda; //Aponta para a cauda da lista do Report
for(i=0; i<reportA->elementos; i++){ //Verifica para cada aluno, quantos ECTS têm
ects=0;
for(j=0; j< pastaCorrente->elementos; j++){
if(noReportA->elemento->numero == no->elemento->numeroAluno)
ects += obterECTS(obterUCNum(no->elemento->numeroUC, bd->ucs));
no = no->proximo;
}
if(ects > 60)
adicionarDadoElementoRepA(noReportA->elemento, ects, L"Aguarda Validação"); //Se tiver mais de 60 ECTS então lança observação para os serviços académicos
else
adicionarDadoElementoRepA(noReportA->elemento, ects, L"N/A");
noReportA = noReportA->proximo;
}
FILE * fp = criarReportA(); //abre ficheiro
escreverReportA(reportA,fp); //escreve no ficheiro os dados do report A
terminarReportA(fp); //fecha ficheiro
return reportA;
}
//Imprimir reportA total ECTS por aluno no ano corrente
void imprimirReportA(REP_A * reportA){
clearScreen();
No_REP_A * norep = reportA->cauda;
int i;
for(i =0; i<80; i++)
wprintf(L"-");
wprintf(L"\n|%17S|%24S|%10S|%24S|\n",L"Número de Aluno",L"Nome do Aluno",L"ECTS",L"Observações");
for(i =0; i<80; i++)
wprintf(L"-");
wprintf(L"\n");
for(i=0;i<reportA->elementos;i++){
wprintf(L"|%17d|%24S|%10d|%24S|\n", norep->elemento->numero, norep->elemento->nome,norep->elemento->ects, norep->elemento->observacao);
norep = norep->proximo;
}
for(i =0; i<80; i++)
wprintf(L"-");
}
/************************************
* Report B *
************************************/
//Gerar Report B
void gerarReportB(SGBD * bd){
LIST_ALUNO * alunosAux = bd->alunos;
LISTA_PASTA * auxInscricoes = bd->inscricoes;
FILE * reportFile = criarReportB();
//Percorrer a lista de todos os alunos
for(int i =0; i< alunosAux->elementos; i++){
REP_B * report = criarListaReportB(); //Cria estrutura de report B
ALUNO * aluno = obterAlunoPos(i,alunosAux);
//Percorrer todos os anos letivos
for(int p =0; p< auxInscricoes->pastas; p++){
NO_PASTA * pasta= obterPastaPos(p,auxInscricoes);
NO * no = pasta->cauda;
//Percorrer todas as inscrições do ano
for(int n = 0; n <pasta->elementos; n++){
no = no->proximo;
//Verificar se inscrição pertence ao aluno
if(no->elemento->numeroAluno == aluno->numero){
//Pesquisa na estrutura para verificar se encontra o id da UC na estrutura
REP_B_ELEM * aux = obterElementoReportBNum(no->elemento->numeroUC, report);
if(aux != NULL){
//Caso o id da uc esteja na estrutura, verifica se a mesma já está concluida, caso não esteja atualiza estado com nova nota
if(aux->estado != 1)
modificarEstado(aux,no->elemento->nota);
} else
//Caso não esteja na estrutura adiciona a uc à estrutura
adicionarElementoRepBFim(report, criarElementoReportB(no->elemento->numeroUC, no->elemento->nota));
}
}
}
//Verifica se estrutura possui tantos elementos como unidades na bd
if(report->quantidade == bd->ucs->elementos){
int contador = 0;
REP_B_ELEM * aux = report->cauda;
//Soma todas o valor de estados da UC na estrutura.
for(int e =0; e < report->quantidade; e++){
aux = aux->proximo;
contador += aux->estado;
}
//Se a soma for igual ou superior ao total de ucs-3 e não for a totalidade de UC escreve no ficheiro
if(contador >= bd->ucs->elementos - 3 && contador < bd->ucs->elementos){
escreverLinhaReportB(aluno,contador, reportFile);
}
}
libertarListaReportB(report);
}
terminarReportB(reportFile);
}
//Imprimir do Report B
void imprimirReportB(){
clearScreen();
FILE * fp = abrirLeituraReportB();
wchar_t * linha = calloc(_TAMSTRING,sizeof(wchar_t));
if(!fp){
wprintf(L"Erro %d: Não foi possivel encontrar o ficheiro a terminar.", _ERR_RESOURCENOTFOUND);
exit(_ERR_RESOURCENOTFOUND);
}
for(int i=0;i<80;i++)
wprintf(L"-");
wprintf(L"\n|%25S|%25S|%26S|\n",L"Número de Aluno", L"Nome de Aluno", L"Total de UCs Realizadas");
for(int i=0;i<80;i++)
wprintf(L"-");
while(!feof(fp)){
fwscanf(fp,L"%l[^\n]\n",linha);
if(wmemcmp(linha,L"#",1)==0 || wcsncmp(linha,L" ",1)==0)
continue;
imprimirLinhaReportB(linha);
}
wprintf(L"\n");
for(int i=0;i<80;i++)
wprintf(L"-");
free(linha);
linha = NULL;
terminarLeituraReportB(fp);
}
//Imprimir linha Report B
void imprimirLinhaReportB(wchar_t * linha){
wchar_t * temp, * buffer;
int numeroAluno = wcstol(wcstok(linha, L";", &buffer), &temp,10);
wchar_t * nome = wcstok(NULL,L";",&buffer);
int totalUC = wcstol(wcstok(NULL, L";", &buffer), &temp,10);
wprintf(L"\n|%25d|%25S|%26d|",numeroAluno,nome,totalUC);
}
/************************************
* Report C *
************************************/
//criar report c
void gerarReportC(SGBD * bd){
//Percorrer cada elemento da lista de alunos
LIST_ALUNO * alunosAux = bd->alunos;
FILE * reportFile = criarReportC();
//Percorrer a lista de todos os alunos
for(int i =0; i< alunosAux->elementos; i++){
PROB_ABANDONO * report = criarListaReportC(); //Cria estrutura de report C
ALUNO * aluno = obterAlunoPos(i,alunosAux);
// obter pasta do ano letivo final
NO_PASTA * pasta = obterAnoLetivoRecente(bd->inscricoes);
NO * no = pasta->cauda;
//percorrer pasta
for(int p =0; p < pasta->elementos; p++){
no = no->proximo;
//comparar se inscrição pertence ao aluno
if(no->elemento->numeroAluno == aluno->numero){
UC * temp = obterUCNum(no->elemento->numeroUC, bd->ucs);
//se uc estiver em 1semestre então incrementa semestre1;
if( temp->semestre == 1){
report->contador_semestre_1++;
} else //se uc->2semestre entao incrementa semestre2;*/
report->contador_semestre_2++;
}
}
//escreve no report c
if(report->contador_semestre_2==0){
if(report->contador_semestre_1>=2){
escreverLinhaReportC(aluno, reportFile);
}
}
libertarElementoReportC(report);
}
terminarReportC(reportFile);
}
//Imprimir do Report C
void imprimirReportC(){
clearScreen();
FILE * fp = abrirLeituraReportC();
wchar_t * linha = calloc(_TAMSTRING,sizeof(wchar_t));
if(!fp){
wprintf(L"Erro %d: Não foi possivel encontrar o ficheiro a terminar.", _ERR_RESOURCENOTFOUND);
exit(_ERR_RESOURCENOTFOUND);
}
for(int i=0;i<80;i++)
wprintf(L"-");
wprintf(L"\n|%39S|%38S|\n",L"Número de Aluno", L"Nome de Aluno");
for(int i=0;i<80;i++)
wprintf(L"-");
while(!feof(fp)){
fwscanf(fp,L"%l[^\n]\n",linha);
if(wmemcmp(linha,L"#",1)==0 || wcsncmp(linha,L" ",1)==0)
continue;
imprimirLinhaReportC(linha);
}
wprintf(L"\n");
for(int i=0;i<80;i++)
wprintf(L"-");
free(linha);
linha = NULL;
terminarLeituraReportC(fp);
}
//Imprimir linha Report C
void imprimirLinhaReportC(wchar_t * linha){
wchar_t * temp, * buffer;
int numeroAluno = wcstol(wcstok(linha, L";", &buffer), &temp,10);
wchar_t * nome = wcstok(NULL,L";",&buffer);
wprintf(L"\n|%39d|%38S|",numeroAluno,nome);
}
/************************************
* Report D *
************************************/
//Gerar Report D
void gerarReportD(SGBD *bd){
//Obter ano letivo mais antigo e mais recente
wchar_t * ano = obterAnoLetivoMaisAntigo(bd->inscricoes)->chave;
wchar_t * anofinal = obterAnoLetivoRecente(bd->inscricoes)->chave;
wchar_t * temp, *buffer;
//Transformar ano letivo antigo em inteiro para depois poder incrementar
wchar_t * anoAux = calloc(_TAMDATAS, sizeof(wchar_t));
if(!anoAux){
wprintf(L"Erro %d: Não foi possivel alocar memoriapara o report.", _ERR_MEMORYALLOC);
exit(_ERR_MEMORYALLOC);
}
wcscpy(anoAux, ano);
int ano1 = wcstol(wcstok(anoAux,L"/", &buffer), &temp, 10);
int ano2 = wcstol(wcstok(NULL,L"", &buffer), &temp, 10);
wcscpy(anoAux, ano);
//Cria ficheiro report D
FILE * reportFile = criarReportD();
//Cria estrutura para guardar a informação
REP_D * report = criarListaReportD();
//Percorre as pastas de anos letivos por ordem temporal
NO_PASTA * pasta;
while(wcscmp(anoAux, anofinal) <= 0 ){
//obtem pasta referente ao ano letivo que se pretende verificar
pasta = obterPastaAno(anoAux,bd->inscricoes);
if(pasta != NULL){
//Cria a lista do ano letivo
REP_D_LISTA * infoAnoletivo = criarListaAnoReportD();
//Percorre a pasta do ano letivo
for(int p =0; p< pasta->elementos; p++){
INSCRICAO * no = obterInscricao(p,pasta);
//Verifica se o idAluno já está na lista, caso não esteja adiciona
if(!obterElementoReportDNum(no->numeroAluno, infoAnoletivo)){
adicionarElementoAnoRepDFim(infoAnoletivo,criarElementoAnoReportD(no->numeroAluno));
}
}
//Adiciona informação a estrutura do report D
adicionarElementoRepDFim(report,criarElementoReportD(anoAux,infoAnoletivo->elementos));
libertarListaAnoReportD(infoAnoletivo);
pasta = NULL;
}
//Atualiza valor Ano Letivo
swprintf(anoAux, wcslen(anoAux)+1, L"%d/%d", ++ano1,++ano2);
}
//Escrever informação no ficheiro
REP_D_ELEM * aux = report->cauda;
int ultimo;
for(int i = 0; i< report->elementos; i++){
//verifica se é o 1º ano de dados
if(i==0){
ultimo =0;
} else{
ultimo = aux->totalAlunos;
}
aux = aux->proximo;
//Calculo de Percentagem
int percentagem =0;
if(ultimo ==0)
percentagem = 100;//Como não existiu alunos anteriormente o aumento foi de 100%
else
//Regra de 3 simples para calcular a percentagem (subtraio os 100 do valor inicial [diferença entre o ano e o ano anterior])
percentagem =((aux->totalAlunos *100) / ultimo)-100;
//Escrever no Relatório
escreverLinhaReportD(aux->ano, aux->totalAlunos, percentagem, reportFile);
}
free(anoAux);
libertarListaReportD(report);
terminarReportD(reportFile);
}
//Imprimir do Report D
void imprimirReportD(){
clearScreen();
FILE * fp = abrirLeituraReportD();
wchar_t * linha = calloc(_TAMSTRING,sizeof(wchar_t));
if(!fp){
wprintf(L"Erro %d: Não foi possivel encontrar o ficheiro a terminar.", _ERR_RESOURCENOTFOUND);
exit(_ERR_RESOURCENOTFOUND);
}
for(int i=0;i<80;i++)
wprintf(L"-");
wprintf(L"\n|%25S|%25S|%26S|\n",L"Ano Letivo", L"Quantidade de Alunos",L"Variação");
for(int i=0;i<80;i++)
wprintf(L"-");
while(!feof(fp)){
fwscanf(fp,L"%l[^\n]\n",linha);
if(wmemcmp(linha,L"#",1)==0 || wcsncmp(linha,L" ",1)==0)
continue;
imprimirLinhaReportD(linha);
}
wprintf(L"\n");
for(int i=0;i<80;i++)
wprintf(L"-");
free(linha);
linha = NULL;
terminarLeituraReportD(fp);
}
//Imprimir linha Report D
void imprimirLinhaReportD(wchar_t * linha){
wchar_t * temp, * buffer;
wchar_t * anoLetivo = wcstok(linha, L";", &buffer);
int quantidade = wcstol(wcstok(NULL, L";", &buffer), &temp,10);
int variacao = wcstol(wcstok(NULL, L";", &buffer), &temp,10);
wprintf(L"\n|%25S|%25d|%26d|",anoLetivo,quantidade,variacao);
}
|
/**
*
* @author Andrei Badea, Jiri Skrivanek
*/
public class SQLLexerTest extends NbTestCase {
public SQLLexerTest(String testName) {
super(testName);
}
public void testSimple() throws Exception {
TokenSequence<SQLTokenId> seq = getTokenSequence("select -/ from 'a' + 1, dto");
assertTokens(seq, SQLTokenId.KEYWORD, SQLTokenId.WHITESPACE, SQLTokenId.OPERATOR,
SQLTokenId.OPERATOR, SQLTokenId.WHITESPACE, SQLTokenId.KEYWORD,
SQLTokenId.WHITESPACE, SQLTokenId.STRING, SQLTokenId.WHITESPACE,
SQLTokenId.OPERATOR, SQLTokenId.WHITESPACE, SQLTokenId.INT_LITERAL,
SQLTokenId.COMMA, SQLTokenId.WHITESPACE, SQLTokenId.IDENTIFIER,
SQLTokenId.WHITESPACE);
}
public void testQuotedIdentifiers() throws Exception {
TokenSequence<SQLTokenId> seq = getTokenSequence("select \"derby\", `mysql`, [mssql], `quo + ted`");
assertTokens(seq, SQLTokenId.KEYWORD, SQLTokenId.WHITESPACE, SQLTokenId.IDENTIFIER,
SQLTokenId.COMMA, SQLTokenId.WHITESPACE, SQLTokenId.IDENTIFIER,
SQLTokenId.COMMA, SQLTokenId.WHITESPACE, SQLTokenId.IDENTIFIER,
SQLTokenId.COMMA, SQLTokenId.WHITESPACE, SQLTokenId.IDENTIFIER,
SQLTokenId.WHITESPACE);
}
/**
* Test escape in quoted identifiers following SQL99 methology
*/
public void testQuotedIdentifiers2() throws Exception {
TokenSequence<SQLTokenId> seq = getTokenSequence("\"derby\"\"\",`mysql```,[mssql]]]");
assertTokens(seq, SQLTokenId.IDENTIFIER,
SQLTokenId.COMMA, SQLTokenId.IDENTIFIER,
SQLTokenId.COMMA, SQLTokenId.IDENTIFIER,
SQLTokenId.WHITESPACE);
}
public void testSimpleSQL99Quoting() throws Exception {
TokenSequence<SQLTokenId> seq = getTokenSequence("select -/ from 'a''' + 1, dto");
assertTokens(seq, SQLTokenId.KEYWORD, SQLTokenId.WHITESPACE, SQLTokenId.OPERATOR,
SQLTokenId.OPERATOR, SQLTokenId.WHITESPACE, SQLTokenId.KEYWORD,
SQLTokenId.WHITESPACE, SQLTokenId.STRING, SQLTokenId.WHITESPACE,
SQLTokenId.OPERATOR, SQLTokenId.WHITESPACE, SQLTokenId.INT_LITERAL,
SQLTokenId.COMMA, SQLTokenId.WHITESPACE, SQLTokenId.IDENTIFIER,
SQLTokenId.WHITESPACE);
}
public void testQuotedIdentifiersSQL99Quote() throws Exception {
TokenSequence<SQLTokenId> seq = getTokenSequence("select \"\"\"derby\", `mysql`, [mssql], `quo + ted`");
assertTokens(seq, SQLTokenId.KEYWORD, SQLTokenId.WHITESPACE, SQLTokenId.IDENTIFIER,
SQLTokenId.COMMA, SQLTokenId.WHITESPACE, SQLTokenId.IDENTIFIER,
SQLTokenId.COMMA, SQLTokenId.WHITESPACE, SQLTokenId.IDENTIFIER,
SQLTokenId.COMMA, SQLTokenId.WHITESPACE, SQLTokenId.IDENTIFIER,
SQLTokenId.WHITESPACE);
}
public void testIncompleteIdentifier() throws Exception {
TokenSequence<SQLTokenId> seq = getTokenSequence("select \"\"\"derby\", `mysql`, [mssql], `quo + ted");
assertTokens(seq, SQLTokenId.KEYWORD, SQLTokenId.WHITESPACE, SQLTokenId.IDENTIFIER,
SQLTokenId.COMMA, SQLTokenId.WHITESPACE, SQLTokenId.IDENTIFIER,
SQLTokenId.COMMA, SQLTokenId.WHITESPACE, SQLTokenId.IDENTIFIER,
SQLTokenId.COMMA, SQLTokenId.WHITESPACE, SQLTokenId.INCOMPLETE_IDENTIFIER);
seq = getTokenSequence("select \"\"\"derby\", `mysql`, [mssql");
assertTokens(seq, SQLTokenId.KEYWORD, SQLTokenId.WHITESPACE, SQLTokenId.IDENTIFIER,
SQLTokenId.COMMA, SQLTokenId.WHITESPACE, SQLTokenId.IDENTIFIER,
SQLTokenId.COMMA, SQLTokenId.WHITESPACE, SQLTokenId.INCOMPLETE_IDENTIFIER);
seq = getTokenSequence("select \"\"\"derby\", `mysql`, [mssql]");
assertTokens(seq, SQLTokenId.KEYWORD, SQLTokenId.WHITESPACE, SQLTokenId.IDENTIFIER,
SQLTokenId.COMMA, SQLTokenId.WHITESPACE, SQLTokenId.IDENTIFIER,
SQLTokenId.COMMA, SQLTokenId.WHITESPACE, SQLTokenId.IDENTIFIER,
SQLTokenId.WHITESPACE);
seq = getTokenSequence("select \"\"\"derby");
assertTokens(seq, SQLTokenId.KEYWORD, SQLTokenId.WHITESPACE,
SQLTokenId.INCOMPLETE_IDENTIFIER);
}
public void testComments() throws Exception {
TokenSequence<SQLTokenId> seq = getTokenSequence("-- line comment\n# mysql comment\n/* block \ncomment*/\n#notComment");
assertTokens(seq, SQLTokenId.LINE_COMMENT, SQLTokenId.LINE_COMMENT,
SQLTokenId.BLOCK_COMMENT, SQLTokenId.WHITESPACE, SQLTokenId.IDENTIFIER, SQLTokenId.WHITESPACE);
}
public void testNewLineInString() throws Exception {
TokenSequence<SQLTokenId> seq = getTokenSequence("'new\nline'");
assertTokens(seq, SQLTokenId.STRING, SQLTokenId.WHITESPACE);
}
public void testIncompleteString() throws Exception {
TokenSequence<SQLTokenId> seq = getTokenSequence("'incomplete");
assertTokens(seq, SQLTokenId.INCOMPLETE_STRING);
}
public void testSingleQuote() throws Exception {
// See bug #200479 - the fix introduced with this text reverts a "fix"
// for bug #152325 - the latter bug can't be fixed, as it is clear violation
// to SQL Standard - as this is a SQL lexer, not a MySQL lexer, this should
// should follow the standard
TokenSequence<SQLTokenId> seq = getTokenSequence("'\\'");
assertTokens(seq, SQLTokenId.STRING, SQLTokenId.WHITESPACE);
}
public void testPlaceHolder() throws Exception {
assertTokens(getTokenSequence("SELECT a FROM b WHERE c = :var"),
SQLTokenId.KEYWORD, SQLTokenId.WHITESPACE,
SQLTokenId.IDENTIFIER, SQLTokenId.WHITESPACE,
SQLTokenId.KEYWORD, SQLTokenId.WHITESPACE,
SQLTokenId.IDENTIFIER, SQLTokenId.WHITESPACE,
SQLTokenId.KEYWORD, SQLTokenId.WHITESPACE,
SQLTokenId.IDENTIFIER, SQLTokenId.WHITESPACE,
SQLTokenId.OPERATOR, SQLTokenId.WHITESPACE,
SQLTokenId.IDENTIFIER, SQLTokenId.WHITESPACE);
assertTokens(getTokenSequence("SELECT a FROM b WHERE c = :var"),
SQLTokenId.KEYWORD, SQLTokenId.WHITESPACE,
SQLTokenId.IDENTIFIER, SQLTokenId.WHITESPACE,
SQLTokenId.KEYWORD, SQLTokenId.WHITESPACE,
SQLTokenId.IDENTIFIER, SQLTokenId.WHITESPACE,
SQLTokenId.KEYWORD, SQLTokenId.WHITESPACE,
SQLTokenId.IDENTIFIER, SQLTokenId.WHITESPACE,
SQLTokenId.OPERATOR, SQLTokenId.WHITESPACE,
SQLTokenId.IDENTIFIER, SQLTokenId.WHITESPACE);
}
public void testVariableDeclaration() throws Exception {
assertTokens(getTokenSequence("@a:='test'"), SQLTokenId.IDENTIFIER, SQLTokenId.OPERATOR, SQLTokenId.STRING, SQLTokenId.WHITESPACE);
}
public void testOperators() throws Exception {
// Basic Arithmetic
assertTokens(getTokenSequence("a+b"), SQLTokenId.IDENTIFIER, SQLTokenId.OPERATOR, SQLTokenId.IDENTIFIER, SQLTokenId.WHITESPACE);
assertTokens(getTokenSequence("a-b"), SQLTokenId.IDENTIFIER, SQLTokenId.OPERATOR, SQLTokenId.IDENTIFIER, SQLTokenId.WHITESPACE);
assertTokens(getTokenSequence("a* b"), SQLTokenId.IDENTIFIER, SQLTokenId.OPERATOR, SQLTokenId.WHITESPACE, SQLTokenId.IDENTIFIER, SQLTokenId.WHITESPACE);
assertTokens(getTokenSequence("a /b"), SQLTokenId.IDENTIFIER, SQLTokenId.WHITESPACE, SQLTokenId.OPERATOR, SQLTokenId.IDENTIFIER, SQLTokenId.WHITESPACE);
assertTokens(getTokenSequence("a % b"), SQLTokenId.IDENTIFIER, SQLTokenId.WHITESPACE, SQLTokenId.OPERATOR, SQLTokenId.WHITESPACE, SQLTokenId.IDENTIFIER, SQLTokenId.WHITESPACE);
// Bitwise operators (MSSQL)
assertTokens(getTokenSequence("a&b"), SQLTokenId.IDENTIFIER, SQLTokenId.OPERATOR, SQLTokenId.IDENTIFIER, SQLTokenId.WHITESPACE);
assertTokens(getTokenSequence("a|b"), SQLTokenId.IDENTIFIER, SQLTokenId.OPERATOR, SQLTokenId.IDENTIFIER, SQLTokenId.WHITESPACE);
assertTokens(getTokenSequence("a^b"), SQLTokenId.IDENTIFIER, SQLTokenId.OPERATOR, SQLTokenId.IDENTIFIER, SQLTokenId.WHITESPACE);
// Unäres bitwise not (ones complement)
assertTokens(getTokenSequence("~b"), SQLTokenId.OPERATOR, SQLTokenId.IDENTIFIER, SQLTokenId.WHITESPACE);
// Comparison operators
assertTokens(getTokenSequence("a=b"), SQLTokenId.IDENTIFIER, SQLTokenId.OPERATOR, SQLTokenId.IDENTIFIER, SQLTokenId.WHITESPACE);
assertTokens(getTokenSequence("a>b"), SQLTokenId.IDENTIFIER, SQLTokenId.OPERATOR, SQLTokenId.IDENTIFIER, SQLTokenId.WHITESPACE);
assertTokens(getTokenSequence("a<b"), SQLTokenId.IDENTIFIER, SQLTokenId.OPERATOR, SQLTokenId.IDENTIFIER, SQLTokenId.WHITESPACE);
assertTokens(getTokenSequence("a<>b"), SQLTokenId.IDENTIFIER, SQLTokenId.OPERATOR, SQLTokenId.IDENTIFIER, SQLTokenId.WHITESPACE);
assertTokens(getTokenSequence("a>=b"), SQLTokenId.IDENTIFIER, SQLTokenId.OPERATOR, SQLTokenId.IDENTIFIER, SQLTokenId.WHITESPACE);
assertTokens(getTokenSequence("a<=b"), SQLTokenId.IDENTIFIER, SQLTokenId.OPERATOR, SQLTokenId.IDENTIFIER, SQLTokenId.WHITESPACE);
assertTokens(getTokenSequence("a !=b"), SQLTokenId.IDENTIFIER, SQLTokenId.WHITESPACE, SQLTokenId.OPERATOR, SQLTokenId.IDENTIFIER, SQLTokenId.WHITESPACE);
assertTokens(getTokenSequence("a!< b"), SQLTokenId.IDENTIFIER, SQLTokenId.OPERATOR, SQLTokenId.WHITESPACE, SQLTokenId.IDENTIFIER, SQLTokenId.WHITESPACE);
assertTokens(getTokenSequence("a !> b"), SQLTokenId.IDENTIFIER, SQLTokenId.WHITESPACE, SQLTokenId.OPERATOR, SQLTokenId.WHITESPACE, SQLTokenId.IDENTIFIER, SQLTokenId.WHITESPACE);
// Concatenation (Informix)
assertTokens(getTokenSequence("a||b"), SQLTokenId.IDENTIFIER, SQLTokenId.OPERATOR, SQLTokenId.IDENTIFIER, SQLTokenId.WHITESPACE);
// Assignement Operator (SPL)
assertTokens(getTokenSequence("a:=b"), SQLTokenId.IDENTIFIER, SQLTokenId.OPERATOR, SQLTokenId.IDENTIFIER, SQLTokenId.WHITESPACE);
// Compound Operators (Transact-SQL)
assertTokens(getTokenSequence("a+=b"), SQLTokenId.IDENTIFIER, SQLTokenId.OPERATOR, SQLTokenId.IDENTIFIER, SQLTokenId.WHITESPACE);
assertTokens(getTokenSequence("a-=b"), SQLTokenId.IDENTIFIER, SQLTokenId.OPERATOR, SQLTokenId.IDENTIFIER, SQLTokenId.WHITESPACE);
assertTokens(getTokenSequence("a*=b"), SQLTokenId.IDENTIFIER, SQLTokenId.OPERATOR, SQLTokenId.IDENTIFIER, SQLTokenId.WHITESPACE);
assertTokens(getTokenSequence("a/=b"), SQLTokenId.IDENTIFIER, SQLTokenId.OPERATOR, SQLTokenId.IDENTIFIER, SQLTokenId.WHITESPACE);
assertTokens(getTokenSequence("a%=b"), SQLTokenId.IDENTIFIER, SQLTokenId.OPERATOR, SQLTokenId.IDENTIFIER, SQLTokenId.WHITESPACE);
assertTokens(getTokenSequence("a&=b"), SQLTokenId.IDENTIFIER, SQLTokenId.OPERATOR, SQLTokenId.IDENTIFIER, SQLTokenId.WHITESPACE);
assertTokens(getTokenSequence("a^=b"), SQLTokenId.IDENTIFIER, SQLTokenId.OPERATOR, SQLTokenId.IDENTIFIER, SQLTokenId.WHITESPACE);
assertTokens(getTokenSequence("a|=b"), SQLTokenId.IDENTIFIER, SQLTokenId.OPERATOR, SQLTokenId.IDENTIFIER, SQLTokenId.WHITESPACE);
}
/**
* Check correct handling of multiline comments (bug #)
*
* @throws Exception
*/
public void testMultiLineComment() throws Exception {
TokenSequence<SQLTokenId> seq = getTokenSequence("/**/\n"
+ "select * from test;");
assertTokens(seq, SQLTokenId.BLOCK_COMMENT, SQLTokenId.WHITESPACE,
SQLTokenId.KEYWORD, SQLTokenId.WHITESPACE, SQLTokenId.OPERATOR,
SQLTokenId.WHITESPACE, SQLTokenId.KEYWORD, SQLTokenId.WHITESPACE,
SQLTokenId.IDENTIFIER, SQLTokenId.OPERATOR, SQLTokenId.WHITESPACE);
seq = getTokenSequence("/****/\n"
+ "select * from test;");
assertTokens(seq, SQLTokenId.BLOCK_COMMENT, SQLTokenId.WHITESPACE,
SQLTokenId.KEYWORD, SQLTokenId.WHITESPACE, SQLTokenId.OPERATOR,
SQLTokenId.WHITESPACE, SQLTokenId.KEYWORD, SQLTokenId.WHITESPACE,
SQLTokenId.IDENTIFIER, SQLTokenId.OPERATOR, SQLTokenId.WHITESPACE);
// Bug #: The following sequences led to only one token
seq = getTokenSequence("/***/\n"
+ "select * from test;");
assertTokens(seq, SQLTokenId.BLOCK_COMMENT, SQLTokenId.WHITESPACE,
SQLTokenId.KEYWORD, SQLTokenId.WHITESPACE, SQLTokenId.OPERATOR,
SQLTokenId.WHITESPACE, SQLTokenId.KEYWORD, SQLTokenId.WHITESPACE,
SQLTokenId.IDENTIFIER, SQLTokenId.OPERATOR, SQLTokenId.WHITESPACE);
seq = getTokenSequence("/*****/\n"
+ "select * from test;");
assertTokens(seq, SQLTokenId.BLOCK_COMMENT, SQLTokenId.WHITESPACE,
SQLTokenId.KEYWORD, SQLTokenId.WHITESPACE, SQLTokenId.OPERATOR,
SQLTokenId.WHITESPACE, SQLTokenId.KEYWORD, SQLTokenId.WHITESPACE,
SQLTokenId.IDENTIFIER, SQLTokenId.OPERATOR, SQLTokenId.WHITESPACE);
seq = getTokenSequence("/*** Test **/\n"
+ "select * from test;");
assertTokens(seq, SQLTokenId.BLOCK_COMMENT, SQLTokenId.WHITESPACE,
SQLTokenId.KEYWORD, SQLTokenId.WHITESPACE, SQLTokenId.OPERATOR,
SQLTokenId.WHITESPACE, SQLTokenId.KEYWORD, SQLTokenId.WHITESPACE,
SQLTokenId.IDENTIFIER, SQLTokenId.OPERATOR, SQLTokenId.WHITESPACE);
seq = getTokenSequence("/*** \n* Test\n **/\n"
+ "select * from test;");
assertTokens(seq, SQLTokenId.BLOCK_COMMENT, SQLTokenId.WHITESPACE,
SQLTokenId.KEYWORD, SQLTokenId.WHITESPACE, SQLTokenId.OPERATOR,
SQLTokenId.WHITESPACE, SQLTokenId.KEYWORD, SQLTokenId.WHITESPACE,
SQLTokenId.IDENTIFIER, SQLTokenId.OPERATOR, SQLTokenId.WHITESPACE);
}
private static TokenSequence<SQLTokenId> getTokenSequence(String sql) throws BadLocationException {
ModificationTextDocument doc = new ModificationTextDocument();
doc.insertString(0, sql, null);
doc.putProperty(Language.class, SQLTokenId.language());
TokenHierarchy<?> hi = TokenHierarchy.get(doc);
doc.readLock();
TokenSequence<SQLTokenId> seq = hi.tokenSequence(SQLTokenId.language());
doc.readUnlock();
seq.moveStart();
return seq;
}
private static CharSequence dumpTokens(TokenSequence<?> seq) {
seq.moveStart();
StringBuilder builder = new StringBuilder();
Token<?> token = null;
while (seq.moveNext()) {
if (token != null) {
builder.append('\n');
}
token = seq.token();
builder.append(token.id());
PartType part = token.partType();
if (part != PartType.COMPLETE) {
builder.append(' ');
builder.append(token.partType());
}
builder.append(' ');
builder.append('\'');
builder.append(token.text());
builder.append('\'');
}
return builder;
}
private static void assertTokens(TokenSequence<SQLTokenId> seq, SQLTokenId... ids) {
if (ids == null) {
ids = new SQLTokenId[0];
}
assertEquals("Wrong token count.", ids.length, seq.tokenCount());
seq.moveNext();
for (SQLTokenId id : ids) {
assertEquals("Wrong token ID at index " + seq.index(), id, seq.token().id());
seq.moveNext();
}
}
} |
// - Verify that the decrement button won't decrease the quantity 0 and cost below $0.00
@Test
public void clickDecrementButton_ChangesQuantityAndCost() {
onView(withId(R.id.quantity_text_view)).check(matches(withText("0")));
onView(withId(R.id.decrement_button)).perform(click());
onView(withId(R.id.quantity_text_view)).check(matches(withText("0")));
onView(withId(R.id.cost_text_view)).check(matches(withText("$0.00")));
} |
def _get_minibatches(self, *args, length=0):
self.length_cum = 0
stop = False
if length > 0:
while not stop:
a = []
for arg in args:
a.append(arg[self.length_cum: self.length_cum + length])
yield tuple(a)
self.length_cum += a[0].shape[0]
stop = self.length_cum >= args[0].shape[0]
if stop:
self.length_cum = 0
else:
yield args |
<filename>demo-core/src/main/java/id/demo/crude/dao/ProvinsiDAO.java
package id.demo.crude.dao;
import id.demo.crude.entity.Provinsi;
public interface ProvinsiDAO extends BaseDAO<Provinsi> {
}
|
# https://atcoder.jp/contests/abc136/tasks/abc136_b
N = input()
len_n = len(N)
N = int(N)
count = 0
if len_n % 2 == 1:
current_len_min_val = 10 ** (len_n - 1)
count += N - current_len_min_val + 1
for i in range(1, len_n, 2):
count += 10 ** i - 10 ** (i-1)
print(count)
|
def start_task(self, taskid):
self.cursor.execute("UPDATE todolist SET status=? WHERE priority=?;", (STATUS.STARTED.value, taskid))
self.conn.commit()
self.summary['STARTED'] += 1 |
def GetFromGraph(self, *args):
return _Interface.Interface_GraphContent_GetFromGraph(self, *args) |
def power(base,exponent):
res = 1
while exponent:
if exponent & 1:
res *= base
res %= 1000000007
base *= base
base %= 1000000007
exponent = exponent >> 1
res %= 1000000007
return res
t=int(input())
for i in range(0,t):
a=list(map(int,input().split()))
result=power(a[0],a[1])
print(result) |
<filename>2d_samples/pmj02_116.inl<gh_stars>1-10
{std::array<float,2>{0.741102755f, 0.871173799f},
std::array<float,2>{0.0730450824f, 0.385653794f},
std::array<float,2>{0.33492732f, 0.563844204f},
std::array<float,2>{0.750660002f, 0.0686030611f},
std::array<float,2>{0.922748685f, 0.747006357f},
std::array<float,2>{0.431425482f, 0.216161087f},
std::array<float,2>{0.22381331f, 0.885834992f},
std::array<float,2>{0.544904828f, 0.366997272f},
std::array<float,2>{0.828110099f, 0.984762967f},
std::array<float,2>{0.251210004f, 0.277144969f},
std::array<float,2>{0.0193213467f, 0.645980239f},
std::array<float,2>{0.677106738f, 0.160594121f},
std::array<float,2>{0.597101212f, 0.502210498f},
std::array<float,2>{0.13090618f, 0.0339919776f},
std::array<float,2>{0.439716876f, 0.764487863f},
std::array<float,2>{0.977838159f, 0.458628714f},
std::array<float,2>{0.503199041f, 0.907525182f},
std::array<float,2>{0.217279688f, 0.324207127f},
std::array<float,2>{0.386875749f, 0.713990808f},
std::array<float,2>{0.892239094f, 0.238136202f},
std::array<float,2>{0.791148901f, 0.610894203f},
std::array<float,2>{0.370391577f, 0.124357924f},
std::array<float,2>{0.113371924f, 0.82011205f},
std::array<float,2>{0.701699078f, 0.417858541f},
std::array<float,2>{0.940530837f, 0.797099054f},
std::array<float,2>{0.472514719f, 0.478933156f},
std::array<float,2>{0.177200302f, 0.562206745f},
std::array<float,2>{0.588172376f, 0.0268134493f},
std::array<float,2>{0.632249177f, 0.669145167f},
std::array<float,2>{0.0386905484f, 0.147465691f},
std::array<float,2>{0.28633064f, 0.940728307f},
std::array<float,2>{0.874769688f, 0.303685695f},
std::array<float,2>{0.574636757f, 0.770065188f},
std::array<float,2>{0.168960944f, 0.445995778f},
std::array<float,2>{0.486608386f, 0.524201572f},
std::array<float,2>{0.959057152f, 0.062314041f},
std::array<float,2>{0.857185483f, 0.637822509f},
std::array<float,2>{0.297998101f, 0.174511731f},
std::array<float,2>{0.0475546569f, 0.970218837f},
std::array<float,2>{0.651165366f, 0.251460373f},
std::array<float,2>{0.889297962f, 0.895781517f},
std::array<float,2>{0.401661336f, 0.355468363f},
std::array<float,2>{0.192819402f, 0.727407455f},
std::array<float,2>{0.523491383f, 0.189236403f},
std::array<float,2>{0.708749235f, 0.587432027f},
std::array<float,2>{0.105226755f, 0.09116631f},
std::array<float,2>{0.346541613f, 0.846660078f},
std::array<float,2>{0.800092518f, 0.390721232f},
std::array<float,2>{0.660712481f, 0.964470744f},
std::array<float,2>{0.0101797832f, 0.292278022f},
std::array<float,2>{0.272730142f, 0.678622484f},
std::array<float,2>{0.841421545f, 0.133667007f},
std::array<float,2>{0.9951545f, 0.544152141f},
std::array<float,2>{0.466675073f, 9.34495765e-05f},
std::array<float,2>{0.153075367f, 0.782062411f},
std::array<float,2>{0.62233299f, 0.497948527f},
std::array<float,2>{0.770144105f, 0.836320281f},
std::array<float,2>{0.327133089f, 0.42592752f},
std::array<float,2>{0.0794551298f, 0.603660703f},
std::array<float,2>{0.731957734f, 0.0995901376f},
std::array<float,2>{0.554699004f, 0.697330832f},
std::array<float,2>{0.239861816f, 0.234027565f},
std::array<float,2>{0.420430124f, 0.922936082f},
std::array<float,2>{0.921117306f, 0.340384781f},
std::array<float,2>{0.645551085f, 0.791976094f},
std::array<float,2>{0.059227623f, 0.485048264f},
std::array<float,2>{0.308087021f, 0.533627391f},
std::array<float,2>{0.846623421f, 0.011377397f},
std::array<float,2>{0.968543708f, 0.684646249f},
std::array<float,2>{0.49839589f, 0.130962431f},
std::array<float,2>{0.161599487f, 0.957788944f},
std::array<float,2>{0.56374979f, 0.286167473f},
std::array<float,2>{0.80639869f, 0.933556557f},
std::array<float,2>{0.352514118f, 0.330282629f},
std::array<float,2>{0.09642452f, 0.688676476f},
std::array<float,2>{0.718121469f, 0.221998885f},
std::array<float,2>{0.517033637f, 0.599994004f},
std::array<float,2>{0.197060183f, 0.104137748f},
std::array<float,2>{0.390929937f, 0.834503233f},
std::array<float,2>{0.876270056f, 0.433734804f},
std::array<float,2>{0.615389347f, 0.982027352f},
std::array<float,2>{0.144322634f, 0.259174705f},
std::array<float,2>{0.460413367f, 0.628368199f},
std::array<float,2>{0.987806499f, 0.184009939f},
std::array<float,2>{0.831559539f, 0.523006797f},
std::array<float,2>{0.277967304f, 0.0504341684f},
std::array<float,2>{0.00488745095f, 0.78119123f},
std::array<float,2>{0.667519867f, 0.442591429f},
std::array<float,2>{0.912232578f, 0.856318831f},
std::array<float,2>{0.412454188f, 0.399953783f},
std::array<float,2>{0.245671809f, 0.578632534f},
std::array<float,2>{0.552481174f, 0.0854717046f},
std::array<float,2>{0.722529352f, 0.724204004f},
std::array<float,2>{0.0881356746f, 0.202346757f},
std::array<float,2>{0.315334022f, 0.903365076f},
std::array<float,2>{0.777878761f, 0.347930282f},
std::array<float,2>{0.537099838f, 0.826113701f},
std::array<float,2>{0.228321552f, 0.408011585f},
std::array<float,2>{0.425401479f, 0.618696988f},
std::array<float,2>{0.937189698f, 0.110100597f},
std::array<float,2>{0.765616715f, 0.704981625f},
std::array<float,2>{0.341500401f, 0.245954171f},
std::array<float,2>{0.0642963573f, 0.919466496f},
std::array<float,2>{0.743426025f, 0.319523305f},
std::array<float,2>{0.973307252f, 0.952874124f},
std::array<float,2>{0.4495956f, 0.310594618f},
std::array<float,2>{0.140227541f, 0.65907234f},
std::array<float,2>{0.603867829f, 0.155908629f},
std::array<float,2>{0.682820082f, 0.549252748f},
std::array<float,2>{0.025225224f, 0.0162701122f},
std::array<float,2>{0.261835039f, 0.807137132f},
std::array<float,2>{0.817501307f, 0.470874012f},
std::array<float,2>{0.687929213f, 0.882607281f},
std::array<float,2>{0.122401461f, 0.374562621f},
std::array<float,2>{0.367020696f, 0.741373718f},
std::array<float,2>{0.781395197f, 0.2042505f},
std::array<float,2>{0.902975738f, 0.572395146f},
std::array<float,2>{0.381277919f, 0.0732032731f},
std::array<float,2>{0.207337335f, 0.865812659f},
std::array<float,2>{0.509489834f, 0.376637399f},
std::array<float,2>{0.861204743f, 0.756615996f},
std::array<float,2>{0.292638481f, 0.461600304f},
std::array<float,2>{0.0402513258f, 0.513098896f},
std::array<float,2>{0.634336352f, 0.0393214785f},
std::array<float,2>{0.585021436f, 0.649725258f},
std::array<float,2>{0.181977183f, 0.171580821f},
std::array<float,2>{0.478212059f, 0.995492637f},
std::array<float,2>{0.952486694f, 0.272239476f},
std::array<float,2>{0.673866689f, 0.829573274f},
std::array<float,2>{0.0199621469f, 0.429865569f},
std::array<float,2>{0.257699251f, 0.594384015f},
std::array<float,2>{0.823548317f, 0.106080778f},
std::array<float,2>{0.981529713f, 0.694663584f},
std::array<float,2>{0.443093985f, 0.226357326f},
std::array<float,2>{0.128612682f, 0.935564399f},
std::array<float,2>{0.600743949f, 0.333898574f},
std::array<float,2>{0.754837096f, 0.954595923f},
std::array<float,2>{0.328770727f, 0.281498164f},
std::array<float,2>{0.0760469735f, 0.680002093f},
std::array<float,2>{0.736206412f, 0.128614113f},
std::array<float,2>{0.53920424f, 0.537534297f},
std::array<float,2>{0.219716311f, 0.0117790168f},
std::array<float,2>{0.435174674f, 0.793674886f},
std::array<float,2>{0.926496923f, 0.489670426f},
std::array<float,2>{0.590242267f, 0.902099848f},
std::array<float,2>{0.172272429f, 0.344515085f},
std::array<float,2>{0.47535041f, 0.720420122f},
std::array<float,2>{0.942697823f, 0.199085146f},
std::array<float,2>{0.868321419f, 0.583529353f},
std::array<float,2>{0.281575233f, 0.0786791816f},
std::array<float,2>{0.031708084f, 0.854348361f},
std::array<float,2>{0.626520395f, 0.402890414f},
std::array<float,2>{0.894693613f, 0.774413705f},
std::array<float,2>{0.386698216f, 0.437837452f},
std::array<float,2>{0.213026553f, 0.516274154f},
std::array<float,2>{0.504694641f, 0.0546547361f},
std::array<float,2>{0.695780694f, 0.632656574f},
std::array<float,2>{0.109830894f, 0.181240857f},
std::array<float,2>{0.372917593f, 0.978326619f},
std::array<float,2>{0.794466615f, 0.265615106f},
std::array<float,2>{0.530265629f, 0.808862925f},
std::array<float,2>{0.188644931f, 0.475355595f},
std::array<float,2>{0.403241575f, 0.551689804f},
std::array<float,2>{0.883762062f, 0.0219528284f},
std::array<float,2>{0.801044285f, 0.663057208f},
std::array<float,2>{0.350721091f, 0.152208462f},
std::array<float,2>{0.108778276f, 0.947708488f},
std::array<float,2>{0.706553817f, 0.305062413f},
std::array<float,2>{0.956058502f, 0.916026592f},
std::array<float,2>{0.490324587f, 0.316189617f},
std::array<float,2>{0.166366518f, 0.710199833f},
std::array<float,2>{0.571226537f, 0.247900352f},
std::array<float,2>{0.655258358f, 0.621469676f},
std::array<float,2>{0.0530704223f, 0.114524603f},
std::array<float,2>{0.303323448f, 0.823233843f},
std::array<float,2>{0.853726983f, 0.413641393f},
std::array<float,2>{0.728198946f, 0.997962594f},
std::array<float,2>{0.0853595808f, 0.267779201f},
std::array<float,2>{0.322543681f, 0.652396083f},
std::array<float,2>{0.767231524f, 0.164172709f},
std::array<float,2>{0.91631639f, 0.508651257f},
std::array<float,2>{0.416914552f, 0.0439745039f},
std::array<float,2>{0.23463212f, 0.75366354f},
std::array<float,2>{0.562422395f, 0.465673476f},
std::array<float,2>{0.83872968f, 0.862994969f},
std::array<float,2>{0.267776728f, 0.382071257f},
std::array<float,2>{0.0149848107f, 0.577926517f},
std::array<float,2>{0.65978843f, 0.0744502619f},
std::array<float,2>{0.61959058f, 0.736817956f},
std::array<float,2>{0.151229292f, 0.207686514f},
std::array<float,2>{0.464392185f, 0.876664102f},
std::array<float,2>{0.99909693f, 0.370808899f},
std::array<float,2>{0.714662015f, 0.759447813f},
std::array<float,2>{0.0993565768f, 0.456802577f},
std::array<float,2>{0.356358409f, 0.505673468f},
std::array<float,2>{0.809356391f, 0.0356289074f},
std::array<float,2>{0.880592287f, 0.64214623f},
std::array<float,2>{0.395092666f, 0.156870663f},
std::array<float,2>{0.202578798f, 0.988433242f},
std::array<float,2>{0.522740424f, 0.280511171f},
std::array<float,2>{0.849702239f, 0.886967599f},
std::array<float,2>{0.309556007f, 0.363260955f},
std::array<float,2>{0.0576628298f, 0.743007004f},
std::array<float,2>{0.643915415f, 0.213093534f},
std::array<float,2>{0.568943799f, 0.569050431f},
std::array<float,2>{0.156859711f, 0.0638007373f},
std::array<float,2>{0.492836207f, 0.86841172f},
std::array<float,2>{0.961813152f, 0.386786073f},
std::array<float,2>{0.547710717f, 0.944612145f},
std::array<float,2>{0.246189848f, 0.299137533f},
std::array<float,2>{0.408726752f, 0.666165888f},
std::array<float,2>{0.908110797f, 0.142643988f},
std::array<float,2>{0.776430905f, 0.556998849f},
std::array<float,2>{0.319481939f, 0.0305903666f},
std::array<float,2>{0.0932111144f, 0.804620564f},
std::array<float,2>{0.723504007f, 0.481567442f},
std::array<float,2>{0.990694702f, 0.816082001f},
std::array<float,2>{0.454566926f, 0.418718994f},
std::array<float,2>{0.145170182f, 0.616671443f},
std::array<float,2>{0.612266243f, 0.119388402f},
std::array<float,2>{0.668930233f, 0.71653384f},
std::array<float,2>{0.00222064485f, 0.242144898f},
std::array<float,2>{0.274760604f, 0.911581814f},
std::array<float,2>{0.835888207f, 0.325662374f},
std::array<float,2>{0.608052194f, 0.849807143f},
std::array<float,2>{0.136184856f, 0.395561039f},
std::array<float,2>{0.44896549f, 0.591249943f},
std::array<float,2>{0.971541047f, 0.0884256661f},
std::array<float,2>{0.816218257f, 0.733081222f},
std::array<float,2>{0.260879248f, 0.193663239f},
std::array<float,2>{0.0294196848f, 0.891718566f},
std::array<float,2>{0.686807632f, 0.356515139f},
std::array<float,2>{0.933455229f, 0.975714743f},
std::array<float,2>{0.427673072f, 0.254549801f},
std::array<float,2>{0.232278422f, 0.636588931f},
std::array<float,2>{0.53212887f, 0.179425314f},
std::array<float,2>{0.749278963f, 0.530413806f},
std::array<float,2>{0.0672055483f, 0.0568311363f},
std::array<float,2>{0.338478386f, 0.766716599f},
std::array<float,2>{0.75883311f, 0.450731426f},
std::array<float,2>{0.639141202f, 0.927557528f},
std::array<float,2>{0.0456320085f, 0.338739574f},
std::array<float,2>{0.295869589f, 0.700163245f},
std::array<float,2>{0.866346657f, 0.229287446f},
std::array<float,2>{0.949205279f, 0.607958674f},
std::array<float,2>{0.481798977f, 0.0962074324f},
std::array<float,2>{0.186273322f, 0.839887798f},
std::array<float,2>{0.578612745f, 0.424193263f},
std::array<float,2>{0.78702724f, 0.787103951f},
std::array<float,2>{0.36278823f, 0.492670238f},
std::array<float,2>{0.119559765f, 0.539989829f},
std::array<float,2>{0.693315268f, 0.0046299831f},
std::array<float,2>{0.514815092f, 0.673875272f},
std::array<float,2>{0.205515414f, 0.139870659f},
std::array<float,2>{0.375420272f, 0.965837538f},
std::array<float,2>{0.89896059f, 0.293829739f},
std::array<float,2>{0.700931668f, 0.81733501f},
std::array<float,2>{0.116427578f, 0.415668756f},
std::array<float,2>{0.368980825f, 0.612339795f},
std::array<float,2>{0.789105833f, 0.122638054f},
std::array<float,2>{0.893305302f, 0.711005211f},
std::array<float,2>{0.389729202f, 0.235872135f},
std::array<float,2>{0.215071201f, 0.909937561f},
std::array<float,2>{0.500161409f, 0.32204774f},
std::array<float,2>{0.873042285f, 0.939030051f},
std::array<float,2>{0.287960976f, 0.301644027f},
std::array<float,2>{0.0358673185f, 0.671378314f},
std::array<float,2>{0.630349398f, 0.146175504f},
std::array<float,2>{0.587306559f, 0.558757722f},
std::array<float,2>{0.178340793f, 0.0239162408f},
std::array<float,2>{0.47054857f, 0.799932957f},
std::array<float,2>{0.939103484f, 0.477122426f},
std::array<float,2>{0.546239197f, 0.884565413f},
std::array<float,2>{0.226040348f, 0.365067989f},
std::array<float,2>{0.431836605f, 0.748640478f},
std::array<float,2>{0.924788654f, 0.217266575f},
std::array<float,2>{0.753688693f, 0.564987183f},
std::array<float,2>{0.333921045f, 0.0664388612f},
std::array<float,2>{0.071862489f, 0.873550892f},
std::array<float,2>{0.739008307f, 0.383413613f},
std::array<float,2>{0.98036474f, 0.762371182f},
std::array<float,2>{0.438904107f, 0.460348785f},
std::array<float,2>{0.130038813f, 0.500144064f},
std::array<float,2>{0.595626056f, 0.0320034996f},
std::array<float,2>{0.678837597f, 0.647156715f},
std::array<float,2>{0.0165156648f, 0.163544685f},
std::array<float,2>{0.25356099f, 0.988128603f},
std::array<float,2>{0.825527608f, 0.273841947f},
std::array<float,2>{0.623055875f, 0.783663392f},
std::array<float,2>{0.154420689f, 0.498656034f},
std::array<float,2>{0.467475593f, 0.545976639f},
std::array<float,2>{0.992899954f, 0.0020164547f},
std::array<float,2>{0.84217912f, 0.67646867f},
std::array<float,2>{0.270790428f, 0.13533397f},
std::array<float,2>{0.00912102312f, 0.961149275f},
std::array<float,2>{0.663345635f, 0.289097339f},
std::array<float,2>{0.919565976f, 0.925515652f},
std::array<float,2>{0.419385135f, 0.343010217f},
std::array<float,2>{0.241596192f, 0.695408463f},
std::array<float,2>{0.557765305f, 0.231714487f},
std::array<float,2>{0.733453691f, 0.60332644f},
std::array<float,2>{0.0801802799f, 0.10072194f},
std::array<float,2>{0.324471623f, 0.839040577f},
std::array<float,2>{0.772469103f, 0.428824663f},
std::array<float,2>{0.649202228f, 0.972621381f},
std::array<float,2>{0.0495392866f, 0.25238803f},
std::array<float,2>{0.2995978f, 0.639142454f},
std::array<float,2>{0.858391881f, 0.173602268f},
std::array<float,2>{0.957587004f, 0.52541554f},
std::array<float,2>{0.485799938f, 0.059499938f},
std::array<float,2>{0.170039818f, 0.772658885f},
std::array<float,2>{0.576911926f, 0.447887182f},
std::array<float,2>{0.797281623f, 0.843842149f},
std::array<float,2>{0.34524563f, 0.393629104f},
std::array<float,2>{0.102058031f, 0.589600384f},
std::array<float,2>{0.710844636f, 0.0921963826f},
std::array<float,2>{0.526611805f, 0.729635596f},
std::array<float,2>{0.194470406f, 0.191249982f},
std::array<float,2>{0.400103956f, 0.898272276f},
std::array<float,2>{0.887788594f, 0.352978289f},
std::array<float,2>{0.6660074f, 0.778445005f},
std::array<float,2>{0.00691555347f, 0.445084006f},
std::array<float,2>{0.280349433f, 0.52096802f},
std::array<float,2>{0.828383148f, 0.047766123f},
std::array<float,2>{0.985700488f, 0.625540376f},
std::array<float,2>{0.457996219f, 0.186154887f},
std::array<float,2>{0.141473725f, 0.982630312f},
std::array<float,2>{0.614206791f, 0.261138111f},
std::array<float,2>{0.779918611f, 0.904378533f},
std::array<float,2>{0.313349694f, 0.350882858f},
std::array<float,2>{0.0862972364f, 0.724835396f},
std::array<float,2>{0.720170617f, 0.199327692f},
std::array<float,2>{0.552950799f, 0.580579579f},
std::array<float,2>{0.242235124f, 0.0826098919f},
std::array<float,2>{0.411327481f, 0.858966887f},
std::array<float,2>{0.911086738f, 0.40051347f},
std::array<float,2>{0.565314054f, 0.960932434f},
std::array<float,2>{0.1624787f, 0.28735745f},
std::array<float,2>{0.497148901f, 0.686667323f},
std::array<float,2>{0.964921236f, 0.129597127f},
std::array<float,2>{0.845022619f, 0.531716406f},
std::array<float,2>{0.305394918f, 0.00928848889f},
std::array<float,2>{0.0609371737f, 0.790794253f},
std::array<float,2>{0.646990359f, 0.487766832f},
std::array<float,2>{0.878228366f, 0.833351612f},
std::array<float,2>{0.394506097f, 0.43578881f},
std::array<float,2>{0.198009387f, 0.59936285f},
std::array<float,2>{0.518696249f, 0.103464283f},
std::array<float,2>{0.715889275f, 0.689763546f},
std::array<float,2>{0.0954785794f, 0.220466629f},
std::array<float,2>{0.354794145f, 0.93163687f},
std::array<float,2>{0.807037473f, 0.328692555f},
std::array<float,2>{0.510267079f, 0.864545345f},
std::array<float,2>{0.209554046f, 0.377356172f},
std::array<float,2>{0.380639344f, 0.571147978f},
std::array<float,2>{0.905367315f, 0.0713039786f},
std::array<float,2>{0.784797966f, 0.738395095f},
std::array<float,2>{0.365096778f, 0.205549315f},
std::array<float,2>{0.124264777f, 0.880060196f},
std::array<float,2>{0.690830469f, 0.372985095f},
std::array<float,2>{0.950446546f, 0.992378652f},
std::array<float,2>{0.478605986f, 0.270769656f},
std::array<float,2>{0.180864066f, 0.651885211f},
std::array<float,2>{0.583023846f, 0.169374093f},
std::array<float,2>{0.636268616f, 0.514008164f},
std::array<float,2>{0.0424204431f, 0.042520605f},
std::array<float,2>{0.290092438f, 0.754173815f},
std::array<float,2>{0.861542702f, 0.463441372f},
std::array<float,2>{0.74557054f, 0.921116292f},
std::array<float,2>{0.066031456f, 0.316845745f},
std::array<float,2>{0.342106014f, 0.70698607f},
std::array<float,2>{0.762950242f, 0.243241936f},
std::array<float,2>{0.935499072f, 0.619720638f},
std::array<float,2>{0.423464298f, 0.112190694f},
std::array<float,2>{0.229734972f, 0.826615572f},
std::array<float,2>{0.538378358f, 0.409926087f},
std::array<float,2>{0.819696009f, 0.806102693f},
std::array<float,2>{0.265548885f, 0.469064057f},
std::array<float,2>{0.0272265058f, 0.548211098f},
std::array<float,2>{0.679870546f, 0.0182939731f},
std::array<float,2>{0.602770269f, 0.65797925f},
std::array<float,2>{0.138137221f, 0.152908742f},
std::array<float,2>{0.452127665f, 0.950157642f},
std::array<float,2>{0.976227343f, 0.310166985f},
std::array<float,2>{0.627492785f, 0.853389263f},
std::array<float,2>{0.0339977741f, 0.405093282f},
std::array<float,2>{0.28369531f, 0.584953308f},
std::array<float,2>{0.870635092f, 0.0802485272f},
std::array<float,2>{0.94458878f, 0.721798718f},
std::array<float,2>{0.474225193f, 0.196779847f},
std::array<float,2>{0.175472826f, 0.899852514f},
std::array<float,2>{0.591881156f, 0.346965045f},
std::array<float,2>{0.796006262f, 0.978575528f},
std::array<float,2>{0.373197794f, 0.262602955f},
std::array<float,2>{0.113114826f, 0.630533814f},
std::array<float,2>{0.699031413f, 0.182869092f},
std::array<float,2>{0.506596744f, 0.518664777f},
std::array<float,2>{0.212312445f, 0.0517529063f},
std::array<float,2>{0.383796304f, 0.776702166f},
std::array<float,2>{0.898078799f, 0.440208167f},
std::array<float,2>{0.597682595f, 0.934841871f},
std::array<float,2>{0.126649931f, 0.335719049f},
std::array<float,2>{0.445185602f, 0.691777766f},
std::array<float,2>{0.982483089f, 0.223003849f},
std::array<float,2>{0.820883572f, 0.59577471f},
std::array<float,2>{0.254704893f, 0.108561993f},
std::array<float,2>{0.0222875793f, 0.830135345f},
std::array<float,2>{0.672581732f, 0.433226079f},
std::array<float,2>{0.929407179f, 0.795727611f},
std::array<float,2>{0.436597794f, 0.491823614f},
std::array<float,2>{0.222505093f, 0.536220551f},
std::array<float,2>{0.542365491f, 0.0146964323f},
std::array<float,2>{0.738185227f, 0.682436347f},
std::array<float,2>{0.077613309f, 0.126571536f},
std::array<float,2>{0.331157982f, 0.955358386f},
std::array<float,2>{0.756452143f, 0.283735067f},
std::array<float,2>{0.559529305f, 0.750910163f},
std::array<float,2>{0.237463802f, 0.467932791f},
std::array<float,2>{0.414498717f, 0.511510551f},
std::array<float,2>{0.915806413f, 0.0449930429f},
std::array<float,2>{0.768402874f, 0.654515743f},
std::array<float,2>{0.320981711f, 0.167344972f},
std::array<float,2>{0.0822063759f, 0.999209404f},
std::array<float,2>{0.73015815f, 0.266749769f},
std::array<float,2>{0.997493327f, 0.878315628f},
std::array<float,2>{0.461429685f, 0.368283808f},
std::array<float,2>{0.150188029f, 0.735886812f},
std::array<float,2>{0.617483377f, 0.209409371f},
std::array<float,2>{0.657765746f, 0.575760305f},
std::array<float,2>{0.012137223f, 0.0767488256f},
std::array<float,2>{0.266090333f, 0.859537125f},
std::array<float,2>{0.836987793f, 0.379186511f},
std::array<float,2>{0.703276992f, 0.946682155f},
std::array<float,2>{0.106079355f, 0.308468461f},
std::array<float,2>{0.349258095f, 0.661935568f},
std::array<float,2>{0.803849936f, 0.149439469f},
std::array<float,2>{0.885770559f, 0.553823054f},
std::array<float,2>{0.40569374f, 0.0210187417f},
std::array<float,2>{0.189702779f, 0.811231971f},
std::array<float,2>{0.528370082f, 0.473615915f},
std::array<float,2>{0.851660669f, 0.821761131f},
std::array<float,2>{0.30095917f, 0.410759419f},
std::array<float,2>{0.0508881509f, 0.623761475f},
std::array<float,2>{0.654134154f, 0.116252579f},
std::array<float,2>{0.573081136f, 0.708576322f},
std::array<float,2>{0.165794119f, 0.24903664f},
std::array<float,2>{0.488531053f, 0.915641606f},
std::array<float,2>{0.953321636f, 0.313219905f},
std::array<float,2>{0.726282716f, 0.801768959f},
std::array<float,2>{0.0904861316f, 0.483549058f},
std::array<float,2>{0.317462981f, 0.55524683f},
std::array<float,2>{0.775132835f, 0.0286071543f},
std::array<float,2>{0.909399629f, 0.665004194f},
std::array<float,2>{0.407163769f, 0.142373696f},
std::array<float,2>{0.249481797f, 0.942595124f},
std::array<float,2>{0.549648643f, 0.29689768f},
std::array<float,2>{0.832384348f, 0.912850618f},
std::array<float,2>{0.275715709f, 0.327429324f},
std::array<float,2>{7.40611576e-05f, 0.716881156f},
std::array<float,2>{0.671554148f, 0.23828809f},
std::array<float,2>{0.610496759f, 0.613395929f},
std::array<float,2>{0.148020655f, 0.117307194f},
std::array<float,2>{0.455286533f, 0.812567115f},
std::array<float,2>{0.989878237f, 0.420534819f},
std::array<float,2>{0.520991981f, 0.991084754f},
std::array<float,2>{0.200345367f, 0.278986067f},
std::array<float,2>{0.397318661f, 0.643920958f},
std::array<float,2>{0.882721186f, 0.159806192f},
std::array<float,2>{0.812371254f, 0.506451666f},
std::array<float,2>{0.359024346f, 0.0383158922f},
std::array<float,2>{0.100464948f, 0.760405123f},
std::array<float,2>{0.712863863f, 0.453139871f},
std::array<float,2>{0.964558184f, 0.869679332f},
std::array<float,2>{0.495242983f, 0.38920486f},
std::array<float,2>{0.159592673f, 0.567803323f},
std::array<float,2>{0.568284869f, 0.0653286576f},
std::array<float,2>{0.641883373f, 0.74495858f},
std::array<float,2>{0.0560550913f, 0.2120599f},
std::array<float,2>{0.311846375f, 0.889588296f},
std::array<float,2>{0.848961473f, 0.359794527f},
std::array<float,2>{0.58079499f, 0.841855824f},
std::array<float,2>{0.183673561f, 0.423387736f},
std::array<float,2>{0.48431465f, 0.606099308f},
std::array<float,2>{0.945497453f, 0.0946077853f},
std::array<float,2>{0.864966571f, 0.702841878f},
std::array<float,2>{0.294436932f, 0.227999806f},
std::array<float,2>{0.0432664342f, 0.929003894f},
std::array<float,2>{0.638345003f, 0.337344438f},
std::array<float,2>{0.90213716f, 0.967220366f},
std::array<float,2>{0.377196968f, 0.296384335f},
std::array<float,2>{0.204057202f, 0.672865987f},
std::array<float,2>{0.512922347f, 0.136774063f},
std::array<float,2>{0.693929732f, 0.541496217f},
std::array<float,2>{0.118445173f, 0.00677893171f},
std::array<float,2>{0.361244977f, 0.787638903f},
std::array<float,2>{0.788981855f, 0.495930225f},
std::array<float,2>{0.684443474f, 0.893058538f},
std::array<float,2>{0.0276519395f, 0.358644038f},
std::array<float,2>{0.259352028f, 0.730753362f},
std::array<float,2>{0.814049184f, 0.191492543f},
std::array<float,2>{0.970574021f, 0.593285263f},
std::array<float,2>{0.445939213f, 0.0870131999f},
std::array<float,2>{0.134035274f, 0.848467886f},
std::array<float,2>{0.606927276f, 0.397610575f},
std::array<float,2>{0.75989157f, 0.768097281f},
std::array<float,2>{0.337536812f, 0.452233821f},
std::array<float,2>{0.0693174452f, 0.527999222f},
std::array<float,2>{0.746186078f, 0.0560315326f},
std::array<float,2>{0.534547269f, 0.633921444f},
std::array<float,2>{0.234249145f, 0.17595157f},
std::array<float,2>{0.42814219f, 0.973000944f},
std::array<float,2>{0.930319905f, 0.256563038f},
std::array<float,2>{0.709879518f, 0.846887112f},
std::array<float,2>{0.103153199f, 0.39174518f},
std::array<float,2>{0.344041467f, 0.586132765f},
std::array<float,2>{0.798806846f, 0.0903322324f},
std::array<float,2>{0.886820734f, 0.728427172f},
std::array<float,2>{0.398578405f, 0.188180864f},
std::array<float,2>{0.193645f, 0.894773185f},
std::array<float,2>{0.526284158f, 0.353850991f},
std::array<float,2>{0.858439267f, 0.969304681f},
std::array<float,2>{0.30005607f, 0.250005424f},
std::array<float,2>{0.050461594f, 0.637684643f},
std::array<float,2>{0.650186062f, 0.175607011f},
std::array<float,2>{0.577152014f, 0.524646699f},
std::array<float,2>{0.171656847f, 0.0614202097f},
std::array<float,2>{0.484823495f, 0.770760655f},
std::array<float,2>{0.958829939f, 0.44714886f},
std::array<float,2>{0.556741297f, 0.922332346f},
std::array<float,2>{0.241156146f, 0.340880811f},
std::array<float,2>{0.418286055f, 0.698457599f},
std::array<float,2>{0.918725193f, 0.232918471f},
std::array<float,2>{0.771800578f, 0.605100274f},
std::array<float,2>{0.325292319f, 0.0983724073f},
std::array<float,2>{0.0811533779f, 0.837797165f},
std::array<float,2>{0.732843816f, 0.427331567f},
std::array<float,2>{0.993661225f, 0.78292352f},
std::array<float,2>{0.468182921f, 0.496424079f},
std::array<float,2>{0.156196222f, 0.543939769f},
std::array<float,2>{0.624488771f, 0.0011933255f},
std::array<float,2>{0.662782013f, 0.678993285f},
std::array<float,2>{0.00794896856f, 0.133878544f},
std::array<float,2>{0.269668907f, 0.963321686f},
std::array<float,2>{0.843265533f, 0.29163304f},
std::array<float,2>{0.594532669f, 0.765083194f},
std::array<float,2>{0.129782289f, 0.457148254f},
std::array<float,2>{0.437641442f, 0.503208518f},
std::array<float,2>{0.978914678f, 0.0342923142f},
std::array<float,2>{0.824502289f, 0.644758403f},
std::array<float,2>{0.252843797f, 0.161478743f},
std::array<float,2>{0.0168712344f, 0.986028731f},
std::array<float,2>{0.678665161f, 0.275483102f},
std::array<float,2>{0.925420642f, 0.885258615f},
std::array<float,2>{0.432689339f, 0.366094589f},
std::array<float,2>{0.225235149f, 0.747245967f},
std::array<float,2>{0.545703292f, 0.214868292f},
std::array<float,2>{0.739699304f, 0.562968791f},
std::array<float,2>{0.0712662488f, 0.0694699213f},
std::array<float,2>{0.332986116f, 0.8726511f},
std::array<float,2>{0.752792299f, 0.3863644f},
std::array<float,2>{0.629193246f, 0.939690828f},
std::array<float,2>{0.0368631259f, 0.304372489f},
std::array<float,2>{0.288752109f, 0.668088138f},
std::array<float,2>{0.8712942f, 0.14710851f},
std::array<float,2>{0.937955558f, 0.561039627f},
std::array<float,2>{0.469703227f, 0.0259992145f},
std::array<float,2>{0.179076001f, 0.79832375f},
std::array<float,2>{0.585983813f, 0.480452538f},
std::array<float,2>{0.790305853f, 0.818883002f},
std::array<float,2>{0.367896646f, 0.41683358f},
std::array<float,2>{0.115460239f, 0.610129774f},
std::array<float,2>{0.699619353f, 0.123982243f},
std::array<float,2>{0.501367092f, 0.713019073f},
std::array<float,2>{0.216684356f, 0.236979768f},
std::array<float,2>{0.389500171f, 0.906615198f},
std::array<float,2>{0.894171f, 0.322738886f},
std::array<float,2>{0.681307912f, 0.807813704f},
std::array<float,2>{0.0260798149f, 0.471975535f},
std::array<float,2>{0.26426211f, 0.550351024f},
std::array<float,2>{0.818787396f, 0.017086586f},
std::array<float,2>{0.974910319f, 0.659699082f},
std::array<float,2>{0.452979088f, 0.154457048f},
std::array<float,2>{0.137187406f, 0.952023149f},
std::array<float,2>{0.601603031f, 0.312269598f},
std::array<float,2>{0.762465596f, 0.918587327f},
std::array<float,2>{0.34323287f, 0.318640858f},
std::array<float,2>{0.0644747466f, 0.70369041f},
std::array<float,2>{0.744710863f, 0.24496378f},
std::array<float,2>{0.5371961f, 0.617297649f},
std::array<float,2>{0.229284972f, 0.111263067f},
std::array<float,2>{0.422321528f, 0.824824989f},
std::array<float,2>{0.933700085f, 0.406666309f},
std::array<float,2>{0.582170844f, 0.994718909f},
std::array<float,2>{0.180570841f, 0.272960037f},
std::array<float,2>{0.480367631f, 0.649410069f},
std::array<float,2>{0.950040817f, 0.170833617f},
std::array<float,2>{0.863208771f, 0.512500405f},
std::array<float,2>{0.289323986f, 0.0408848599f},
std::array<float,2>{0.0414901227f, 0.756902635f},
std::array<float,2>{0.635493159f, 0.462098449f},
std::array<float,2>{0.904979527f, 0.866330624f},
std::array<float,2>{0.378974169f, 0.375366271f},
std::array<float,2>{0.210927382f, 0.573832929f},
std::array<float,2>{0.511190414f, 0.073290281f},
std::array<float,2>{0.689927816f, 0.740607381f},
std::array<float,2>{0.123743676f, 0.203781694f},
std::array<float,2>{0.363979906f, 0.881625235f},
std::array<float,2>{0.784101725f, 0.373811632f},
std::array<float,2>{0.517831326f, 0.835384488f},
std::array<float,2>{0.199138448f, 0.435493022f},
std::array<float,2>{0.392587811f, 0.600996554f},
std::array<float,2>{0.877180099f, 0.104860015f},
std::array<float,2>{0.807984352f, 0.687650204f},
std::array<float,2>{0.35425356f, 0.221035138f},
std::array<float,2>{0.0943712667f, 0.932155669f},
std::array<float,2>{0.715022147f, 0.331773579f},
std::array<float,2>{0.966446936f, 0.958485007f},
std::array<float,2>{0.496309102f, 0.286067098f},
std::array<float,2>{0.163626447f, 0.684126735f},
std::array<float,2>{0.566395879f, 0.132521972f},
std::array<float,2>{0.647625089f, 0.534859776f},
std::array<float,2>{0.0622470342f, 0.0104410527f},
std::array<float,2>{0.306294143f, 0.792625964f},
std::array<float,2>{0.844005704f, 0.485875279f},
std::array<float,2>{0.719234645f, 0.90325743f},
std::array<float,2>{0.0872490332f, 0.349018574f},
std::array<float,2>{0.313659102f, 0.722980738f},
std::array<float,2>{0.780683517f, 0.201951727f},
std::array<float,2>{0.911914825f, 0.579774678f},
std::array<float,2>{0.410274833f, 0.0842482969f},
std::array<float,2>{0.243458867f, 0.856610537f},
std::array<float,2>{0.554286718f, 0.399408072f},
std::array<float,2>{0.82928282f, 0.779823661f},
std::array<float,2>{0.279437989f, 0.441424757f},
std::array<float,2>{0.00590065448f, 0.52230823f},
std::array<float,2>{0.664527774f, 0.0490003787f},
std::array<float,2>{0.615130305f, 0.627741873f},
std::array<float,2>{0.141771078f, 0.184726715f},
std::array<float,2>{0.458066672f, 0.981360793f},
std::array<float,2>{0.98441565f, 0.258517355f},
std::array<float,2>{0.653301775f, 0.823533237f},
std::array<float,2>{0.052316457f, 0.412906826f},
std::array<float,2>{0.302447677f, 0.622796237f},
std::array<float,2>{0.852561593f, 0.113796167f},
std::array<float,2>{0.954964221f, 0.709578574f},
std::array<float,2>{0.489705533f, 0.246252358f},
std::array<float,2>{0.164908901f, 0.917471886f},
std::array<float,2>{0.573907614f, 0.315013528f},
std::array<float,2>{0.803597689f, 0.949059963f},
std::array<float,2>{0.348590732f, 0.306441396f},
std::array<float,2>{0.10716778f, 0.663138866f},
std::array<float,2>{0.704551816f, 0.150472403f},
std::array<float,2>{0.528080106f, 0.552277982f},
std::array<float,2>{0.190525725f, 0.0227842014f},
std::array<float,2>{0.404641092f, 0.810410976f},
std::array<float,2>{0.885008454f, 0.47619763f},
std::array<float,2>{0.618686199f, 0.875850379f},
std::array<float,2>{0.149272114f, 0.369436204f},
std::array<float,2>{0.462146431f, 0.73752284f},
std::array<float,2>{0.996782362f, 0.20898369f},
std::array<float,2>{0.836801291f, 0.5762586f},
std::array<float,2>{0.266786247f, 0.076150462f},
std::array<float,2>{0.0129924919f, 0.861985028f},
std::array<float,2>{0.656276822f, 0.381551772f},
std::array<float,2>{0.91413945f, 0.752601743f},
std::array<float,2>{0.415217042f, 0.466474593f},
std::array<float,2>{0.237031579f, 0.509588063f},
std::array<float,2>{0.559609652f, 0.0430533551f},
std::array<float,2>{0.729084194f, 0.653363824f},
std::array<float,2>{0.0836466327f, 0.165176481f},
std::array<float,2>{0.322129786f, 0.997023463f},
std::array<float,2>{0.769318521f, 0.269191861f},
std::array<float,2>{0.541817367f, 0.794646919f},
std::array<float,2>{0.221186459f, 0.489250422f},
std::array<float,2>{0.435798526f, 0.538830519f},
std::array<float,2>{0.927978456f, 0.0129011367f},
std::array<float,2>{0.757616699f, 0.680717468f},
std::array<float,2>{0.330831677f, 0.127719268f},
std::array<float,2>{0.0766040236f, 0.953615248f},
std::array<float,2>{0.736879289f, 0.282283098f},
std::array<float,2>{0.984091163f, 0.936598539f},
std::array<float,2>{0.443436205f, 0.33258003f},
std::array<float,2>{0.125208378f, 0.694247067f},
std::array<float,2>{0.599423707f, 0.224997774f},
std::array<float,2>{0.673683584f, 0.594805717f},
std::array<float,2>{0.0226760656f, 0.107138373f},
std::array<float,2>{0.255815148f, 0.828661263f},
std::array<float,2>{0.821775198f, 0.430985272f},
std::array<float,2>{0.69733268f, 0.976927757f},
std::array<float,2>{0.111706711f, 0.263885587f},
std::array<float,2>{0.374507904f, 0.631175995f},
std::array<float,2>{0.795205295f, 0.180600867f},
std::array<float,2>{0.897297025f, 0.517543912f},
std::array<float,2>{0.383419484f, 0.0531425588f},
std::array<float,2>{0.211210549f, 0.775132775f},
std::array<float,2>{0.507774889f, 0.438621432f},
std::array<float,2>{0.869556069f, 0.854812264f},
std::array<float,2>{0.284709156f, 0.403686076f},
std::array<float,2>{0.0346279889f, 0.582876861f},
std::array<float,2>{0.628085196f, 0.0797532722f},
std::array<float,2>{0.593735278f, 0.719431102f},
std::array<float,2>{0.174085766f, 0.197282657f},
std::array<float,2>{0.472678334f, 0.900509357f},
std::array<float,2>{0.944307268f, 0.345508039f},
std::array<float,2>{0.747126698f, 0.766130865f},
std::array<float,2>{0.0699202567f, 0.449486941f},
std::array<float,2>{0.336205155f, 0.529863596f},
std::array<float,2>{0.761381388f, 0.0579001643f},
std::array<float,2>{0.931275904f, 0.635430396f},
std::array<float,2>{0.429207891f, 0.178031385f},
std::array<float,2>{0.233103737f, 0.975082397f},
std::array<float,2>{0.533874512f, 0.255143613f},
std::array<float,2>{0.81253165f, 0.890770972f},
std::array<float,2>{0.257990062f, 0.356353134f},
std::array<float,2>{0.0289920904f, 0.733716607f},
std::array<float,2>{0.684859753f, 0.194578841f},
std::array<float,2>{0.605726838f, 0.590209126f},
std::array<float,2>{0.13356635f, 0.089687556f},
std::array<float,2>{0.446339697f, 0.851370215f},
std::array<float,2>{0.969294965f, 0.394902647f},
std::array<float,2>{0.511928558f, 0.965508103f},
std::array<float,2>{0.204238772f, 0.294878244f},
std::array<float,2>{0.378415465f, 0.675654411f},
std::array<float,2>{0.900668859f, 0.138876051f},
std::array<float,2>{0.787626565f, 0.540440917f},
std::array<float,2>{0.359424353f, 0.00490310136f},
std::array<float,2>{0.118000045f, 0.785511553f},
std::array<float,2>{0.695174098f, 0.493465334f},
std::array<float,2>{0.946590006f, 0.841122925f},
std::array<float,2>{0.482505679f, 0.425352037f},
std::array<float,2>{0.185190171f, 0.608534217f},
std::array<float,2>{0.581990778f, 0.0975112244f},
std::array<float,2>{0.637691021f, 0.700286388f},
std::array<float,2>{0.0439668745f, 0.230078608f},
std::array<float,2>{0.29314974f, 0.92630291f},
std::array<float,2>{0.863473892f, 0.338965327f},
std::array<float,2>{0.56684798f, 0.868110597f},
std::array<float,2>{0.158773571f, 0.388052702f},
std::array<float,2>{0.495098144f, 0.569533467f},
std::array<float,2>{0.963319898f, 0.0626612455f},
std::array<float,2>{0.848172247f, 0.743399322f},
std::array<float,2>{0.311242312f, 0.214502111f},
std::array<float,2>{0.0549196154f, 0.888356447f},
std::array<float,2>{0.640632629f, 0.362000674f},
std::array<float,2>{0.881822467f, 0.9894014f},
std::array<float,2>{0.398148268f, 0.279916704f},
std::array<float,2>{0.199373171f, 0.641450346f},
std::array<float,2>{0.52038008f, 0.15819107f},
std::array<float,2>{0.711087823f, 0.504040599f},
std::array<float,2>{0.101327181f, 0.036405798f},
std::array<float,2>{0.358145833f, 0.758333981f},
std::array<float,2>{0.810932517f, 0.456054479f},
std::array<float,2>{0.670315087f, 0.91024518f},
std::array<float,2>{0.00100945227f, 0.32451427f},
std::array<float,2>{0.276707977f, 0.71571523f},
std::array<float,2>{0.833854198f, 0.241137683f},
std::array<float,2>{0.989254594f, 0.615321875f},
std::array<float,2>{0.456321388f, 0.120322399f},
std::array<float,2>{0.147224158f, 0.814907372f},
std::array<float,2>{0.609990597f, 0.419557899f},
std::array<float,2>{0.773806572f, 0.803645551f},
std::array<float,2>{0.317336231f, 0.481235236f},
std::array<float,2>{0.0916919187f, 0.557826698f},
std::array<float,2>{0.724674106f, 0.0302112624f},
std::array<float,2>{0.550434828f, 0.66718483f},
std::array<float,2>{0.248571426f, 0.144042805f},
std::array<float,2>{0.407764912f, 0.944214046f},
std::array<float,2>{0.908438623f, 0.300566554f},
std::array<float,2>{0.731030881f, 0.837923944f},
std::array<float,2>{0.0788442865f, 0.428558677f},
std::array<float,2>{0.327648401f, 0.601801634f},
std::array<float,2>{0.770789206f, 0.0996883661f},
std::array<float,2>{0.920230806f, 0.696293831f},
std::array<float,2>{0.420999825f, 0.23080495f},
std::array<float,2>{0.238350838f, 0.924262285f},
std::array<float,2>{0.556034207f, 0.341815263f},
std::array<float,2>{0.84063071f, 0.962725639f},
std::array<float,2>{0.27176702f, 0.290397763f},
std::array<float,2>{0.0115069281f, 0.677262485f},
std::array<float,2>{0.661840439f, 0.136223659f},
std::array<float,2>{0.622026563f, 0.545105219f},
std::array<float,2>{0.153878063f, 0.00301296241f},
std::array<float,2>{0.465545833f, 0.784567714f},
std::array<float,2>{0.994893193f, 0.499161601f},
std::array<float,2>{0.524697185f, 0.897125363f},
std::array<float,2>{0.1921321f, 0.352308601f},
std::array<float,2>{0.401043028f, 0.729003072f},
std::array<float,2>{0.890599728f, 0.189523712f},
std::array<float,2>{0.798952341f, 0.588544011f},
std::array<float,2>{0.347563595f, 0.0928224996f},
std::array<float,2>{0.104288995f, 0.845260799f},
std::array<float,2>{0.707944512f, 0.393051684f},
std::array<float,2>{0.960682869f, 0.771569252f},
std::array<float,2>{0.487669349f, 0.448578656f},
std::array<float,2>{0.168165013f, 0.526796699f},
std::array<float,2>{0.576149106f, 0.0598312095f},
std::array<float,2>{0.65167439f, 0.64051187f},
std::array<float,2>{0.0479104742f, 0.172020674f},
std::array<float,2>{0.297844559f, 0.971035123f},
std::array<float,2>{0.85633862f, 0.253478438f},
std::array<float,2>{0.588907599f, 0.79906702f},
std::array<float,2>{0.176744223f, 0.47774598f},
std::array<float,2>{0.471221119f, 0.560280859f},
std::array<float,2>{0.939733088f, 0.0247956011f},
std::array<float,2>{0.873443305f, 0.670047283f},
std::array<float,2>{0.285232008f, 0.145289987f},
std::array<float,2>{0.0379109383f, 0.938273251f},
std::array<float,2>{0.631544888f, 0.302159995f},
std::array<float,2>{0.891115904f, 0.90843457f},
std::array<float,2>{0.388534456f, 0.321070671f},
std::array<float,2>{0.218421713f, 0.712359846f},
std::array<float,2>{0.502773881f, 0.235148489f},
std::array<float,2>{0.70248425f, 0.611703813f},
std::array<float,2>{0.11504589f, 0.121182494f},
std::array<float,2>{0.369812548f, 0.817676842f},
std::array<float,2>{0.792871058f, 0.414356053f},
std::array<float,2>{0.676574111f, 0.986397684f},
std::array<float,2>{0.0180453192f, 0.274894923f},
std::array<float,2>{0.250438899f, 0.647617102f},
std::array<float,2>{0.826513588f, 0.162120998f},
std::array<float,2>{0.977310836f, 0.501705468f},
std::array<float,2>{0.440921277f, 0.0326248556f},
std::array<float,2>{0.132600129f, 0.763449788f},
std::array<float,2>{0.596160829f, 0.459501058f},
std::array<float,2>{0.751917839f, 0.874522865f},
std::array<float,2>{0.335837513f, 0.384376854f},
std::array<float,2>{0.0735334903f, 0.566231489f},
std::array<float,2>{0.741888285f, 0.0680567399f},
std::array<float,2>{0.543882847f, 0.749847174f},
std::array<float,2>{0.223363683f, 0.218344495f},
std::array<float,2>{0.430357933f, 0.883268416f},
std::array<float,2>{0.923818767f, 0.363968402f},
std::array<float,2>{0.63327229f, 0.755709887f},
std::array<float,2>{0.0394342579f, 0.464709759f},
std::array<float,2>{0.291218132f, 0.514753044f},
std::array<float,2>{0.860193551f, 0.0417800732f},
std::array<float,2>{0.952016354f, 0.650860012f},
std::array<float,2>{0.477478296f, 0.168762416f},
std::array<float,2>{0.18269594f, 0.993173897f},
std::array<float,2>{0.584614396f, 0.269791722f},
std::array<float,2>{0.782942116f, 0.879688978f},
std::array<float,2>{0.365419954f, 0.371452183f},
std::array<float,2>{0.121884227f, 0.739582181f},
std::array<float,2>{0.688882411f, 0.20608294f},
std::array<float,2>{0.508709192f, 0.572084904f},
std::array<float,2>{0.208025202f, 0.0706240162f},
std::array<float,2>{0.381949097f, 0.863402367f},
std::array<float,2>{0.903696239f, 0.378498226f},
std::array<float,2>{0.605137885f, 0.950452328f},
std::array<float,2>{0.138966322f, 0.309000343f},
std::array<float,2>{0.450244427f, 0.656873465f},
std::array<float,2>{0.973670065f, 0.154018804f},
std::array<float,2>{0.817084789f, 0.547105908f},
std::array<float,2>{0.263303161f, 0.0191907994f},
std::array<float,2>{0.024226727f, 0.805334687f},
std::array<float,2>{0.682114661f, 0.470211029f},
std::array<float,2>{0.935858428f, 0.828084707f},
std::array<float,2>{0.423907459f, 0.408815622f},
std::array<float,2>{0.227059811f, 0.620872021f},
std::array<float,2>{0.535259783f, 0.112625286f},
std::array<float,2>{0.742289543f, 0.705807567f},
std::array<float,2>{0.0625429973f, 0.243087843f},
std::array<float,2>{0.339878291f, 0.920187175f},
std::array<float,2>{0.764059186f, 0.318353951f},
std::array<float,2>{0.551738203f, 0.858173788f},
std::array<float,2>{0.244696125f, 0.401997268f},
std::array<float,2>{0.413930595f, 0.581244171f},
std::array<float,2>{0.914013743f, 0.0839313269f},
std::array<float,2>{0.779124498f, 0.725973427f},
std::array<float,2>{0.31552279f, 0.20029214f},
std::array<float,2>{0.0896421f, 0.905287564f},
std::array<float,2>{0.721229136f, 0.350500852f},
std::array<float,2>{0.986405969f, 0.983665884f},
std::array<float,2>{0.459197193f, 0.260418147f},
std::array<float,2>{0.142610729f, 0.626492441f},
std::array<float,2>{0.616216481f, 0.187167466f},
std::array<float,2>{0.666557193f, 0.519801557f},
std::array<float,2>{0.00418077502f, 0.0486181453f},
std::array<float,2>{0.278888911f, 0.777936518f},
std::array<float,2>{0.830303133f, 0.443918169f},
std::array<float,2>{0.71768105f, 0.930483937f},
std::array<float,2>{0.0973086283f, 0.329925776f},
std::array<float,2>{0.353481054f, 0.691007674f},
std::array<float,2>{0.804956079f, 0.219407678f},
std::array<float,2>{0.875759184f, 0.597847164f},
std::array<float,2>{0.392325938f, 0.102113001f},
std::array<float,2>{0.195948303f, 0.832077563f},
std::array<float,2>{0.516082525f, 0.436903685f},
std::array<float,2>{0.846858859f, 0.789616644f},
std::array<float,2>{0.307248324f, 0.486579627f},
std::array<float,2>{0.0601871721f, 0.532841146f},
std::array<float,2>{0.645175815f, 0.00823861454f},
std::array<float,2>{0.562824368f, 0.686266422f},
std::array<float,2>{0.160921738f, 0.1303197f},
std::array<float,2>{0.499266267f, 0.959140241f},
std::array<float,2>{0.96728456f, 0.288497359f},
std::array<float,2>{0.65836525f, 0.860674798f},
std::array<float,2>{0.0137654049f, 0.380155981f},
std::array<float,2>{0.269153357f, 0.574502885f},
std::array<float,2>{0.839137733f, 0.0778536424f},
std::array<float,2>{0.998888314f, 0.734426916f},
std::array<float,2>{0.463349342f, 0.210723847f},
std::array<float,2>{0.152107015f, 0.877566457f},
std::array<float,2>{0.620607555f, 0.367393345f},
std::array<float,2>{0.765867829f, 0.998336434f},
std::array<float,2>{0.323629111f, 0.266103089f},
std::array<float,2>{0.0842507929f, 0.656106532f},
std::array<float,2>{0.727388084f, 0.166278139f},
std::array<float,2>{0.561026096f, 0.510618091f},
std::array<float,2>{0.235629022f, 0.0464265123f},
std::array<float,2>{0.417002946f, 0.751209378f},
std::array<float,2>{0.917238712f, 0.466902107f},
std::array<float,2>{0.572234929f, 0.914907157f},
std::array<float,2>{0.167136952f, 0.314087272f},
std::array<float,2>{0.491910785f, 0.707427144f},
std::array<float,2>{0.95559448f, 0.248234853f},
std::array<float,2>{0.854878843f, 0.624915361f},
std::array<float,2>{0.304010808f, 0.115561418f},
std::array<float,2>{0.0546745993f, 0.821264029f},
std::array<float,2>{0.655641675f, 0.411140859f},
std::array<float,2>{0.884477854f, 0.812228501f},
std::array<float,2>{0.403815508f, 0.473853737f},
std::array<float,2>{0.187778249f, 0.55293566f},
std::array<float,2>{0.530771315f, 0.0203188919f},
std::array<float,2>{0.705155134f, 0.661009073f},
std::array<float,2>{0.108006582f, 0.148809955f},
std::array<float,2>{0.350194633f, 0.945805073f},
std::array<float,2>{0.802233815f, 0.307166636f},
std::array<float,2>{0.5049842f, 0.775579691f},
std::array<float,2>{0.2146945f, 0.440446377f},
std::array<float,2>{0.385018736f, 0.518293858f},
std::array<float,2>{0.895854831f, 0.0520060286f},
std::array<float,2>{0.793299556f, 0.629656911f},
std::array<float,2>{0.371789664f, 0.18205373f},
std::array<float,2>{0.111292653f, 0.979916394f},
std::array<float,2>{0.6971277f, 0.263005674f},
std::array<float,2>{0.941938639f, 0.898512721f},
std::array<float,2>{0.475696743f, 0.345888555f},
std::array<float,2>{0.173819244f, 0.721442938f},
std::array<float,2>{0.591702461f, 0.19544746f},
std::array<float,2>{0.625857472f, 0.584976673f},
std::array<float,2>{0.032977052f, 0.0810978562f},
std::array<float,2>{0.282487214f, 0.851590455f},
std::array<float,2>{0.868029237f, 0.405527472f},
std::array<float,2>{0.735033035f, 0.95657444f},
std::array<float,2>{0.0742734745f, 0.284552097f},
std::array<float,2>{0.329546183f, 0.682949185f},
std::array<float,2>{0.755735993f, 0.125552341f},
std::array<float,2>{0.927655756f, 0.536116362f},
std::array<float,2>{0.434335917f, 0.0144013073f},
std::array<float,2>{0.219924077f, 0.795971155f},
std::array<float,2>{0.540052474f, 0.49091813f},
std::array<float,2>{0.823121607f, 0.831789613f},
std::array<float,2>{0.256036282f, 0.43251738f},
std::array<float,2>{0.0211552642f, 0.597325861f},
std::array<float,2>{0.675407708f, 0.108365096f},
std::array<float,2>{0.600451231f, 0.692489922f},
std::array<float,2>{0.127754077f, 0.223896369f},
std::array<float,2>{0.442274779f, 0.934232473f},
std::array<float,2>{0.980919778f, 0.3347103f},
std::array<float,2>{0.692023337f, 0.788164675f},
std::array<float,2>{0.120183624f, 0.494842768f},
std::array<float,2>{0.362294257f, 0.542609155f},
std::array<float,2>{0.78610462f, 0.0077231559f},
std::array<float,2>{0.89966023f, 0.67275399f},
std::array<float,2>{0.376434237f, 0.138539702f},
std::array<float,2>{0.206106976f, 0.96827358f},
std::array<float,2>{0.513730288f, 0.295230985f},
std::array<float,2>{0.865813851f, 0.928273797f},
std::array<float,2>{0.296506524f, 0.336756557f},
std::array<float,2>{0.0465287305f, 0.701996744f},
std::array<float,2>{0.640456498f, 0.226748675f},
std::array<float,2>{0.579203784f, 0.606968045f},
std::array<float,2>{0.186636001f, 0.0949916616f},
std::array<float,2>{0.480788738f, 0.84321177f},
std::array<float,2>{0.947282732f, 0.422475517f},
std::array<float,2>{0.532785714f, 0.974380136f},
std::array<float,2>{0.230813727f, 0.25755927f},
std::array<float,2>{0.426159978f, 0.632824659f},
std::array<float,2>{0.932508111f, 0.17745626f},
std::array<float,2>{0.757999003f, 0.528599858f},
std::array<float,2>{0.338875562f, 0.0553967431f},
std::array<float,2>{0.0683141574f, 0.768588483f},
std::array<float,2>{0.748793542f, 0.451455176f},
std::array<float,2>{0.971950889f, 0.849504113f},
std::array<float,2>{0.447975516f, 0.396562129f},
std::array<float,2>{0.135143608f, 0.592292607f},
std::array<float,2>{0.609168172f, 0.0865095109f},
std::array<float,2>{0.685790598f, 0.731730163f},
std::array<float,2>{0.0311623756f, 0.19300887f},
std::array<float,2>{0.259920746f, 0.89445734f},
std::array<float,2>{0.814998448f, 0.357921332f},
std::array<float,2>{0.613060176f, 0.813549399f},
std::array<float,2>{0.145866603f, 0.421636313f},
std::array<float,2>{0.453783929f, 0.614453793f},
std::array<float,2>{0.992090702f, 0.118578486f},
std::array<float,2>{0.834497154f, 0.718063176f},
std::array<float,2>{0.274328291f, 0.239697948f},
std::array<float,2>{0.0038446018f, 0.913561463f},
std::array<float,2>{0.669242442f, 0.3270863f},
std::array<float,2>{0.906962931f, 0.942336142f},
std::array<float,2>{0.409680992f, 0.298593432f},
std::array<float,2>{0.247681558f, 0.665742815f},
std::array<float,2>{0.548057079f, 0.140897155f},
std::array<float,2>{0.723986745f, 0.55631268f},
std::array<float,2>{0.0922803208f, 0.0276915636f},
std::array<float,2>{0.318452209f, 0.801312983f},
std::array<float,2>{0.775564671f, 0.483375609f},
std::array<float,2>{0.643162906f, 0.890049815f},
std::array<float,2>{0.0566533729f, 0.361007482f},
std::array<float,2>{0.310099095f, 0.745147705f},
std::array<float,2>{0.850629687f, 0.211015403f},
std::array<float,2>{0.962208688f, 0.56645745f},
std::array<float,2>{0.493544757f, 0.0654937625f},
std::array<float,2>{0.157516941f, 0.870592237f},
std::array<float,2>{0.570066094f, 0.39056161f},
std::array<float,2>{0.810414672f, 0.760863245f},
std::array<float,2>{0.356935561f, 0.454998493f},
std::array<float,2>{0.0983236656f, 0.507747114f},
std::array<float,2>{0.713454425f, 0.0379752852f},
std::array<float,2>{0.521956682f, 0.642811656f},
std::array<float,2>{0.201189414f, 0.158667371f},
std::array<float,2>{0.396188349f, 0.991630137f},
std::array<float,2>{0.879776239f, 0.27819261f},
std::array<float,2>{0.720937908f, 0.857072651f},
std::array<float,2>{0.0888846219f, 0.398789018f},
std::array<float,2>{0.316348553f, 0.579398036f},
std::array<float,2>{0.778625786f, 0.0846184194f},
std::array<float,2>{0.913485944f, 0.723266423f},
std::array<float,2>{0.413354903f, 0.201307103f},
std::array<float,2>{0.244391829f, 0.902368546f},
std::array<float,2>{0.551081836f, 0.349471301f},
std::array<float,2>{0.830845177f, 0.980853379f},
std::array<float,2>{0.278612792f, 0.258028477f},
std::array<float,2>{0.00482741045f, 0.627048314f},
std::array<float,2>{0.666049063f, 0.185228825f},
std::array<float,2>{0.616870701f, 0.521835566f},
std::array<float,2>{0.143484488f, 0.0495437235f},
std::array<float,2>{0.459887266f, 0.779663324f},
std::array<float,2>{0.987134516f, 0.4421359f},
std::array<float,2>{0.516511977f, 0.931968868f},
std::array<float,2>{0.1957369f, 0.331315726f},
std::array<float,2>{0.391705185f, 0.688231051f},
std::array<float,2>{0.87530601f, 0.221631721f},
std::array<float,2>{0.80538249f, 0.601379454f},
std::array<float,2>{0.352807909f, 0.105311505f},
std::array<float,2>{0.0969439298f, 0.835873187f},
std::array<float,2>{0.716982126f, 0.434827268f},
std::array<float,2>{0.9674052f, 0.792141438f},
std::array<float,2>{0.499520183f, 0.485775799f},
std::array<float,2>{0.160624683f, 0.534554183f},
std::array<float,2>{0.563174307f, 0.00979249366f},
std::array<float,2>{0.644615054f, 0.683832467f},
std::array<float,2>{0.0597313419f, 0.132112339f},
std::array<float,2>{0.306805134f, 0.958801448f},
std::array<float,2>{0.847512364f, 0.285631388f},
std::array<float,2>{0.584226489f, 0.757756233f},
std::array<float,2>{0.183191955f, 0.462495208f},
std::array<float,2>{0.476757288f, 0.512049615f},
std::array<float,2>{0.951648176f, 0.0405020975f},
std::array<float,2>{0.859461308f, 0.648538172f},
std::array<float,2>{0.291600794f, 0.170122132f},
std::array<float,2>{0.0398377366f, 0.99422735f},
std::array<float,2>{0.633428574f, 0.272838145f},
std::array<float,2>{0.904020667f, 0.881149411f},
std::array<float,2>{0.382573366f, 0.373047054f},
std::array<float,2>{0.208948106f, 0.740981579f},
std::array<float,2>{0.507862329f, 0.203491554f},
std::array<float,2>{0.689279437f, 0.573372424f},
std::array<float,2>{0.121495672f, 0.0740686804f},
std::array<float,2>{0.365985632f, 0.867150009f},
std::array<float,2>{0.782611132f, 0.375941455f},
std::array<float,2>{0.682614565f, 0.951398134f},
std::array<float,2>{0.0235182308f, 0.311959416f},
std::array<float,2>{0.26305905f, 0.659220755f},
std::array<float,2>{0.816426456f, 0.15483354f},
std::array<float,2>{0.974529386f, 0.549972892f},
std::array<float,2>{0.450820982f, 0.0172188859f},
std::array<float,2>{0.13940835f, 0.808520675f},
std::array<float,2>{0.604809046f, 0.472261906f},
std::array<float,2>{0.764381945f, 0.824703991f},
std::array<float,2>{0.340729147f, 0.406883568f},
std::array<float,2>{0.063041456f, 0.617918074f},
std::array<float,2>{0.742966175f, 0.11057768f},
std::array<float,2>{0.536036789f, 0.703493774f},
std::array<float,2>{0.22699444f, 0.244241193f},
std::array<float,2>{0.424340755f, 0.918438673f},
std::array<float,2>{0.936460793f, 0.318890125f},
std::array<float,2>{0.63124156f, 0.798742235f},
std::array<float,2>{0.0371739008f, 0.479686499f},
std::array<float,2>{0.285750836f, 0.560661733f},
std::array<float,2>{0.873593271f, 0.0256968867f},
std::array<float,2>{0.940339625f, 0.668768704f},
std::array<float,2>{0.470946521f, 0.146633014f},
std::array<float,2>{0.175841287f, 0.940308034f},
std::array<float,2>{0.589750528f, 0.303854495f},
std::array<float,2>{0.792226255f, 0.906998754f},
std::array<float,2>{0.369491935f, 0.323227674f},
std::array<float,2>{0.1146961f, 0.713863909f},
std::array<float,2>{0.703035295f, 0.236418083f},
std::array<float,2>{0.502055645f, 0.609544098f},
std::array<float,2>{0.217846826f, 0.123280369f},
std::array<float,2>{0.387965322f, 0.818438649f},
std::array<float,2>{0.89100796f, 0.416298807f},
std::array<float,2>{0.596629322f, 0.98571521f},
std::array<float,2>{0.131956115f, 0.276117027f},
std::array<float,2>{0.440552533f, 0.645231724f},
std::array<float,2>{0.976612687f, 0.16199173f},
std::array<float,2>{0.82701081f, 0.503759086f},
std::array<float,2>{0.250761986f, 0.0351485349f},
std::array<float,2>{0.0184380487f, 0.765157759f},
std::array<float,2>{0.676027298f, 0.457964152f},
std::array<float,2>{0.922926605f, 0.872092485f},
std::array<float,2>{0.429880917f, 0.386115819f},
std::array<float,2>{0.222788244f, 0.563297749f},
std::array<float,2>{0.543214738f, 0.0702987835f},
std::array<float,2>{0.741443157f, 0.74800539f},
std::array<float,2>{0.074059993f, 0.215435535f},
std::array<float,2>{0.335224301f, 0.885020018f},
std::array<float,2>{0.751081586f, 0.365454257f},
std::array<float,2>{0.556197762f, 0.837257564f},
std::array<float,2>{0.238975167f, 0.427070051f},
std::array<float,2>{0.421499014f, 0.60479176f},
std::array<float,2>{0.920627654f, 0.0980322435f},
std::array<float,2>{0.771307826f, 0.698776782f},
std::array<float,2>{0.327179193f, 0.232765913f},
std::array<float,2>{0.0783711746f, 0.92273885f},
std::array<float,2>{0.730726182f, 0.341590196f},
std::array<float,2>{0.994160891f, 0.96347791f},
std::array<float,2>{0.465250283f, 0.291237533f},
std::array<float,2>{0.153615177f, 0.679368734f},
std::array<float,2>{0.62124902f, 0.134370595f},
std::array<float,2>{0.661533356f, 0.543073118f},
std::array<float,2>{0.0108791981f, 0.00159524952f},
std::array<float,2>{0.272276878f, 0.782696068f},
std::array<float,2>{0.8398996f, 0.496974349f},
std::array<float,2>{0.70735538f, 0.895441711f},
std::array<float,2>{0.103569701f, 0.354244113f},
std::array<float,2>{0.347147107f, 0.727844119f},
std::array<float,2>{0.799393594f, 0.18765448f},
std::array<float,2>{0.889715254f, 0.586440861f},
std::array<float,2>{0.400808752f, 0.0901693329f},
std::array<float,2>{0.191578358f, 0.847269118f},
std::array<float,2>{0.525325179f, 0.392145604f},
std::array<float,2>{0.855576515f, 0.771057963f},
std::array<float,2>{0.296984106f, 0.446774185f},
std::array<float,2>{0.0484888405f, 0.525163472f},
std::array<float,2>{0.65203172f, 0.0607440434f},
std::array<float,2>{0.575484872f, 0.636956036f},
std::array<float,2>{0.168597251f, 0.17509456f},
std::array<float,2>{0.488048702f, 0.969232678f},
std::array<float,2>{0.960147023f, 0.250860631f},
std::array<float,2>{0.66964817f, 0.815389693f},
std::array<float,2>{0.00292991335f, 0.419124931f},
std::array<float,2>{0.273544937f, 0.616131008f},
std::array<float,2>{0.834411263f, 0.12081746f},
std::array<float,2>{0.991613984f, 0.715158761f},
std::array<float,2>{0.453386694f, 0.240288213f},
std::array<float,2>{0.146269709f, 0.911047757f},
std::array<float,2>{0.612591922f, 0.324893504f},
std::array<float,2>{0.775963783f, 0.943514347f},
std::array<float,2>{0.319036365f, 0.299870968f},
std::array<float,2>{0.0923523679f, 0.667752087f},
std::array<float,2>{0.72460407f, 0.144479468f},
std::array<float,2>{0.548489511f, 0.558161914f},
std::array<float,2>{0.24708426f, 0.0293186251f},
std::array<float,2>{0.40959239f, 0.803220332f},
std::array<float,2>{0.906702042f, 0.480852306f},
std::array<float,2>{0.569672167f, 0.88803494f},
std::array<float,2>{0.157776535f, 0.361754507f},
std::array<float,2>{0.493692547f, 0.74378258f},
std::array<float,2>{0.962799668f, 0.214289322f},
std::array<float,2>{0.851109684f, 0.570046127f},
std::array<float,2>{0.310040176f, 0.0632268414f},
std::array<float,2>{0.0572410338f, 0.867430031f},
std::array<float,2>{0.642912924f, 0.388389558f},
std::array<float,2>{0.87891686f, 0.758216977f},
std::array<float,2>{0.395807773f, 0.455410928f},
std::array<float,2>{0.201754898f, 0.504686892f},
std::array<float,2>{0.522110641f, 0.0370617919f},
std::array<float,2>{0.713340998f, 0.640670657f},
std::array<float,2>{0.0978482738f, 0.157279477f},
std::array<float,2>{0.3567065f, 0.989978015f},
std::array<float,2>{0.809987187f, 0.279306918f},
std::array<float,2>{0.514263451f, 0.786073327f},
std::array<float,2>{0.206877977f, 0.493788421f},
std::array<float,2>{0.376747757f, 0.54073596f},
std::array<float,2>{0.899997234f, 0.00542364269f},
std::array<float,2>{0.785513937f, 0.674892366f},
std::array<float,2>{0.361638725f, 0.139242575f},
std::array<float,2>{0.120696373f, 0.965258718f},
std::array<float,2>{0.691807032f, 0.294159681f},
std::array<float,2>{0.94798857f, 0.926126599f},
std::array<float,2>{0.481182218f, 0.339376152f},
std::array<float,2>{0.187352449f, 0.700960755f},
std::array<float,2>{0.579767466f, 0.229647502f},
std::array<float,2>{0.639756024f, 0.609255672f},
std::array<float,2>{0.0461465158f, 0.0966902599f},
std::array<float,2>{0.295948893f, 0.841505289f},
std::array<float,2>{0.86562711f, 0.424833447f},
std::array<float,2>{0.748372614f, 0.975239217f},
std::array<float,2>{0.0677702054f, 0.255474448f},
std::array<float,2>{0.339692593f, 0.635097206f},
std::array<float,2>{0.758666337f, 0.178495616f},
std::array<float,2>{0.932066083f, 0.529724896f},
std::array<float,2>{0.426647574f, 0.0584611446f},
std::array<float,2>{0.231429398f, 0.766078353f},
std::array<float,2>{0.532274961f, 0.44981271f},
std::array<float,2>{0.81454891f, 0.850773871f},
std::array<float,2>{0.260471165f, 0.395207345f},
std::array<float,2>{0.0307080895f, 0.590589285f},
std::array<float,2>{0.686422944f, 0.0892915353f},
std::array<float,2>{0.60856545f, 0.734161973f},
std::array<float,2>{0.135483548f, 0.195168823f},
std::array<float,2>{0.447499722f, 0.891346872f},
std::array<float,2>{0.972323418f, 0.355517328f},
std::array<float,2>{0.696642458f, 0.774476528f},
std::array<float,2>{0.110829338f, 0.439280897f},
std::array<float,2>{0.371199399f, 0.516816616f},
std::array<float,2>{0.79391551f, 0.0534370169f},
std::array<float,2>{0.896452785f, 0.631683469f},
std::array<float,2>{0.385254711f, 0.179753497f},
std::array<float,2>{0.214054719f, 0.97721827f},
std::array<float,2>{0.505666137f, 0.264470756f},
std::array<float,2>{0.867546797f, 0.901154697f},
std::array<float,2>{0.282940209f, 0.344772995f},
std::array<float,2>{0.0323498771f, 0.718777478f},
std::array<float,2>{0.625110626f, 0.197939008f},
std::array<float,2>{0.591185033f, 0.582195401f},
std::array<float,2>{0.173208803f, 0.0792935342f},
std::array<float,2>{0.476470321f, 0.85508579f},
std::array<float,2>{0.94152689f, 0.404097855f},
std::array<float,2>{0.540972352f, 0.953557968f},
std::array<float,2>{0.220606714f, 0.282767206f},
std::array<float,2>{0.433958322f, 0.681287348f},
std::array<float,2>{0.926960111f, 0.127411798f},
std::array<float,2>{0.755364478f, 0.538236499f},
std::array<float,2>{0.329623252f, 0.0134809734f},
std::array<float,2>{0.0751020163f, 0.79401952f},
std::array<float,2>{0.734599411f, 0.488766998f},
std::array<float,2>{0.981403828f, 0.828224242f},
std::array<float,2>{0.441501796f, 0.431191981f},
std::array<float,2>{0.127384707f, 0.595552146f},
std::array<float,2>{0.599955559f, 0.106637225f},
std::array<float,2>{0.674987137f, 0.693639398f},
std::array<float,2>{0.0205283109f, 0.225504249f},
std::array<float,2>{0.256576091f, 0.937388659f},
std::array<float,2>{0.822500944f, 0.332364142f},
std::array<float,2>{0.620154142f, 0.861765563f},
std::array<float,2>{0.151743472f, 0.381255209f},
std::array<float,2>{0.463792354f, 0.577062488f},
std::array<float,2>{0.998308659f, 0.0754965693f},
std::array<float,2>{0.839501619f, 0.738124311f},
std::array<float,2>{0.268753707f, 0.208423316f},
std::array<float,2>{0.0143768014f, 0.875286818f},
std::array<float,2>{0.658908308f, 0.370114893f},
std::array<float,2>{0.917543828f, 0.996127725f},
std::array<float,2>{0.417740554f, 0.269005805f},
std::array<float,2>{0.23613812f, 0.653832912f},
std::array<float,2>{0.561439395f, 0.1658815f},
std::array<float,2>{0.726892054f, 0.508929253f},
std::array<float,2>{0.0848079249f, 0.0436171778f},
std::array<float,2>{0.323792756f, 0.752085328f},
std::array<float,2>{0.76651752f, 0.466152191f},
std::array<float,2>{0.656131029f, 0.917484283f},
std::array<float,2>{0.0538077466f, 0.314576477f},
std::array<float,2>{0.304559171f, 0.709235489f},
std::array<float,2>{0.855460465f, 0.247053459f},
std::array<float,2>{0.955394566f, 0.622262776f},
std::array<float,2>{0.491593659f, 0.113364682f},
std::array<float,2>{0.167697325f, 0.824033201f},
std::array<float,2>{0.571358919f, 0.412386268f},
std::array<float,2>{0.802590787f, 0.809705377f},
std::array<float,2>{0.349669546f, 0.475603312f},
std::array<float,2>{0.107720375f, 0.552165508f},
std::array<float,2>{0.705617428f, 0.0232928041f},
std::array<float,2>{0.530427992f, 0.66367805f},
std::array<float,2>{0.188448533f, 0.151005924f},
std::array<float,2>{0.40333268f, 0.948593438f},
std::array<float,2>{0.884254634f, 0.305858314f},
std::array<float,2>{0.71581465f, 0.832650959f},
std::array<float,2>{0.0938837007f, 0.437269777f},
std::array<float,2>{0.353835881f, 0.598314941f},
std::array<float,2>{0.808238268f, 0.101843633f},
std::array<float,2>{0.877851546f, 0.690911293f},
std::array<float,2>{0.393472642f, 0.218809769f},
std::array<float,2>{0.198289379f, 0.929890275f},
std::array<float,2>{0.518440664f, 0.329108179f},
std::array<float,2>{0.844252169f, 0.95968163f},
std::array<float,2>{0.305763125f, 0.288933814f},
std::array<float,2>{0.0616926998f, 0.686015904f},
std::array<float,2>{0.648297071f, 0.130654693f},
std::array<float,2>{0.565654874f, 0.532446682f},
std::array<float,2>{0.163158685f, 0.00838759542f},
std::array<float,2>{0.496657819f, 0.789287984f},
std::array<float,2>{0.966032147f, 0.486817569f},
std::array<float,2>{0.553829193f, 0.906019509f},
std::array<float,2>{0.243763417f, 0.349615306f},
std::array<float,2>{0.410847843f, 0.726487935f},
std::array<float,2>{0.911592901f, 0.200804234f},
std::array<float,2>{0.781055093f, 0.581736684f},
std::array<float,2>{0.314218104f, 0.0831912756f},
std::array<float,2>{0.087532796f, 0.857850075f},
std::array<float,2>{0.719424963f, 0.401453882f},
std::array<float,2>{0.985082448f, 0.777360678f},
std::array<float,2>{0.458580881f, 0.443590105f},
std::array<float,2>{0.142477602f, 0.520139873f},
std::array<float,2>{0.614474833f, 0.0483287945f},
std::array<float,2>{0.664848924f, 0.626254022f},
std::array<float,2>{0.00655699009f, 0.18668808f},
std::array<float,2>{0.2799173f, 0.983923078f},
std::array<float,2>{0.829700053f, 0.260193527f},
std::array<float,2>{0.602165163f, 0.805150092f},
std::array<float,2>{0.137436107f, 0.470604211f},
std::array<float,2>{0.452471793f, 0.54771781f},
std::array<float,2>{0.975350142f, 0.0187654775f},
std::array<float,2>{0.819030464f, 0.656542957f},
std::array<float,2>{0.26369831f, 0.153731182f},
std::array<float,2>{0.0254341438f, 0.95099175f},
std::array<float,2>{0.681045949f, 0.309396297f},
std::array<float,2>{0.934552848f, 0.920454025f},
std::array<float,2>{0.422673851f, 0.317571402f},
std::array<float,2>{0.228593305f, 0.705237031f},
std::array<float,2>{0.537898958f, 0.242414147f},
std::array<float,2>{0.744299054f, 0.620285273f},
std::array<float,2>{0.0653544217f, 0.113091365f},
std::array<float,2>{0.343425483f, 0.827292025f},
std::array<float,2>{0.762040615f, 0.408669293f},
std::array<float,2>{0.634998918f, 0.99385184f},
std::array<float,2>{0.0416799374f, 0.270483077f},
std::array<float,2>{0.289801151f, 0.651298106f},
std::array<float,2>{0.862360835f, 0.168195277f},
std::array<float,2>{0.949586511f, 0.515513957f},
std::array<float,2>{0.479738355f, 0.0412971564f},
std::array<float,2>{0.180050746f, 0.75494802f},
std::array<float,2>{0.582612038f, 0.464257985f},
std::array<float,2>{0.783665419f, 0.863774359f},
std::array<float,2>{0.363768905f, 0.378003538f},
std::array<float,2>{0.123436786f, 0.571369886f},
std::array<float,2>{0.690410137f, 0.0711262003f},
std::array<float,2>{0.511686981f, 0.739818871f},
std::array<float,2>{0.210411057f, 0.206878617f},
std::array<float,2>{0.379680574f, 0.879245162f},
std::array<float,2>{0.904784322f, 0.371728212f},
std::array<float,2>{0.677905381f, 0.76280266f},
std::array<float,2>{0.0171402581f, 0.459101766f},
std::array<float,2>{0.251991272f, 0.501119375f},
std::array<float,2>{0.824766576f, 0.033033561f},
std::array<float,2>{0.979102671f, 0.648359656f},
std::array<float,2>{0.438103348f, 0.162718773f},
std::array<float,2>{0.129250154f, 0.987244844f},
std::array<float,2>{0.593840837f, 0.274969935f},
std::array<float,2>{0.752010882f, 0.883343339f},
std::array<float,2>{0.332505763f, 0.363329142f},
std::array<float,2>{0.0703444928f, 0.749172807f},
std::array<float,2>{0.739870965f, 0.21813105f},
std::array<float,2>{0.545301974f, 0.565821886f},
std::array<float,2>{0.224906653f, 0.0673881769f},
std::array<float,2>{0.433287024f, 0.874158263f},
std::array<float,2>{0.925272405f, 0.384075224f},
std::array<float,2>{0.58685565f, 0.93792063f},
std::array<float,2>{0.179281309f, 0.302660435f},
std::array<float,2>{0.469043165f, 0.670423329f},
std::array<float,2>{0.938157082f, 0.144583106f},
std::array<float,2>{0.871649265f, 0.560048401f},
std::array<float,2>{0.288422257f, 0.025008766f},
std::array<float,2>{0.0363779329f, 0.79979521f},
std::array<float,2>{0.629616916f, 0.478131592f},
std::array<float,2>{0.893835425f, 0.817954481f},
std::array<float,2>{0.388692111f, 0.414725184f},
std::array<float,2>{0.215870753f, 0.611861765f},
std::array<float,2>{0.501553953f, 0.121969357f},
std::array<float,2>{0.700107038f, 0.712631464f},
std::array<float,2>{0.115798458f, 0.234759957f},
std::array<float,2>{0.367515266f, 0.909174681f},
std::array<float,2>{0.790864646f, 0.320578009f},
std::array<float,2>{0.525596738f, 0.845018983f},
std::array<float,2>{0.193931654f, 0.393166602f},
std::array<float,2>{0.399393111f, 0.588289618f},
std::array<float,2>{0.887515783f, 0.0935305133f},
std::array<float,2>{0.798071384f, 0.729206443f},
std::array<float,2>{0.344388634f, 0.190391436f},
std::array<float,2>{0.102563322f, 0.896736205f},
std::array<float,2>{0.709214687f, 0.352019399f},
std::array<float,2>{0.958107829f, 0.971541882f},
std::array<float,2>{0.48489058f, 0.253379673f},
std::array<float,2>{0.171017602f, 0.640044749f},
std::array<float,2>{0.577910841f, 0.172842011f},
std::array<float,2>{0.649634838f, 0.526969135f},
std::array<float,2>{0.0499744751f, 0.0603652596f},
std::array<float,2>{0.300554186f, 0.772281766f},
std::array<float,2>{0.858979106f, 0.44887805f},
std::array<float,2>{0.733089983f, 0.924627185f},
std::array<float,2>{0.0817903802f, 0.342651188f},
std::array<float,2>{0.325810134f, 0.697076917f},
std::array<float,2>{0.772118866f, 0.231430843f},
std::array<float,2>{0.918419838f, 0.602268875f},
std::array<float,2>{0.41855666f, 0.100186333f},
std::array<float,2>{0.240436077f, 0.838747025f},
std::array<float,2>{0.557222903f, 0.427954465f},
std::array<float,2>{0.842934549f, 0.785124242f},
std::array<float,2>{0.270444095f, 0.499749005f},
std::array<float,2>{0.00850366894f, 0.545766056f},
std::array<float,2>{0.66235435f, 0.00343677751f},
std::array<float,2>{0.624825239f, 0.676881552f},
std::array<float,2>{0.155552f, 0.136694536f},
std::array<float,2>{0.468736231f, 0.962244213f},
std::array<float,2>{0.993530273f, 0.290928483f},
std::array<float,2>{0.64122045f, 0.870731056f},
std::array<float,2>{0.0554782003f, 0.390030265f},
std::array<float,2>{0.31103158f, 0.567281425f},
std::array<float,2>{0.847675085f, 0.0661010444f},
std::array<float,2>{0.963748455f, 0.745924115f},
std::array<float,2>{0.494548589f, 0.211747989f},
std::array<float,2>{0.158453837f, 0.890529871f},
std::array<float,2>{0.567192793f, 0.360574692f},
std::array<float,2>{0.811499953f, 0.992121637f},
std::array<float,2>{0.357440352f, 0.277417511f},
std::array<float,2>{0.100771919f, 0.643361211f},
std::array<float,2>{0.71189779f, 0.15882729f},
std::array<float,2>{0.519737363f, 0.507114708f},
std::array<float,2>{0.199714348f, 0.0372665524f},
std::array<float,2>{0.397766918f, 0.761352301f},
std::array<float,2>{0.880952835f, 0.454228461f},
std::array<float,2>{0.609458447f, 0.913935661f},
std::array<float,2>{0.146895066f, 0.326231778f},
std::array<float,2>{0.456854761f, 0.718421817f},
std::array<float,2>{0.988435805f, 0.240165189f},
std::array<float,2>{0.833135724f, 0.614787757f},
std::array<float,2>{0.276955128f, 0.119025111f},
std::array<float,2>{0.00180209137f, 0.814005494f},
std::array<float,2>{0.670590341f, 0.42094937f},
std::array<float,2>{0.908692718f, 0.80095458f},
std::array<float,2>{0.407357901f, 0.482428819f},
std::array<float,2>{0.248075679f, 0.555976987f},
std::array<float,2>{0.550075233f, 0.0280386079f},
std::array<float,2>{0.725206673f, 0.665496528f},
std::array<float,2>{0.091052264f, 0.14149709f},
std::array<float,2>{0.316611975f, 0.941886544f},
std::array<float,2>{0.774121702f, 0.298140109f},
std::array<float,2>{0.53324908f, 0.769493759f},
std::array<float,2>{0.232732609f, 0.452104479f},
std::array<float,2>{0.428910345f, 0.529055595f},
std::array<float,2>{0.930748463f, 0.055009529f},
std::array<float,2>{0.760930777f, 0.633477509f},
std::array<float,2>{0.336592317f, 0.17714037f},
std::array<float,2>{0.0696595982f, 0.974023819f},
std::array<float,2>{0.74800396f, 0.257089823f},
std::array<float,2>{0.969176114f, 0.893738151f},
std::array<float,2>{0.4472287f, 0.357859194f},
std::array<float,2>{0.133011892f, 0.732347906f},
std::array<float,2>{0.60599947f, 0.192610934f},
std::array<float,2>{0.685360432f, 0.592054009f},
std::array<float,2>{0.028601082f, 0.0861111134f},
std::array<float,2>{0.258326381f, 0.84906745f},
std::array<float,2>{0.813105166f, 0.397295654f},
std::array<float,2>{0.694501817f, 0.967926025f},
std::array<float,2>{0.117587663f, 0.295441091f},
std::array<float,2>{0.360146046f, 0.672235191f},
std::array<float,2>{0.787554979f, 0.137887791f},
std::array<float,2>{0.901067376f, 0.542109728f},
std::array<float,2>{0.378702492f, 0.00702715246f},
std::array<float,2>{0.204828694f, 0.788645804f},
std::array<float,2>{0.512641132f, 0.494172841f},
std::array<float,2>{0.863942921f, 0.843732178f},
std::array<float,2>{0.293837339f, 0.422164291f},
std::array<float,2>{0.044792138f, 0.606682897f},
std::array<float,2>{0.637105942f, 0.0952241868f},
std::array<float,2>{0.581153035f, 0.701645792f},
std::array<float,2>{0.184756443f, 0.227411956f},
std::array<float,2>{0.48308447f, 0.927969038f},
std::array<float,2>{0.946891665f, 0.336272597f},
std::array<float,2>{0.736677349f, 0.796498835f},
std::array<float,2>{0.07693813f, 0.49061197f},
std::array<float,2>{0.330314159f, 0.535337806f},
std::array<float,2>{0.757196903f, 0.0138138887f},
std::array<float,2>{0.928251565f, 0.683118522f},
std::array<float,2>{0.436139554f, 0.125181809f},
std::array<float,2>{0.221517354f, 0.956184208f},
std::array<float,2>{0.541186094f, 0.284728825f},
std::array<float,2>{0.82216692f, 0.933633208f},
std::array<float,2>{0.255226076f, 0.334286958f},
std::array<float,2>{0.0234223846f, 0.693206549f},
std::array<float,2>{0.67327863f, 0.224592879f},
std::array<float,2>{0.598812103f, 0.596898139f},
std::array<float,2>{0.125751153f, 0.107552782f},
std::array<float,2>{0.444040328f, 0.831409991f},
std::array<float,2>{0.983399153f, 0.43168065f},
std::array<float,2>{0.507155001f, 0.980197787f},
std::array<float,2>{0.211622089f, 0.263497174f},
std::array<float,2>{0.383109927f, 0.629347086f},
std::array<float,2>{0.896578431f, 0.182253003f},
std::array<float,2>{0.795817852f, 0.517819762f},
std::array<float,2>{0.374720514f, 0.0525968373f},
std::array<float,2>{0.112005085f, 0.77632159f},
std::array<float,2>{0.698221564f, 0.441038966f},
std::array<float,2>{0.943671167f, 0.852161884f},
std::array<float,2>{0.473252684f, 0.405775338f},
std::array<float,2>{0.17469041f, 0.58569324f},
std::array<float,2>{0.593191564f, 0.0817568302f},
std::array<float,2>{0.628788412f, 0.720791757f},
std::array<float,2>{0.0350614488f, 0.195812553f},
std::array<float,2>{0.284277678f, 0.898965299f},
std::array<float,2>{0.869889855f, 0.346463263f},
std::array<float,2>{0.573466003f, 0.820521176f},
std::array<float,2>{0.164211854f, 0.41177088f},
std::array<float,2>{0.489799231f, 0.62425077f},
std::array<float,2>{0.954484224f, 0.115978882f},
std::array<float,2>{0.853178263f, 0.707857132f},
std::array<float,2>{0.302084565f, 0.248838216f},
std::array<float,2>{0.0521294549f, 0.914375722f},
std::array<float,2>{0.652354777f, 0.313509285f},
std::array<float,2>{0.885510564f, 0.945552588f},
std::array<float,2>{0.40499717f, 0.30699411f},
std::array<float,2>{0.190927029f, 0.660211086f},
std::array<float,2>{0.527725816f, 0.149191856f},
std::array<float,2>{0.704651773f, 0.553376377f},
std::array<float,2>{0.10656748f, 0.0199475605f},
std::array<float,2>{0.348066092f, 0.811958194f},
std::array<float,2>{0.80294019f, 0.474426597f},
std::array<float,2>{0.657119334f, 0.877064466f},
std::array<float,2>{0.0133284908f, 0.368158877f},
std::array<float,2>{0.267165959f, 0.735143304f},
std::array<float,2>{0.836019814f, 0.210247412f},
std::array<float,2>{0.996341884f, 0.574930549f},
std::array<float,2>{0.462670058f, 0.0774085298f},
std::array<float,2>{0.148522675f, 0.86130631f},
std::array<float,2>{0.618390679f, 0.380688399f},
std::array<float,2>{0.768897176f, 0.751904547f},
std::array<float,2>{0.321694404f, 0.467353672f},
std::array<float,2>{0.08332818f, 0.509882927f},
std::array<float,2>{0.728668153f, 0.0461638756f},
std::array<float,2>{0.560192585f, 0.655356646f},
std::array<float,2>{0.236416623f, 0.166854098f},
std::array<float,2>{0.415993571f, 0.998978972f},
std::array<float,2>{0.914648533f, 0.266264468f},
std::array<float,2>{0.691003561f, 0.865698159f},
std::array<float,2>{0.124791116f, 0.376311362f},
std::array<float,2>{0.364526361f, 0.573071003f},
std::array<float,2>{0.78444165f, 0.0726300031f},
std::array<float,2>{0.906233728f, 0.741990089f},
std::array<float,2>{0.380270392f, 0.204945132f},
std::array<float,2>{0.209363148f, 0.882028282f},
std::array<float,2>{0.509985507f, 0.374264121f},
std::array<float,2>{0.861949444f, 0.995677352f},
std::array<float,2>{0.290955842f, 0.271800458f},
std::array<float,2>{0.0428898931f, 0.65008992f},
std::array<float,2>{0.636062026f, 0.17100805f},
std::array<float,2>{0.583914876f, 0.513539314f},
std::array<float,2>{0.181395307f, 0.0400369018f},
std::array<float,2>{0.479217857f, 0.756257415f},
std::array<float,2>{0.950949073f, 0.461322427f},
std::array<float,2>{0.538856626f, 0.918955088f},
std::array<float,2>{0.230372757f, 0.320129573f},
std::array<float,2>{0.422874004f, 0.704343081f},
std::array<float,2>{0.934799552f, 0.245146558f},
std::array<float,2>{0.763641477f, 0.61840409f},
std::array<float,2>{0.342378289f, 0.1097719f},
std::array<float,2>{0.0654591322f, 0.825610876f},
std::array<float,2>{0.745786488f, 0.40727818f},
std::array<float,2>{0.975779057f, 0.806952536f},
std::array<float,2>{0.45119378f, 0.471420586f},
std::array<float,2>{0.138301447f, 0.549744606f},
std::array<float,2>{0.603054762f, 0.0159475096f},
std::array<float,2>{0.680583358f, 0.658414006f},
std::array<float,2>{0.0266372375f, 0.155413643f},
std::array<float,2>{0.264710158f, 0.952489138f},
std::array<float,2>{0.820195854f, 0.311096996f},
std::array<float,2>{0.613556921f, 0.780678511f},
std::array<float,2>{0.141094893f, 0.443124264f},
std::array<float,2>{0.457379937f, 0.522806525f},
std::array<float,2>{0.986170113f, 0.0502224974f},
std::array<float,2>{0.828868151f, 0.628446639f},
std::array<float,2>{0.281099737f, 0.184091017f},
std::array<float,2>{0.00739287632f, 0.981799185f},
std::array<float,2>{0.665189505f, 0.259592265f},
std::array<float,2>{0.910469651f, 0.903824449f},
std::array<float,2>{0.411666006f, 0.348378927f},
std::array<float,2>{0.243134305f, 0.723840415f},
std::array<float,2>{0.553276539f, 0.202947333f},
std::array<float,2>{0.720244765f, 0.578527868f},
std::array<float,2>{0.0865147784f, 0.0854011327f},
std::array<float,2>{0.312871546f, 0.855516315f},
std::array<float,2>{0.779327512f, 0.399867833f},
std::array<float,2>{0.646863818f, 0.957315564f},
std::array<float,2>{0.0614009351f, 0.286915123f},
std::array<float,2>{0.304844797f, 0.685252845f},
std::array<float,2>{0.845609725f, 0.131467596f},
std::array<float,2>{0.965806603f, 0.534179151f},
std::array<float,2>{0.497676015f, 0.011093366f},
std::array<float,2>{0.162707895f, 0.79137224f},
std::array<float,2>{0.564775944f, 0.484523147f},
std::array<float,2>{0.80734849f, 0.83446604f},
std::array<float,2>{0.355047017f, 0.43425414f},
std::array<float,2>{0.0949161798f, 0.600447416f},
std::array<float,2>{0.716362476f, 0.103859834f},
std::array<float,2>{0.519428492f, 0.688991666f},
std::array<float,2>{0.197445869f, 0.22242713f},
std::array<float,2>{0.393700987f, 0.932725668f},
std::array<float,2>{0.87848109f, 0.330982327f},
std::array<float,2>{0.663599491f, 0.781687796f},
std::array<float,2>{0.00975502562f, 0.497534305f},
std::array<float,2>{0.271200448f, 0.544622064f},
std::array<float,2>{0.842351735f, 0.000692707952f},
std::array<float,2>{0.992467403f, 0.678048491f},
std::array<float,2>{0.466830045f, 0.133234367f},
std::array<float,2>{0.154844195f, 0.963969469f},
std::array<float,2>{0.623959422f, 0.292789698f},
std::array<float,2>{0.773057401f, 0.923818588f},
std::array<float,2>{0.32488358f, 0.339844495f},
std::array<float,2>{0.080728963f, 0.697839439f},
std::array<float,2>{0.734369993f, 0.233676299f},
std::array<float,2>{0.558310509f, 0.604138196f},
std::array<float,2>{0.242134586f, 0.0986726508f},
std::array<float,2>{0.419680148f, 0.836634278f},
std::array<float,2>{0.919409156f, 0.426456988f},
std::array<float,2>{0.576505601f, 0.970055342f},
std::array<float,2>{0.17046006f, 0.251838207f},
std::array<float,2>{0.486174703f, 0.638284922f},
std::array<float,2>{0.957269192f, 0.173900127f},
std::array<float,2>{0.857849777f, 0.523789704f},
std::array<float,2>{0.298855841f, 0.0616033264f},
std::array<float,2>{0.0492901765f, 0.769604087f},
std::array<float,2>{0.648776174f, 0.445594251f},
std::array<float,2>{0.888224125f, 0.845768154f},
std::array<float,2>{0.399416298f, 0.391295284f},
std::array<float,2>{0.195069402f, 0.587093651f},
std::array<float,2>{0.526886344f, 0.0913688838f},
std::array<float,2>{0.710399091f, 0.72679168f},
std::array<float,2>{0.10168229f, 0.188842282f},
std::array<float,2>{0.344984263f, 0.896003246f},
std::array<float,2>{0.797808528f, 0.354671299f},
std::array<float,2>{0.500590742f, 0.819397092f},
std::array<float,2>{0.215471014f, 0.417025208f},
std::array<float,2>{0.390394211f, 0.610542536f},
std::array<float,2>{0.892681122f, 0.124934241f},
std::array<float,2>{0.78975147f, 0.714656651f},
std::array<float,2>{0.368275791f, 0.237749875f},
std::array<float,2>{0.117087856f, 0.907737613f},
std::array<float,2>{0.70051986f, 0.3233836f},
std::array<float,2>{0.938764155f, 0.941091061f},
std::array<float,2>{0.469912201f, 0.303123772f},
std::array<float,2>{0.177824765f, 0.669740975f},
std::array<float,2>{0.587635517f, 0.148387745f},
std::array<float,2>{0.630567849f, 0.561610043f},
std::array<float,2>{0.0355887711f, 0.0271792933f},
std::array<float,2>{0.287209213f, 0.797547579f},
std::array<float,2>{0.872103274f, 0.479435742f},
std::array<float,2>{0.738699794f, 0.886300743f},
std::array<float,2>{0.0717433468f, 0.366526634f},
std::array<float,2>{0.333297908f, 0.746357322f},
std::array<float,2>{0.753038704f, 0.216723517f},
std::array<float,2>{0.923912942f, 0.564348638f},
std::array<float,2>{0.4322429f, 0.0692325309f},
std::array<float,2>{0.226288915f, 0.871921659f},
std::array<float,2>{0.546592176f, 0.384976745f},
std::array<float,2>{0.825911283f, 0.763832211f},
std::array<float,2>{0.252984285f, 0.458431005f},
std::array<float,2>{0.0160632227f, 0.502770483f},
std::array<float,2>{0.67924124f, 0.0333671607f},
std::array<float,2>{0.594916165f, 0.646032453f},
std::array<float,2>{0.130855426f, 0.160767704f},
std::array<float,2>{0.43944931f, 0.985179901f},
std::array<float,2>{0.9796229f, 0.276766509f},
std::array<float,2>{0.637874484f, 0.840396047f},
std::array<float,2>{0.043622423f, 0.424633116f},
std::array<float,2>{0.294313014f, 0.607583523f},
std::array<float,2>{0.864542902f, 0.0958220884f},
std::array<float,2>{0.946212173f, 0.699504852f},
std::array<float,2>{0.483521432f, 0.228529513f},
std::array<float,2>{0.184197068f, 0.927212715f},
std::array<float,2>{0.580341935f, 0.338006288f},
std::array<float,2>{0.788129985f, 0.966788471f},
std::array<float,2>{0.360827297f, 0.293253928f},
std::array<float,2>{0.118799508f, 0.674394131f},
std::array<float,2>{0.69337213f, 0.140380576f},
std::array<float,2>{0.513503194f, 0.539199233f},
std::array<float,2>{0.203160748f, 0.00392847881f},
std::array<float,2>{0.377874345f, 0.786412477f},
std::array<float,2>{0.901704848f, 0.492851347f},
std::array<float,2>{0.607380569f, 0.892467737f},
std::array<float,2>{0.134332776f, 0.35738799f},
std::array<float,2>{0.445749581f, 0.732423127f},
std::array<float,2>{0.970160007f, 0.193848982f},
std::array<float,2>{0.813514113f, 0.591589212f},
std::array<float,2>{0.25913021f, 0.0879755467f},
std::array<float,2>{0.0280688182f, 0.850149035f},
std::array<float,2>{0.683801711f, 0.396380335f},
std::array<float,2>{0.929689884f, 0.767103434f},
std::array<float,2>{0.428279191f, 0.450286537f},
std::array<float,2>{0.233511761f, 0.531002581f},
std::array<float,2>{0.534804404f, 0.057577502f},
std::array<float,2>{0.746920347f, 0.635982633f},
std::array<float,2>{0.0685260445f, 0.178869858f},
std::array<float,2>{0.337105602f, 0.976340711f},
std::array<float,2>{0.760722995f, 0.254074335f},
std::array<float,2>{0.549216211f, 0.804044604f},
std::array<float,2>{0.249884591f, 0.481979728f},
std::array<float,2>{0.406405389f, 0.557252824f},
std::array<float,2>{0.909918964f, 0.0311204698f},
std::array<float,2>{0.774591148f, 0.666783273f},
std::array<float,2>{0.318338573f, 0.143096372f},
std::array<float,2>{0.0902846679f, 0.945031643f},
std::array<float,2>{0.725954711f, 0.299380362f},
std::array<float,2>{0.989302278f, 0.911929429f},
std::array<float,2>{0.455688298f, 0.326109231f},
std::array<float,2>{0.147636011f, 0.715928137f},
std::array<float,2>{0.610984266f, 0.241367951f},
std::array<float,2>{0.671355844f, 0.616940081f},
std::array<float,2>{0.000940148719f, 0.120026328f},
std::array<float,2>{0.276278585f, 0.81587702f},
std::array<float,2>{0.83254236f, 0.418200165f},
std::array<float,2>{0.712040067f, 0.989004374f},
std::array<float,2>{0.099713698f, 0.281245887f},
std::array<float,2>{0.358683735f, 0.641691208f},
std::array<float,2>{0.81193763f, 0.15628536f},
std::array<float,2>{0.88188231f, 0.505334496f},
std::array<float,2>{0.396850526f, 0.0359682515f},
std::array<float,2>{0.200930014f, 0.759086192f},
std::array<float,2>{0.52132827f, 0.456116945f},
std::array<float,2>{0.849337161f, 0.868864655f},
std::array<float,2>{0.312308639f, 0.387378395f},
std::array<float,2>{0.0564451255f, 0.56836313f},
std::array<float,2>{0.642356277f, 0.0643214732f},
std::array<float,2>{0.56751579f, 0.742262602f},
std::array<float,2>{0.159924462f, 0.213512436f},
std::array<float,2>{0.495694458f, 0.887585104f},
std::array<float,2>{0.964094579f, 0.362641096f},
std::array<float,2>{0.729839623f, 0.753172517f},
std::array<float,2>{0.0825441778f, 0.46531111f},
std::array<float,2>{0.320665985f, 0.508013189f},
std::array<float,2>{0.767872572f, 0.0446323007f},
std::array<float,2>{0.915507197f, 0.652985573f},
std::array<float,2>{0.414581895f, 0.164902464f},
std::array<float,2>{0.238176763f, 0.997121334f},
std::array<float,2>{0.558871329f, 0.268094867f},
std::array<float,2>{0.837727845f, 0.876315832f},
std::array<float,2>{0.26632759f, 0.370517552f},
std::array<float,2>{0.0124686155f, 0.736775398f},
std::array<float,2>{0.657228827f, 0.207506821f},
std::array<float,2>{0.618147314f, 0.577322245f},
std::array<float,2>{0.149422944f, 0.0751621798f},
std::array<float,2>{0.461364865f, 0.862510324f},
std::array<float,2>{0.998022676f, 0.382385492f},
std::array<float,2>{0.52915442f, 0.947998703f},
std::array<float,2>{0.190170124f, 0.305520535f},
std::array<float,2>{0.406148583f, 0.662236631f},
std::array<float,2>{0.886409521f, 0.151705757f},
std::array<float,2>{0.80432719f, 0.551003218f},
std::array<float,2>{0.348906696f, 0.021994032f},
std::array<float,2>{0.105874851f, 0.809089541f},
std::array<float,2>{0.703901827f, 0.474837273f},
std::array<float,2>{0.953832448f, 0.822717011f},
std::array<float,2>{0.489234775f, 0.413350224f},
std::array<float,2>{0.165214762f, 0.621874094f},
std::array<float,2>{0.572409928f, 0.115080126f},
std::array<float,2>{0.653727591f, 0.710813046f},
std::array<float,2>{0.0514736623f, 0.247470826f},
std::array<float,2>{0.301285326f, 0.916909456f},
std::array<float,2>{0.852402747f, 0.31570214f},
std::array<float,2>{0.592484057f, 0.853997886f},
std::array<float,2>{0.175080299f, 0.402457178f},
std::array<float,2>{0.474019617f, 0.583116591f},
std::array<float,2>{0.945290804f, 0.0783254057f},
std::array<float,2>{0.870426059f, 0.720072985f},
std::array<float,2>{0.283567816f, 0.198543429f},
std::array<float,2>{0.0332447961f, 0.901517868f},
std::array<float,2>{0.627407551f, 0.343881845f},
std::array<float,2>{0.897850037f, 0.977765203f},
std::array<float,2>{0.384473354f, 0.265013784f},
std::array<float,2>{0.212629169f, 0.63205111f},
std::array<float,2>{0.506061494f, 0.180790722f},
std::array<float,2>{0.698583245f, 0.515964806f},
std::array<float,2>{0.112455517f, 0.0538337268f},
std::array<float,2>{0.37401101f, 0.773539007f},
std::array<float,2>{0.796475947f, 0.438322842f},
std::array<float,2>{0.672026217f, 0.93644923f},
std::array<float,2>{0.0216351021f, 0.3334032f},
std::array<float,2>{0.254057318f, 0.695222318f},
std::array<float,2>{0.820763171f, 0.225672096f},
std::array<float,2>{0.983263612f, 0.593979716f},
std::array<float,2>{0.444580525f, 0.105907977f},
std::array<float,2>{0.126128018f, 0.829676509f},
std::array<float,2>{0.598262191f, 0.430268258f},
std::array<float,2>{0.756121993f, 0.793030024f},
std::array<float,2>{0.332015663f, 0.489893496f},
std::array<float,2>{0.0780141875f, 0.538020313f},
std::array<float,2>{0.737508178f, 0.0125006437f},
std::array<float,2>{0.542937517f, 0.680468857f},
std::array<float,2>{0.221753463f, 0.128168225f},
std::array<float,2>{0.437271237f, 0.954102933f},
std::array<float,2>{0.929025114f, 0.282215059f},
std::array<float,2>{0.744126618f, 0.827119112f},
std::array<float,2>{0.0636195913f, 0.409431845f},
std::array<float,2>{0.340917677f, 0.619551182f},
std::array<float,2>{0.765113115f, 0.111803748f},
std::array<float,2>{0.936718047f, 0.706458151f},
std::array<float,2>{0.425100982f, 0.243773639f},
std::array<float,2>{0.227580979f, 0.921415508f},
std::array<float,2>{0.536217451f, 0.317287147f},
std::array<float,2>{0.818092227f, 0.949300945f},
std::array<float,2>{0.262464464f, 0.309894949f},
std::array<float,2>{0.024835607f, 0.657603383f},
std::array<float,2>{0.683585405f, 0.152521983f},
std::array<float,2>{0.604076922f, 0.548422933f},
std::array<float,2>{0.139750078f, 0.0179546475f},
std::array<float,2>{0.450193703f, 0.80661577f},
std::array<float,2>{0.973135591f, 0.469621569f},
std::array<float,2>{0.508809626f, 0.880765021f},
std::array<float,2>{0.207966864f, 0.372100443f},
std::array<float,2>{0.381811529f, 0.739094317f},
std::array<float,2>{0.902760208f, 0.205904379f},
std::array<float,2>{0.781990588f, 0.570664704f},
std::array<float,2>{0.366427362f, 0.0717910007f},
std::array<float,2>{0.122899123f, 0.864815652f},
std::array<float,2>{0.688425362f, 0.377720535f},
std::array<float,2>{0.953018248f, 0.754619658f},
std::array<float,2>{0.477901131f, 0.463350058f},
std::array<float,2>{0.18235451f, 0.514550149f},
std::array<float,2>{0.585691571f, 0.0421494618f},
std::array<float,2>{0.634132504f, 0.651406407f},
std::array<float,2>{0.0409406722f, 0.169741035f},
std::array<float,2>{0.292449355f, 0.9929052f},
std::array<float,2>{0.860837579f, 0.271063328f},
std::array<float,2>{0.564438462f, 0.790464699f},
std::array<float,2>{0.16188027f, 0.488076121f},
std::array<float,2>{0.499018937f, 0.531747937f},
std::array<float,2>{0.968178391f, 0.00890783034f},
std::array<float,2>{0.845747173f, 0.687326252f},
std::array<float,2>{0.308207154f, 0.129154861f},
std::array<float,2>{0.0586778149f, 0.960139632f},
std::array<float,2>{0.646197975f, 0.287777454f},
std::array<float,2>{0.876549363f, 0.930703759f},
std::array<float,2>{0.391374379f, 0.32843703f},
std::array<float,2>{0.196712375f, 0.690265298f},
std::array<float,2>{0.517331183f, 0.220042422f},
std::array<float,2>{0.7185179f, 0.599117756f},
std::array<float,2>{0.0958639458f, 0.102773845f},
std::array<float,2>{0.351990938f, 0.833701491f},
std::array<float,2>{0.805734754f, 0.436109304f},
std::array<float,2>{0.667271078f, 0.983072281f},
std::array<float,2>{0.00570870331f, 0.261457831f},
std::array<float,2>{0.277675599f, 0.625316978f},
std::array<float,2>{0.831347525f, 0.185670212f},
std::array<float,2>{0.98742801f, 0.521148801f},
std::array<float,2>{0.460756212f, 0.0470698141f},
std::array<float,2>{0.14358528f, 0.778988183f},
std::array<float,2>{0.61595434f, 0.444452286f},
std::array<float,2>{0.77779752f, 0.858448505f},
std::array<float,2>{0.314531744f, 0.400893331f},
std::array<float,2>{0.0885430127f, 0.580323637f},
std::array<float,2>{0.722141027f, 0.0821892098f},
std::array<float,2>{0.551799536f, 0.725490153f},
std::array<float,2>{0.245125815f, 0.199809045f},
std::array<float,2>{0.413062423f, 0.905045688f},
std::array<float,2>{0.912705004f, 0.351350933f},
std::array<float,2>{0.650652766f, 0.773177683f},
std::array<float,2>{0.0472981595f, 0.447687358f},
std::array<float,2>{0.298615366f, 0.526107311f},
std::array<float,2>{0.856474519f, 0.0589537919f},
std::array<float,2>{0.959922552f, 0.639283895f},
std::array<float,2>{0.487049043f, 0.173009038f},
std::array<float,2>{0.169790477f, 0.971913934f},
std::array<float,2>{0.574881375f, 0.252642125f},
std::array<float,2>{0.800524592f, 0.897575796f},
std::array<float,2>{0.346140623f, 0.35335958f},
std::array<float,2>{0.104597189f, 0.730291605f},
std::array<float,2>{0.708414137f, 0.190586686f},
std::array<float,2>{0.524015903f, 0.589277089f},
std::array<float,2>{0.193188965f, 0.0926761478f},
std::array<float,2>{0.401891202f, 0.8444345f},
std::array<float,2>{0.889031172f, 0.394188732f},
std::array<float,2>{0.622609854f, 0.96181488f},
std::array<float,2>{0.152663201f, 0.289777666f},
std::array<float,2>{0.465824455f, 0.675797701f},
std::array<float,2>{0.995726287f, 0.134877622f},
std::array<float,2>{0.840833604f, 0.546677113f},
std::array<float,2>{0.272974819f, 0.0028122298f},
std::array<float,2>{0.0103824828f, 0.783980489f},
std::array<float,2>{0.660321176f, 0.498228401f},
std::array<float,2>{0.921631396f, 0.839562774f},
std::array<float,2>{0.420126557f, 0.42955479f},
std::array<float,2>{0.239410058f, 0.60269767f},
std::array<float,2>{0.555354118f, 0.101078279f},
std::array<float,2>{0.73179096f, 0.696148872f},
std::array<float,2>{0.080076009f, 0.232337743f},
std::array<float,2>{0.326243311f, 0.924898028f},
std::array<float,2>{0.769537687f, 0.343286127f},
std::array<float,2>{0.544081748f, 0.87323302f},
std::array<float,2>{0.224232078f, 0.383100897f},
std::array<float,2>{0.430859566f, 0.564675689f},
std::array<float,2>{0.922100008f, 0.0673399344f},
std::array<float,2>{0.750300586f, 0.748209417f},
std::array<float,2>{0.334038615f, 0.21766673f},
std::array<float,2>{0.0725630522f, 0.883987308f},
std::array<float,2>{0.740472615f, 0.364723593f},
std::array<float,2>{0.978284001f, 0.987471581f},
std::array<float,2>{0.440033495f, 0.274354398f},
std::array<float,2>{0.131470829f, 0.64671886f},
std::array<float,2>{0.597232938f, 0.163792893f},
std::array<float,2>{0.677353978f, 0.500971913f},
std::array<float,2>{0.0187061075f, 0.031253662f},
std::array<float,2>{0.251655489f, 0.762029946f},
std::array<float,2>{0.827477872f, 0.460856676f},
std::array<float,2>{0.701171994f, 0.909416676f},
std::array<float,2>{0.11419367f, 0.321542084f},
std::array<float,2>{0.370801598f, 0.711491227f},
std::array<float,2>{0.791854978f, 0.235360056f},
std::array<float,2>{0.891965687f, 0.613239884f},
std::array<float,2>{0.387387663f, 0.1220771f},
std::array<float,2>{0.21747911f, 0.816414654f},
std::array<float,2>{0.503565371f, 0.415053695f},
std::array<float,2>{0.874031782f, 0.800583243f},
std::array<float,2>{0.286639065f, 0.476849884f},
std::array<float,2>{0.038516365f, 0.559202254f},
std::array<float,2>{0.632468939f, 0.0242803469f},
std::array<float,2>{0.588509619f, 0.671765864f},
std::array<float,2>{0.177709609f, 0.14560695f},
std::array<float,2>{0.471914053f, 0.93867898f},
std::array<float,2>{0.941130996f, 0.300855428f},
std::array<float,2>{0.687097728f, 0.847777903f},
std::array<float,2>{0.0297975503f, 0.398066849f},
std::array<float,2>{0.261386484f, 0.593046904f},
std::array<float,2>{0.81572628f, 0.0875139907f},
std::array<float,2>{0.971171141f, 0.73110956f},
std::array<float,2>{0.448681056f, 0.191900879f},
std::array<float,2>{0.136695504f, 0.8932634f},
std::array<float,2>{0.607696593f, 0.359218627f},
std::array<float,2>{0.759418607f, 0.973149419f},
std::array<float,2>{0.338272929f, 0.256160051f},
std::array<float,2>{0.0668531656f, 0.634654403f},
std::array<float,2>{0.749785781f, 0.176393941f},
std::array<float,2>{0.531546474f, 0.527492225f},
std::array<float,2>{0.231554717f, 0.0563555807f},
std::array<float,2>{0.42699945f, 0.767581284f},
std::array<float,2>{0.932975948f, 0.452962935f},
std::array<float,2>{0.57863301f, 0.929465175f},
std::array<float,2>{0.185589522f, 0.337705612f},
std::array<float,2>{0.48215279f, 0.702447951f},
std::array<float,2>{0.948409915f, 0.228267699f},
std::array<float,2>{0.866860032f, 0.605852604f},
std::array<float,2>{0.295206934f, 0.0941771194f},
std::array<float,2>{0.0452775434f, 0.84231329f},
std::array<float,2>{0.639353812f, 0.423146367f},
std::array<float,2>{0.898517072f, 0.787123322f},
std::array<float,2>{0.375957578f, 0.495127678f},
std::array<float,2>{0.205838367f, 0.541767359f},
std::array<float,2>{0.515488327f, 0.005893806f},
std::array<float,2>{0.692846715f, 0.673374772f},
std::array<float,2>{0.119826153f, 0.137455523f},
std::array<float,2>{0.362954974f, 0.967611074f},
std::array<float,2>{0.786524951f, 0.296626925f},
std::array<float,2>{0.523222923f, 0.760038257f},
std::array<float,2>{0.202642068f, 0.453923851f},
std::array<float,2>{0.394838631f, 0.506166041f},
std::array<float,2>{0.880118191f, 0.0388177373f},
std::array<float,2>{0.808841228f, 0.644127131f},
std::array<float,2>{0.355801433f, 0.159657255f},
std::array<float,2>{0.098657243f, 0.990338862f},
std::array<float,2>{0.714089751f, 0.278376997f},
std::array<float,2>{0.961175561f, 0.889055371f},
std::array<float,2>{0.492491573f, 0.360285491f},
std::array<float,2>{0.156499147f, 0.744381547f},
std::array<float,2>{0.568530321f, 0.212436274f},
std::array<float,2>{0.644285142f, 0.568151295f},
std::array<float,2>{0.0585721955f, 0.0648695752f},
std::array<float,2>{0.308958888f, 0.869391084f},
std::array<float,2>{0.850451946f, 0.389142126f},
std::array<float,2>{0.723124981f, 0.943318784f},
std::array<float,2>{0.0933166444f, 0.297519207f},
std::array<float,2>{0.320148528f, 0.664392829f},
std::array<float,2>{0.776985109f, 0.142044857f},
std::array<float,2>{0.907536268f, 0.554783583f},
std::array<float,2>{0.408375025f, 0.029202709f},
std::array<float,2>{0.246825829f, 0.802516103f},
std::array<float,2>{0.547015548f, 0.483923256f},
std::array<float,2>{0.835280716f, 0.813248634f},
std::array<float,2>{0.275060683f, 0.420035183f},
std::array<float,2>{0.00257129082f, 0.613819599f},
std::array<float,2>{0.668040514f, 0.117862485f},
std::array<float,2>{0.611773193f, 0.717300534f},
std::array<float,2>{0.144746587f, 0.239066273f},
std::array<float,2>{0.455010891f, 0.912286282f},
std::array<float,2>{0.991152823f, 0.327860564f},
std::array<float,2>{0.706332266f, 0.810976088f},
std::array<float,2>{0.109139904f, 0.472749531f},
std::array<float,2>{0.351328224f, 0.554436743f},
std::array<float,2>{0.801619589f, 0.0209889598f},
std::array<float,2>{0.883259594f, 0.661531329f},
std::array<float,2>{0.402401567f, 0.150278509f},
std::array<float,2>{0.189288378f, 0.947034299f},
std::array<float,2>{0.529461682f, 0.307855189f},
std::array<float,2>{0.854259312f, 0.915304244f},
std::array<float,2>{0.303204656f, 0.312503874f},
std::array<float,2>{0.0534728058f, 0.708383203f},
std::array<float,2>{0.654527128f, 0.249848709f},
std::array<float,2>{0.570465028f, 0.623414397f},
std::array<float,2>{0.166574448f, 0.116835445f},
std::array<float,2>{0.490872115f, 0.821989655f},
std::array<float,2>{0.956846118f, 0.41045925f},
std::array<float,2>{0.561567605f, 0.999847531f},
std::array<float,2>{0.235210836f, 0.267403245f},
std::array<float,2>{0.416027248f, 0.655113339f},
std::array<float,2>{0.916849852f, 0.167622849f},
std::array<float,2>{0.767078698f, 0.510864139f},
std::array<float,2>{0.323235422f, 0.0455402732f},
std::array<float,2>{0.0856200904f, 0.750454485f},
std::array<float,2>{0.727693081f, 0.468548447f},
std::array<float,2>{0.999598145f, 0.860310555f},
std::array<float,2>{0.464334428f, 0.379653662f},
std::array<float,2>{0.150717959f, 0.575517833f},
std::array<float,2>{0.619659066f, 0.0762210935f},
std::array<float,2>{0.659427404f, 0.735453784f},
std::array<float,2>{0.0155131454f, 0.209489584f},
std::array<float,2>{0.268073559f, 0.878564417f},
std::array<float,2>{0.838289559f, 0.368714809f},
std::array<float,2>{0.601202667f, 0.830964446f},
std::array<float,2>{0.128339201f, 0.432940394f},
std::array<float,2>{0.442698181f, 0.596625984f},
std::array<float,2>{0.982272506f, 0.109194346f},
std::array<float,2>{0.823809743f, 0.692357719f},
std::array<float,2>{0.25719884f, 0.22337395f},
std::array<float,2>{0.0200541653f, 0.935156167f},
std::array<float,2>{0.674345374f, 0.335144877f},
std::array<float,2>{0.925997198f, 0.955618262f},
std::array<float,2>{0.434905231f, 0.283594817f},
std::array<float,2>{0.219149664f, 0.682006121f},
std::array<float,2>{0.539961517f, 0.126354933f},
std::array<float,2>{0.735707819f, 0.536791325f},
std::array<float,2>{0.0755604208f, 0.0154118454f},
std::array<float,2>{0.328441203f, 0.795292318f},
std::array<float,2>{0.754092932f, 0.491637468f},
std::array<float,2>{0.626277149f, 0.900277376f},
std::array<float,2>{0.0317770466f, 0.347535044f},
std::array<float,2>{0.281740755f, 0.722186863f},
std::array<float,2>{0.869003296f, 0.196451604f},
std::array<float,2>{0.94328022f, 0.584415615f},
std::array<float,2>{0.475053996f, 0.0808178633f},
std::array<float,2>{0.172809437f, 0.852984607f},
std::array<float,2>{0.590763748f, 0.404688239f},
std::array<float,2>{0.794402122f, 0.777132988f},
std::array<float,2>{0.372349411f, 0.439864516f},
std::array<float,2>{0.109988891f, 0.51937604f},
std::array<float,2>{0.695883036f, 0.0509847738f},
std::array<float,2>{0.504188538f, 0.630135417f},
std::array<float,2>{0.213452682f, 0.183373675f},
std::array<float,2>{0.386188924f, 0.979422331f},
std::array<float,2>{0.895409226f, 0.261933863f},
std::array<float,2>{0.727123141f, 0.862624109f},
std::array<float,2>{0.0840841979f, 0.382653356f},
std::array<float,2>{0.323452413f, 0.57740581f},
std::array<float,2>{0.765896618f, 0.074798964f},
std::array<float,2>{0.917201102f, 0.736415982f},
std::array<float,2>{0.417448193f, 0.207048818f},
std::array<float,2>{0.235421583f, 0.876095474f},
std::array<float,2>{0.560628712f, 0.370283067f},
std::array<float,2>{0.838878095f, 0.997534752f},
std::array<float,2>{0.269419551f, 0.268513799f},
std::array<float,2>{0.0140492888f, 0.653109968f},
std::array<float,2>{0.658584118f, 0.164620623f},
std::array<float,2>{0.620912671f, 0.508219182f},
std::array<float,2>{0.152051315f, 0.0447976291f},
std::array<float,2>{0.463104248f, 0.75318712f},
std::array<float,2>{0.998550296f, 0.464935243f},
std::array<float,2>{0.531105399f, 0.916566014f},
std::array<float,2>{0.18753916f, 0.315508932f},
std::array<float,2>{0.404201865f, 0.710596919f},
std::array<float,2>{0.884549975f, 0.247281477f},
std::array<float,2>{0.801973045f, 0.621647537f},
std::array<float,2>{0.350550383f, 0.114957355f},
std::array<float,2>{0.108305588f, 0.822485149f},
std::array<float,2>{0.705355465f, 0.413143814f},
std::array<float,2>{0.956027687f, 0.809419274f},
std::array<float,2>{0.492106736f, 0.47490412f},
std::array<float,2>{0.167376727f, 0.551091969f},
std::array<float,2>{0.572000265f, 0.0222963244f},
std::array<float,2>{0.655474067f, 0.662389159f},
std::array<float,2>{0.0543296337f, 0.151539162f},
std::array<float,2>{0.303792983f, 0.947874546f},
std::array<float,2>{0.854611576f, 0.305258304f},
std::array<float,2>{0.591525137f, 0.773688078f},
std::array<float,2>{0.173434466f, 0.438024253f},
std::array<float,2>{0.476056755f, 0.515750468f},
std::array<float,2>{0.942289174f, 0.0541989133f},
std::array<float,2>{0.867836535f, 0.632136643f},
std::array<float,2>{0.282422066f, 0.180936694f},
std::array<float,2>{0.0328794755f, 0.977948785f},
std::array<float,2>{0.625722826f, 0.264717251f},
std::array<float,2>{0.895575762f, 0.901667237f},
std::array<float,2>{0.384790242f, 0.344216973f},
std::array<float,2>{0.214447305f, 0.719769955f},
std::array<float,2>{0.505154431f, 0.198397577f},
std::array<float,2>{0.696780741f, 0.58342284f},
std::array<float,2>{0.111063547f, 0.0784816816f},
std::array<float,2>{0.371869862f, 0.853755534f},
std::array<float,2>{0.793132544f, 0.402744621f},
std::array<float,2>{0.675643742f, 0.954465508f},
std::array<float,2>{0.0212586951f, 0.281977832f},
std::array<float,2>{0.256246507f, 0.680348158f},
std::array<float,2>{0.82282871f, 0.128361419f},
std::array<float,2>{0.980677545f, 0.537599802f},
std::array<float,2>{0.442053467f, 0.0123982541f},
std::array<float,2>{0.127612129f, 0.793415964f},
std::array<float,2>{0.600162148f, 0.490081698f},
std::array<float,2>{0.755457401f, 0.829957962f},
std::array<float,2>{0.329149663f, 0.430535167f},
std::array<float,2>{0.0746154413f, 0.594025791f},
std::array<float,2>{0.735187769f, 0.105671979f},
std::array<float,2>{0.54040581f, 0.694854915f},
std::array<float,2>{0.22015509f, 0.225990191f},
std::array<float,2>{0.434097409f, 0.936201513f},
std::array<float,2>{0.927277982f, 0.333143294f},
std::array<float,2>{0.640220106f, 0.786139905f},
std::array<float,2>{0.046721492f, 0.493139088f},
std::array<float,2>{0.29677251f, 0.539438963f},
std::array<float,2>{0.866147995f, 0.00424344745f},
std::array<float,2>{0.947622538f, 0.674701333f},
std::array<float,2>{0.480677426f, 0.140506953f},
std::array<float,2>{0.186860427f, 0.966428578f},
std::array<float,2>{0.579363585f, 0.293199599f},
std::array<float,2>{0.785778761f, 0.926936865f},
std::array<float,2>{0.362020224f, 0.338358492f},
std::array<float,2>{0.120415658f, 0.69936657f},
std::array<float,2>{0.692382514f, 0.228806034f},
std::array<float,2>{0.514113486f, 0.607827783f},
std::array<float,2>{0.206338108f, 0.0959885642f},
std::array<float,2>{0.376176894f, 0.840617478f},
std::array<float,2>{0.899649024f, 0.424519241f},
std::array<float,2>{0.608965933f, 0.97616142f},
std::array<float,2>{0.134976521f, 0.254371077f},
std::array<float,2>{0.448139131f, 0.636096954f},
std::array<float,2>{0.971773863f, 0.179048836f},
std::array<float,2>{0.81536603f, 0.531097233f},
std::array<float,2>{0.260146558f, 0.0572293811f},
std::array<float,2>{0.0310027786f, 0.767503738f},
std::array<float,2>{0.685839295f, 0.45066312f},
std::array<float,2>{0.932227373f, 0.850402057f},
std::array<float,2>{0.425835818f, 0.396232069f},
std::array<float,2>{0.230681539f, 0.59138f},
std::array<float,2>{0.533140242f, 0.0882448927f},
std::array<float,2>{0.748682022f, 0.732734561f},
std::array<float,2>{0.0679075643f, 0.194097981f},
std::array<float,2>{0.339289099f, 0.892129302f},
std::array<float,2>{0.758119106f, 0.356978685f},
std::array<float,2>{0.548299372f, 0.815474153f},
std::array<float,2>{0.247852191f, 0.418361515f},
std::array<float,2>{0.409957767f, 0.617074788f},
std::array<float,2>{0.907040894f, 0.119830132f},
std::array<float,2>{0.775695026f, 0.716305971f},
std::array<float,2>{0.318736017f, 0.2416026f},
std::array<float,2>{0.0918048471f, 0.911652863f},
std::array<float,2>{0.723792195f, 0.325830519f},
std::array<float,2>{0.99184525f, 0.945108712f},
std::array<float,2>{0.453940302f, 0.29975152f},
std::array<float,2>{0.145515785f, 0.666533947f},
std::array<float,2>{0.613017797f, 0.143338531f},
std::array<float,2>{0.669029117f, 0.557516873f},
std::array<float,2>{0.00358859496f, 0.030950848f},
std::array<float,2>{0.273939013f, 0.803802013f},
std::array<float,2>{0.834945917f, 0.482208967f},
std::array<float,2>{0.713625908f, 0.887217522f},
std::array<float,2>{0.0986085236f, 0.3623707f},
std::array<float,2>{0.357351512f, 0.742616355f},
std::array<float,2>{0.810197711f, 0.213721365f},
std::array<float,2>{0.879556835f, 0.568709671f},
std::array<float,2>{0.396274358f, 0.0639667138f},
std::array<float,2>{0.201430142f, 0.86901933f},
std::array<float,2>{0.521702111f, 0.387591988f},
std::array<float,2>{0.851059675f, 0.758886099f},
std::array<float,2>{0.310534179f, 0.456419468f},
std::array<float,2>{0.0570507422f, 0.504886329f},
std::array<float,2>{0.643340111f, 0.0358527675f},
std::array<float,2>{0.570212007f, 0.642009795f},
std::array<float,2>{0.157259196f, 0.156618118f},
std::array<float,2>{0.493263394f, 0.989059448f},
std::array<float,2>{0.962087095f, 0.280782074f},
std::array<float,2>{0.662058353f, 0.836694837f},
std::array<float,2>{0.0112394914f, 0.426649451f},
std::array<float,2>{0.271691769f, 0.604248762f},
std::array<float,2>{0.8404845f, 0.0991157889f},
std::array<float,2>{0.994830549f, 0.698225319f},
std::array<float,2>{0.465728939f, 0.233506247f},
std::array<float,2>{0.154071733f, 0.923502982f},
std::array<float,2>{0.62168473f, 0.340159625f},
std::array<float,2>{0.770549715f, 0.96429342f},
std::array<float,2>{0.328037053f, 0.292510629f},
std::array<float,2>{0.078874357f, 0.677824616f},
std::array<float,2>{0.731369615f, 0.133045346f},
std::array<float,2>{0.555672705f, 0.544859469f},
std::array<float,2>{0.238624409f, 0.000752594147f},
std::array<float,2>{0.421155334f, 0.781393826f},
std::array<float,2>{0.919960082f, 0.49718526f},
std::array<float,2>{0.575735986f, 0.896320403f},
std::array<float,2>{0.168240577f, 0.35496822f},
std::array<float,2>{0.48734048f, 0.726891339f},
std::array<float,2>{0.960823357f, 0.18860884f},
std::array<float,2>{0.855991006f, 0.587290466f},
std::array<float,2>{0.297481477f, 0.0917610079f},
std::array<float,2>{0.0482006893f, 0.846037507f},
std::array<float,2>{0.651376307f, 0.391515195f},
std::array<float,2>{0.890338898f, 0.769982576f},
std::array<float,2>{0.401163548f, 0.445405126f},
std::array<float,2>{0.192293212f, 0.523564696f},
std::array<float,2>{0.524514794f, 0.0619348288f},
std::array<float,2>{0.707625031f, 0.638448596f},
std::array<float,2>{0.104090825f, 0.174278468f},
std::array<float,2>{0.347296685f, 0.969732344f},
std::array<float,2>{0.799098313f, 0.251498908f},
std::array<float,2>{0.502573609f, 0.797794402f},
std::array<float,2>{0.218694523f, 0.479125947f},
std::array<float,2>{0.388390183f, 0.561824501f},
std::array<float,2>{0.891489685f, 0.0269121211f},
std::array<float,2>{0.792682111f, 0.669561625f},
std::array<float,2>{0.369976223f, 0.148137406f},
std::array<float,2>{0.114846841f, 0.941332579f},
std::array<float,2>{0.702386439f, 0.302906513f},
std::array<float,2>{0.939568937f, 0.9079687f},
std::array<float,2>{0.471507818f, 0.323658288f},
std::array<float,2>{0.176303893f, 0.71459645f},
std::array<float,2>{0.589252532f, 0.237317428f},
std::array<float,2>{0.63165164f, 0.610804796f},
std::array<float,2>{0.0378358401f, 0.124712519f},
std::array<float,2>{0.285427779f, 0.819633543f},
std::array<float,2>{0.873049021f, 0.417368263f},
std::array<float,2>{0.742028296f, 0.984874308f},
std::array<float,2>{0.0734791756f, 0.276436716f},
std::array<float,2>{0.335572988f, 0.646265507f},
std::array<float,2>{0.751706123f, 0.161094084f},
std::array<float,2>{0.923514545f, 0.502627492f},
std::array<float,2>{0.430646181f, 0.0336130559f},
std::array<float,2>{0.223579332f, 0.764021456f},
std::array<float,2>{0.543647766f, 0.458042592f},
std::array<float,2>{0.826218843f, 0.871792078f},
std::array<float,2>{0.250012249f, 0.385013908f},
std::array<float,2>{0.0177588798f, 0.563985884f},
std::array<float,2>{0.676350474f, 0.0689712912f},
std::array<float,2>{0.59581238f, 0.746269405f},
std::array<float,2>{0.132504568f, 0.216452405f},
std::array<float,2>{0.441331297f, 0.886605263f},
std::array<float,2>{0.977272987f, 0.366280824f},
std::array<float,2>{0.68869108f, 0.756017983f},
std::array<float,2>{0.121697396f, 0.461116791f},
std::array<float,2>{0.365521282f, 0.513310373f},
std::array<float,2>{0.783123374f, 0.0397467799f},
std::array<float,2>{0.903478444f, 0.650230825f},
std::array<float,2>{0.382187366f, 0.171177372f},
std::array<float,2>{0.208370388f, 0.995995522f},
std::array<float,2>{0.508493304f, 0.271609545f},
std::array<float,2>{0.860047042f, 0.882256925f},
std::array<float,2>{0.291470796f, 0.374270916f},
std::array<float,2>{0.0391729064f, 0.741924822f},
std::array<float,2>{0.632864118f, 0.204766572f},
std::array<float,2>{0.584836483f, 0.572854877f},
std::array<float,2>{0.182956442f, 0.0724527016f},
std::array<float,2>{0.477291673f, 0.865434229f},
std::array<float,2>{0.951830983f, 0.376101345f},
std::array<float,2>{0.535440505f, 0.952222586f},
std::array<float,2>{0.227342546f, 0.311448991f},
std::array<float,2>{0.42414391f, 0.658513367f},
std::array<float,2>{0.935764134f, 0.155573472f},
std::array<float,2>{0.763849318f, 0.549479544f},
std::array<float,2>{0.3400985f, 0.0158251505f},
std::array<float,2>{0.0629881024f, 0.806709528f},
std::array<float,2>{0.74263835f, 0.471664041f},
std::array<float,2>{0.974115849f, 0.825375736f},
std::array<float,2>{0.450587094f, 0.407488883f},
std::array<float,2>{0.138683334f, 0.618420899f},
std::array<float,2>{0.605233252f, 0.109424353f},
std::array<float,2>{0.681807995f, 0.704456508f},
std::array<float,2>{0.0241668746f, 0.245518327f},
std::array<float,2>{0.263548553f, 0.919286013f},
std::array<float,2>{0.817156911f, 0.319920093f},
std::array<float,2>{0.616563022f, 0.855790615f},
std::array<float,2>{0.142892852f, 0.399493635f},
std::array<float,2>{0.459272355f, 0.578168333f},
std::array<float,2>{0.98677963f, 0.0850547925f},
std::array<float,2>{0.830447733f, 0.723888516f},
std::array<float,2>{0.279208481f, 0.202638462f},
std::array<float,2>{0.00397358695f, 0.904129565f},
std::array<float,2>{0.666760623f, 0.34850961f},
std::array<float,2>{0.913574994f, 0.981473505f},
std::array<float,2>{0.413782626f, 0.259436667f},
std::array<float,2>{0.24503997f, 0.628781736f},
std::array<float,2>{0.55135572f, 0.184330225f},
std::array<float,2>{0.721462846f, 0.522591472f},
std::array<float,2>{0.0893779993f, 0.0498446412f},
std::array<float,2>{0.315744936f, 0.78046757f},
std::array<float,2>{0.778992891f, 0.442930311f},
std::array<float,2>{0.645495832f, 0.932938099f},
std::array<float,2>{0.0603084303f, 0.330681562f},
std::array<float,2>{0.307471454f, 0.689301193f},
std::array<float,2>{0.846975625f, 0.222187921f},
std::array<float,2>{0.966909468f, 0.600183368f},
std::array<float,2>{0.499463707f, 0.103758253f},
std::array<float,2>{0.160815746f, 0.834049702f},
std::array<float,2>{0.562502086f, 0.434544981f},
std::array<float,2>{0.804929018f, 0.791070879f},
std::array<float,2>{0.353090256f, 0.484699368f},
std::array<float,2>{0.0976177081f, 0.533783019f},
std::array<float,2>{0.717430532f, 0.0109394966f},
std::array<float,2>{0.51578927f, 0.685371637f},
std::array<float,2>{0.196061984f, 0.131772041f},
std::array<float,2>{0.392336965f, 0.957044661f},
std::array<float,2>{0.875605166f, 0.286630809f},
std::array<float,2>{0.704249442f, 0.822041869f},
std::array<float,2>{0.107372105f, 0.410187662f},
std::array<float,2>{0.348342985f, 0.623102248f},
std::array<float,2>{0.80323863f, 0.116967387f},
std::array<float,2>{0.885166526f, 0.708013177f},
std::array<float,2>{0.404463828f, 0.24974294f},
std::array<float,2>{0.190717474f, 0.915099442f},
std::array<float,2>{0.528045952f, 0.312965691f},
std::array<float,2>{0.852882683f, 0.946829259f},
std::array<float,2>{0.302514285f, 0.307889551f},
std::array<float,2>{0.0525177419f, 0.661369979f},
std::array<float,2>{0.653056204f, 0.149952024f},
std::array<float,2>{0.574027538f, 0.554648876f},
std::array<float,2>{0.164633155f, 0.0205270518f},
std::array<float,2>{0.489436567f, 0.810606897f},
std::array<float,2>{0.954815865f, 0.473040938f},
std::array<float,2>{0.560022771f, 0.878890872f},
std::array<float,2>{0.237287343f, 0.369063288f},
std::array<float,2>{0.415435016f, 0.735748649f},
std::array<float,2>{0.91445291f, 0.209848806f},
std::array<float,2>{0.769126415f, 0.575324833f},
std::array<float,2>{0.321850598f, 0.0764972568f},
std::array<float,2>{0.0839842111f, 0.860001206f},
std::array<float,2>{0.729483426f, 0.379618049f},
std::array<float,2>{0.996892393f, 0.750162542f},
std::array<float,2>{0.462327152f, 0.468493223f},
std::array<float,2>{0.149000227f, 0.511199117f},
std::array<float,2>{0.619014144f, 0.0458001234f},
std::array<float,2>{0.656720221f, 0.654942214f},
std::array<float,2>{0.0128598288f, 0.167885199f},
std::array<float,2>{0.266884893f, 0.999530554f},
std::array<float,2>{0.836582661f, 0.267161757f},
std::array<float,2>{0.599150717f, 0.795087457f},
std::array<float,2>{0.125251427f, 0.491454035f},
std::array<float,2>{0.443823457f, 0.536891878f},
std::array<float,2>{0.984250426f, 0.0153002124f},
std::array<float,2>{0.821445465f, 0.681782842f},
std::array<float,2>{0.255479723f, 0.125998452f},
std::array<float,2>{0.0227205995f, 0.955916822f},
std::array<float,2>{0.673421919f, 0.283282399f},
std::array<float,2>{0.928036749f, 0.935491145f},
std::array<float,2>{0.435786545f, 0.335356474f},
std::array<float,2>{0.220707849f, 0.691947997f},
std::array<float,2>{0.541718602f, 0.223463282f},
std::array<float,2>{0.73706907f, 0.596295953f},
std::array<float,2>{0.076263912f, 0.108984351f},
std::array<float,2>{0.330657482f, 0.830720603f},
std::array<float,2>{0.757519722f, 0.432727665f},
std::array<float,2>{0.628194869f, 0.979203939f},
std::array<float,2>{0.0344098173f, 0.262010843f},
std::array<float,2>{0.284915596f, 0.630054057f},
std::array<float,2>{0.869301379f, 0.183173195f},
std::array<float,2>{0.944076002f, 0.519140482f},
std::array<float,2>{0.472947538f, 0.0512291901f},
std::array<float,2>{0.173882574f, 0.777037978f},
std::array<float,2>{0.593449295f, 0.439523607f},
std::array<float,2>{0.795119643f, 0.852627337f},
std::array<float,2>{0.374212235f, 0.40444991f},
std::array<float,2>{0.11135f, 0.584180117f},
std::array<float,2>{0.697622597f, 0.0805669054f},
std::array<float,2>{0.507517099f, 0.722556531f},
std::array<float,2>{0.211022034f, 0.196777061f},
std::array<float,2>{0.383560866f, 0.900106788f},
std::array<float,2>{0.897041082f, 0.347386569f},
std::array<float,2>{0.684673429f, 0.767940819f},
std::array<float,2>{0.0291360188f, 0.452797055f},
std::array<float,2>{0.258254081f, 0.527734697f},
std::array<float,2>{0.81285423f, 0.0565399975f},
std::array<float,2>{0.969522059f, 0.634295642f},
std::array<float,2>{0.446589708f, 0.176542848f},
std::array<float,2>{0.133477584f, 0.973506033f},
std::array<float,2>{0.605544627f, 0.256101012f},
std::array<float,2>{0.761690855f, 0.893487453f},
std::array<float,2>{0.336164951f, 0.359038025f},
std::array<float,2>{0.0701803267f, 0.731202066f},
std::array<float,2>{0.747394741f, 0.192151278f},
std::array<float,2>{0.534162581f, 0.592884839f},
std::array<float,2>{0.233199716f, 0.0877770707f},
std::array<float,2>{0.429445833f, 0.847932577f},
std::array<float,2>{0.931488156f, 0.398240775f},
std::array<float,2>{0.581750393f, 0.967434824f},
std::array<float,2>{0.185391486f, 0.296822459f},
std::array<float,2>{0.482843369f, 0.673648238f},
std::array<float,2>{0.946331918f, 0.13721922f},
std::array<float,2>{0.863575459f, 0.541699886f},
std::array<float,2>{0.293375105f, 0.00633047102f},
std::array<float,2>{0.0443498567f, 0.78748858f},
std::array<float,2>{0.637272656f, 0.495579988f},
std::array<float,2>{0.900600076f, 0.842591524f},
std::array<float,2>{0.377997369f, 0.422985226f},
std::array<float,2>{0.204575717f, 0.605541825f},
std::array<float,2>{0.512159705f, 0.0938049033f},
std::array<float,2>{0.695048809f, 0.702315331f},
std::array<float,2>{0.117809474f, 0.228435412f},
std::array<float,2>{0.359666616f, 0.929351091f},
std::array<float,2>{0.787939906f, 0.337633759f},
std::array<float,2>{0.52022773f, 0.869318724f},
std::array<float,2>{0.199521452f, 0.388748497f},
std::array<float,2>{0.398302048f, 0.568096161f},
std::array<float,2>{0.881496966f, 0.0644874051f},
std::array<float,2>{0.810733259f, 0.744605601f},
std::array<float,2>{0.358191729f, 0.212862954f},
std::array<float,2>{0.101142541f, 0.888815343f},
std::array<float,2>{0.711420298f, 0.35988456f},
std::array<float,2>{0.962944627f, 0.990622938f},
std::array<float,2>{0.494788826f, 0.278762937f},
std::array<float,2>{0.159171984f, 0.64433825f},
std::array<float,2>{0.566489518f, 0.159387305f},
std::array<float,2>{0.641060054f, 0.505862772f},
std::array<float,2>{0.0550639145f, 0.0390180238f},
std::array<float,2>{0.311455816f, 0.759867191f},
std::array<float,2>{0.848405123f, 0.453852385f},
std::array<float,2>{0.724900961f, 0.912429392f},
std::array<float,2>{0.0914579257f, 0.328122228f},
std::array<float,2>{0.317051858f, 0.717532635f},
std::array<float,2>{0.773600042f, 0.238887489f},
std::array<float,2>{0.908460438f, 0.614125431f},
std::array<float,2>{0.4080621f, 0.118086144f},
std::array<float,2>{0.248980105f, 0.813098192f},
std::array<float,2>{0.55066067f, 0.420169622f},
std::array<float,2>{0.833592117f, 0.802470982f},
std::array<float,2>{0.276410788f, 0.484182209f},
std::array<float,2>{0.00131822575f, 0.555153966f},
std::array<float,2>{0.670031726f, 0.0289566349f},
std::array<float,2>{0.61030364f, 0.66420275f},
std::array<float,2>{0.146974981f, 0.141661584f},
std::array<float,2>{0.45608449f, 0.943044603f},
std::array<float,2>{0.988978803f, 0.297791034f},
std::array<float,2>{0.650032043f, 0.844603121f},
std::array<float,2>{0.0507608019f, 0.394432932f},
std::array<float,2>{0.299815506f, 0.589069724f},
std::array<float,2>{0.858678043f, 0.0923447534f},
std::array<float,2>{0.958586633f, 0.73009485f},
std::array<float,2>{0.484465003f, 0.190780133f},
std::array<float,2>{0.171463087f, 0.89779973f},
std::array<float,2>{0.57746011f, 0.353045821f},
std::array<float,2>{0.798484743f, 0.972010016f},
std::array<float,2>{0.343813002f, 0.25274083f},
std::array<float,2>{0.103443019f, 0.639541805f},
std::array<float,2>{0.709574223f, 0.173098639f},
std::array<float,2>{0.526046574f, 0.526148438f},
std::array<float,2>{0.19355619f, 0.0586925186f},
std::array<float,2>{0.398684323f, 0.773393095f},
std::array<float,2>{0.887142479f, 0.447484106f},
std::array<float,2>{0.624088049f, 0.925140619f},
std::array<float,2>{0.155828163f, 0.343663961f},
std::array<float,2>{0.467882752f, 0.695889294f},
std::array<float,2>{0.994076014f, 0.232111827f},
std::array<float,2>{0.843705654f, 0.602807045f},
std::array<float,2>{0.269851118f, 0.101319119f},
std::array<float,2>{0.00825123489f, 0.839835525f},
std::array<float,2>{0.662897944f, 0.429228365f},
std::array<float,2>{0.918610454f, 0.783709705f},
std::array<float,2>{0.418200552f, 0.498439431f},
std::array<float,2>{0.240838662f, 0.546560466f},
std::array<float,2>{0.556934714f, 0.00259256782f},
std::array<float,2>{0.732520044f, 0.676056921f},
std::array<float,2>{0.081398502f, 0.135213658f},
std::array<float,2>{0.325450718f, 0.961491585f},
std::array<float,2>{0.771698952f, 0.289971113f},
std::array<float,2>{0.545420229f, 0.761761129f},
std::array<float,2>{0.22545591f, 0.460490525f},
std::array<float,2>{0.433084756f, 0.500683546f},
std::array<float,2>{0.925764978f, 0.0316193067f},
std::array<float,2>{0.75252682f, 0.646786988f},
std::array<float,2>{0.332634002f, 0.163855538f},
std::array<float,2>{0.0710338503f, 0.987588048f},
std::array<float,2>{0.739379227f, 0.273990005f},
std::array<float,2>{0.978625834f, 0.884133697f},
std::array<float,2>{0.437965721f, 0.364360452f},
std::array<float,2>{0.129564658f, 0.748308778f},
std::array<float,2>{0.594390333f, 0.217518017f},
std::array<float,2>{0.678462088f, 0.564924359f},
std::array<float,2>{0.0168026388f, 0.0670922399f},
std::array<float,2>{0.252489626f, 0.873411298f},
std::array<float,2>{0.82438606f, 0.382967085f},
std::array<float,2>{0.699383974f, 0.938809335f},
std::array<float,2>{0.115633741f, 0.301187366f},
std::array<float,2>{0.367956161f, 0.671503007f},
std::array<float,2>{0.790073693f, 0.145895705f},
std::array<float,2>{0.894447565f, 0.559420466f},
std::array<float,2>{0.38938123f, 0.0239376612f},
std::array<float,2>{0.216523424f, 0.800403118f},
std::array<float,2>{0.501048863f, 0.476762533f},
std::array<float,2>{0.871569097f, 0.816654384f},
std::array<float,2>{0.28887856f, 0.415476441f},
std::array<float,2>{0.0370023735f, 0.613016963f},
std::array<float,2>{0.628929257f, 0.122484811f},
std::array<float,2>{0.586308897f, 0.711729705f},
std::array<float,2>{0.178866237f, 0.235632777f},
std::array<float,2>{0.469337732f, 0.90961045f},
std::array<float,2>{0.937614322f, 0.321393788f},
std::array<float,2>{0.744889259f, 0.80624181f},
std::array<float,2>{0.0648484454f, 0.469453543f},
std::array<float,2>{0.342844129f, 0.548600078f},
std::array<float,2>{0.762369573f, 0.0176140033f},
std::array<float,2>{0.93405807f, 0.65743947f},
std::array<float,2>{0.421930522f, 0.152761891f},
std::array<float,2>{0.229110464f, 0.949625134f},
std::array<float,2>{0.537429512f, 0.309759289f},
std::array<float,2>{0.818377376f, 0.921693146f},
std::array<float,2>{0.264643162f, 0.317121327f},
std::array<float,2>{0.0262720715f, 0.706244886f},
std::array<float,2>{0.681523383f, 0.244079798f},
std::array<float,2>{0.601946592f, 0.619256854f},
std::array<float,2>{0.136747599f, 0.111535259f},
std::array<float,2>{0.452675581f, 0.826847196f},
std::array<float,2>{0.97474581f, 0.409232378f},
std::array<float,2>{0.510955155f, 0.992978036f},
std::array<float,2>{0.210689023f, 0.271460742f},
std::array<float,2>{0.379150808f, 0.65163523f},
std::array<float,2>{0.905270278f, 0.169585064f},
std::array<float,2>{0.783904791f, 0.514351964f},
std::array<float,2>{0.364257008f, 0.0424689911f},
std::array<float,2>{0.123999156f, 0.754780948f},
std::array<float,2>{0.689656556f, 0.463114172f},
std::array<float,2>{0.949867904f, 0.865049362f},
std::array<float,2>{0.480100662f, 0.377656639f},
std::array<float,2>{0.180201337f, 0.570452929f},
std::array<float,2>{0.582490206f, 0.0722033754f},
std::array<float,2>{0.635541856f, 0.738872766f},
std::array<float,2>{0.041236341f, 0.205587f},
std::array<float,2>{0.289198875f, 0.880564332f},
std::array<float,2>{0.862882197f, 0.372387171f},
std::array<float,2>{0.566127181f, 0.833813667f},
std::array<float,2>{0.163954958f, 0.436510772f},
std::array<float,2>{0.496526361f, 0.598805785f},
std::array<float,2>{0.966634572f, 0.102888629f},
std::array<float,2>{0.84377718f, 0.690136552f},
std::array<float,2>{0.306568891f, 0.219912037f},
std::array<float,2>{0.0623632222f, 0.931129456f},
std::array<float,2>{0.647750616f, 0.328307509f},
std::array<float,2>{0.877413034f, 0.960403621f},
std::array<float,2>{0.392909497f, 0.288024276f},
std::array<float,2>{0.198749125f, 0.687103093f},
std::array<float,2>{0.517719269f, 0.129125893f},
std::array<float,2>{0.715173304f, 0.532149613f},
std::array<float,2>{0.0946038812f, 0.00916454103f},
std::array<float,2>{0.354107052f, 0.790154338f},
std::array<float,2>{0.807805717f, 0.487835526f},
std::array<float,2>{0.664093852f, 0.904795766f},
std::array<float,2>{0.00626684306f, 0.351270586f},
std::array<float,2>{0.279708773f, 0.725236893f},
std::array<float,2>{0.829424441f, 0.200146407f},
std::array<float,2>{0.984631062f, 0.580286086f},
std::array<float,2>{0.45840475f, 0.0824761018f},
std::array<float,2>{0.141939804f, 0.858694375f},
std::array<float,2>{0.614955068f, 0.401151091f},
std::array<float,2>{0.78032583f, 0.779272676f},
std::array<float,2>{0.313866138f, 0.44473511f},
std::array<float,2>{0.0869971514f, 0.521340728f},
std::array<float,2>{0.718958378f, 0.0473619252f},
std::array<float,2>{0.554585874f, 0.625180006f},
std::array<float,2>{0.243331432f, 0.185860977f},
std::array<float,2>{0.410466552f, 0.983225524f},
std::array<float,2>{0.911693513f, 0.261488885f},
std::array<float,2>{0.698822618f, 0.855439603f},
std::array<float,2>{0.112826549f, 0.404017329f},
std::array<float,2>{0.373425186f, 0.582310498f},
std::array<float,2>{0.796368599f, 0.0793509036f},
std::array<float,2>{0.898261309f, 0.719079733f},
std::array<float,2>{0.384255826f, 0.198221698f},
std::array<float,2>{0.212003678f, 0.901030481f},
std::array<float,2>{0.506451726f, 0.345201015f},
std::array<float,2>{0.870896995f, 0.977484822f},
std::array<float,2>{0.284053594f, 0.264171422f},
std::array<float,2>{0.0337206461f, 0.631516874f},
std::array<float,2>{0.62774086f, 0.180070966f},
std::array<float,2>{0.592080951f, 0.516964436f},
std::array<float,2>{0.175744802f, 0.0535875037f},
std::array<float,2>{0.474471211f, 0.774745226f},
std::array<float,2>{0.94456017f, 0.438993156f},
std::array<float,2>{0.542081296f, 0.937143028f},
std::array<float,2>{0.222266823f, 0.332165062f},
std::array<float,2>{0.437006652f, 0.693516552f},
std::array<float,2>{0.929643393f, 0.225316674f},
std::array<float,2>{0.756750882f, 0.595388889f},
std::array<float,2>{0.331370294f, 0.10670311f},
std::array<float,2>{0.0773669407f, 0.828430057f},
std::array<float,2>{0.738012552f, 0.431607723f},
std::array<float,2>{0.982868373f, 0.794342399f},
std::array<float,2>{0.444831133f, 0.488384843f},
std::array<float,2>{0.126747027f, 0.538486302f},
std::array<float,2>{0.597947896f, 0.0133635206f},
std::array<float,2>{0.672704518f, 0.681453109f},
std::array<float,2>{0.022045007f, 0.126983285f},
std::array<float,2>{0.254431427f, 0.95320648f},
std::array<float,2>{0.821285963f, 0.282991797f},
std::array<float,2>{0.617205024f, 0.752381086f},
std::array<float,2>{0.149977908f, 0.466017365f},
std::array<float,2>{0.461716443f, 0.509271145f},
std::array<float,2>{0.997071683f, 0.0438773297f},
std::array<float,2>{0.83734864f, 0.654285789f},
std::array<float,2>{0.26575309f, 0.165551871f},
std::array<float,2>{0.0118063763f, 0.996578276f},
std::array<float,2>{0.658126056f, 0.268656939f},
std::array<float,2>{0.915706694f, 0.875242949f},
std::array<float,2>{0.414215267f, 0.369787484f},
std::array<float,2>{0.237603605f, 0.737826169f},
std::array<float,2>{0.559285581f, 0.208104625f},
std::array<float,2>{0.730319381f, 0.576751053f},
std::array<float,2>{0.0823702291f, 0.0752918348f},
std::array<float,2>{0.321273118f, 0.86134994f},
std::array<float,2>{0.768275321f, 0.38094002f},
std::array<float,2>{0.653965831f, 0.948253214f},
std::array<float,2>{0.051196605f, 0.306082249f},
std::array<float,2>{0.301087141f, 0.663915932f},
std::array<float,2>{0.852000535f, 0.151258647f},
std::array<float,2>{0.953403473f, 0.551831424f},
std::array<float,2>{0.488374949f, 0.0229495168f},
std::array<float,2>{0.16559574f, 0.810012758f},
std::array<float,2>{0.572945476f, 0.475913852f},
std::array<float,2>{0.804028988f, 0.823860168f},
std::array<float,2>{0.349423409f, 0.412229449f},
std::array<float,2>{0.106302872f, 0.622349918f},
std::array<float,2>{0.70356077f, 0.113549799f},
std::array<float,2>{0.528630793f, 0.709059656f},
std::array<float,2>{0.189547226f, 0.246619284f},
std::array<float,2>{0.405301899f, 0.917849958f},
std::array<float,2>{0.886044383f, 0.314784974f},
std::array<float,2>{0.671810985f, 0.802754402f},
std::array<float,2>{0.000324942375f, 0.480655134f},
std::array<float,2>{0.275433302f, 0.558547258f},
std::array<float,2>{0.832147956f, 0.0295557026f},
std::array<float,2>{0.990077853f, 0.667674065f},
std::array<float,2>{0.455541342f, 0.144068256f},
std::array<float,2>{0.148355037f, 0.943685353f},
std::array<float,2>{0.61072892f, 0.300177902f},
std::array<float,2>{0.775352538f, 0.910766304f},
std::array<float,2>{0.317666292f, 0.325174749f},
std::array<float,2>{0.0907703862f, 0.71508491f},
std::array<float,2>{0.726389289f, 0.240557596f},
std::array<float,2>{0.549381196f, 0.615948081f},
std::array<float,2>{0.249265879f, 0.1209976f},
std::array<float,2>{0.406925678f, 0.815087914f},
std::array<float,2>{0.909626901f, 0.419297397f},
std::array<float,2>{0.568108439f, 0.990037799f},
std::array<float,2>{0.159233466f, 0.27977249f},
std::array<float,2>{0.495550662f, 0.64095217f},
std::array<float,2>{0.964821398f, 0.15749675f},
std::array<float,2>{0.848857522f, 0.504433215f},
std::array<float,2>{0.311655641f, 0.0367011875f},
std::array<float,2>{0.0557394922f, 0.757901788f},
std::array<float,2>{0.641762972f, 0.455182016f},
std::array<float,2>{0.882533133f, 0.867547512f},
std::array<float,2>{0.397032857f, 0.388600945f},
std::array<float,2>{0.200449064f, 0.570305526f},
std::array<float,2>{0.520729005f, 0.0633825287f},
std::array<float,2>{0.712483466f, 0.743906856f},
std::array<float,2>{0.100227118f, 0.213981256f},
std::array<float,2>{0.359145969f, 0.88787514f},
std::array<float,2>{0.812224746f, 0.361484855f},
std::array<float,2>{0.51302743f, 0.841694891f},
std::array<float,2>{0.203745276f, 0.425081193f},
std::array<float,2>{0.377342939f, 0.608909786f},
std::array<float,2>{0.902070105f, 0.0970447883f},
std::array<float,2>{0.788813174f, 0.700754642f},
std::array<float,2>{0.361021012f, 0.229857177f},
std::array<float,2>{0.11831639f, 0.925895452f},
std::array<float,2>{0.694250941f, 0.339665473f},
std::array<float,2>{0.945623815f, 0.964868546f},
std::array<float,2>{0.483894378f, 0.294244468f},
std::array<float,2>{0.18391338f, 0.67522192f},
std::array<float,2>{0.580870628f, 0.139468446f},
std::array<float,2>{0.638667583f, 0.540885031f},
std::array<float,2>{0.0431248732f, 0.00574070681f},
std::array<float,2>{0.294899344f, 0.7857669f},
std::array<float,2>{0.865108073f, 0.494005501f},
std::array<float,2>{0.746537685f, 0.891416132f},
std::array<float,2>{0.0690218881f, 0.355833918f},
std::array<float,2>{0.337662935f, 0.733901262f},
std::array<float,2>{0.76023823f, 0.194954067f},
std::array<float,2>{0.930638134f, 0.590374529f},
std::array<float,2>{0.427869916f, 0.0888712183f},
std::array<float,2>{0.23403427f, 0.85089761f},
std::array<float,2>{0.534320354f, 0.395347476f},
std::array<float,2>{0.814294517f, 0.765797734f},
std::array<float,2>{0.259614021f, 0.450032264f},
std::array<float,2>{0.0275649019f, 0.529436409f},
std::array<float,2>{0.684260726f, 0.0583155565f},
std::array<float,2>{0.606545806f, 0.634873867f},
std::array<float,2>{0.133968368f, 0.178304404f},
std::array<float,2>{0.446266502f, 0.975507379f},
std::array<float,2>{0.970256507f, 0.255795151f},
std::array<float,2>{0.62989068f, 0.818643272f},
std::array<float,2>{0.0360417515f, 0.416187584f},
std::array<float,2>{0.287634969f, 0.609784245f},
std::array<float,2>{0.872681797f, 0.12332917f},
std::array<float,2>{0.939349651f, 0.713555634f},
std::array<float,2>{0.470389485f, 0.236689016f},
std::array<float,2>{0.178656429f, 0.906945705f},
std::array<float,2>{0.586972058f, 0.322966784f},
std::array<float,2>{0.789504409f, 0.940183997f},
std::array<float,2>{0.368868381f, 0.303966552f},
std::array<float,2>{0.116459675f, 0.66856581f},
std::array<float,2>{0.700766146f, 0.146809205f},
std::array<float,2>{0.500386238f, 0.561025441f},
std::array<float,2>{0.21530138f, 0.0254315231f},
std::array<float,2>{0.389898449f, 0.798411667f},
std::array<float,2>{0.893381119f, 0.479794532f},
std::array<float,2>{0.595423758f, 0.884804308f},
std::array<float,2>{0.130336478f, 0.365626603f},
std::array<float,2>{0.438478827f, 0.747570038f},
std::array<float,2>{0.980083466f, 0.215603635f},
std::array<float,2>{0.825356185f, 0.563122213f},
std::array<float,2>{0.253829151f, 0.0699944198f},
std::array<float,2>{0.016233284f, 0.87233448f},
std::array<float,2>{0.679087877f, 0.385962903f},
std::array<float,2>{0.924386859f, 0.765590191f},
std::array<float,2>{0.431991339f, 0.457576483f},
std::array<float,2>{0.225798368f, 0.503429234f},
std::array<float,2>{0.545979202f, 0.0347420983f},
std::array<float,2>{0.739149988f, 0.64548552f},
std::array<float,2>{0.072034508f, 0.161816999f},
std::array<float,2>{0.333664268f, 0.985356927f},
std::array<float,2>{0.75346601f, 0.276282519f},
std::array<float,2>{0.557866335f, 0.78239429f},
std::array<float,2>{0.24137713f, 0.496649474f},
std::array<float,2>{0.419146657f, 0.543229222f},
std::array<float,2>{0.919702291f, 0.00177309546f},
std::array<float,2>{0.772708297f, 0.679502428f},
std::array<float,2>{0.32429412f, 0.134658873f},
std::array<float,2>{0.0805400461f, 0.963792562f},
std::array<float,2>{0.733731806f, 0.291354626f},
std::array<float,2>{0.99314636f, 0.922498107f},
std::array<float,2>{0.467715144f, 0.341475159f},
std::array<float,2>{0.154758155f, 0.699171305f},
std::array<float,2>{0.623522103f, 0.232501671f},
std::array<float,2>{0.663255751f, 0.604626238f},
std::array<float,2>{0.00884097349f, 0.0977948681f},
std::array<float,2>{0.27072522f, 0.83692199f},
std::array<float,2>{0.842006445f, 0.426999807f},
std::array<float,2>{0.710516632f, 0.968955159f},
std::array<float,2>{0.102434337f, 0.250677973f},
std::array<float,2>{0.345521659f, 0.637080252f},
std::array<float,2>{0.797042489f, 0.17491813f},
std::array<float,2>{0.888148248f, 0.525073946f},
std::array<float,2>{0.400380343f, 0.060861554f},
std::array<float,2>{0.194789588f, 0.771382928f},
std::array<float,2>{0.526408494f, 0.446370363f},
std::array<float,2>{0.85802722f, 0.847524703f},
std::array<float,2>{0.299457848f, 0.392510384f},
std::array<float,2>{0.0496506765f, 0.586719394f},
std::array<float,2>{0.649065495f, 0.089913711f},
std::array<float,2>{0.576707482f, 0.727735519f},
std::array<float,2>{0.170347735f, 0.187941596f},
std::array<float,2>{0.485352248f, 0.895252168f},
std::array<float,2>{0.95778811f, 0.354337424f},
std::array<float,2>{0.719847798f, 0.77937001f},
std::array<float,2>{0.0861710086f, 0.442285269f},
std::array<float,2>{0.313201696f, 0.521580279f},
std::array<float,2>{0.780064166f, 0.0497566275f},
std::array<float,2>{0.910844743f, 0.627288282f},
std::array<float,2>{0.411399275f, 0.185315177f},
std::array<float,2>{0.242596239f, 0.980662346f},
std::array<float,2>{0.553151608f, 0.258133054f},
std::array<float,2>{0.828270853f, 0.902623236f},
std::array<float,2>{0.280664235f, 0.34925133f},
std::array<float,2>{0.00727817137f, 0.723566592f},
std::array<float,2>{0.665762722f, 0.20157975f},
std::array<float,2>{0.613964379f, 0.579256237f},
std::array<float,2>{0.141306713f, 0.0849299207f},
std::array<float,2>{0.457676858f, 0.85725832f},
std::array<float,2>{0.985355198f, 0.398623884f},
std::array<float,2>{0.518989205f, 0.958584249f},
std::array<float,2>{0.197793677f, 0.285363853f},
std::array<float,2>{0.394154549f, 0.684025943f},
std::array<float,2>{0.878128946f, 0.131867319f},
std::array<float,2>{0.806655049f, 0.53441f},
std::array<float,2>{0.354551047f, 0.0100483326f},
std::array<float,2>{0.0953438804f, 0.79242152f},
std::array<float,2>{0.716145277f, 0.485528022f},
std::array<float,2>{0.965189099f, 0.835472107f},
std::array<float,2>{0.497446209f, 0.434669703f},
std::array<float,2>{0.162336528f, 0.601232231f},
std::array<float,2>{0.56505543f, 0.105192825f},
std::array<float,2>{0.647334158f, 0.688341916f},
std::array<float,2>{0.0607104264f, 0.221406564f},
std::array<float,2>{0.305438399f, 0.931773245f},
std::array<float,2>{0.844970405f, 0.331243634f},
std::array<float,2>{0.583398223f, 0.866898656f},
std::array<float,2>{0.181118026f, 0.375493854f},
std::array<float,2>{0.47892803f, 0.573526502f},
std::array<float,2>{0.950202167f, 0.0738686249f},
std::array<float,2>{0.861735344f, 0.740847826f},
std::array<float,2>{0.290492207f, 0.203245386f},
std::array<float,2>{0.0421870872f, 0.880881131f},
std::array<float,2>{0.636683464f, 0.373454213f},
std::array<float,2>{0.905726016f, 0.994517565f},
std::array<float,2>{0.38058126f, 0.272478729f},
std::array<float,2>{0.209786102f, 0.648825526f},
std::array<float,2>{0.51050818f, 0.170301959f},
std::array<float,2>{0.690633357f, 0.511753142f},
std::array<float,2>{0.124420531f, 0.0402318239f},
std::array<float,2>{0.36497888f, 0.757564187f},
std::array<float,2>{0.785059452f, 0.462824404f},
std::array<float,2>{0.679955184f, 0.918120623f},
std::array<float,2>{0.0268565919f, 0.319140762f},
std::array<float,2>{0.265161008f, 0.703166068f},
std::array<float,2>{0.819427133f, 0.244533956f},
std::array<float,2>{0.976559997f, 0.618101776f},
std::array<float,2>{0.451815397f, 0.110600866f},
std::array<float,2>{0.13776283f, 0.824376881f},
std::array<float,2>{0.602990806f, 0.407213658f},
std::array<float,2>{0.762914777f, 0.808302939f},
std::array<float,2>{0.341947049f, 0.47259593f},
std::array<float,2>{0.066258058f, 0.550240934f},
std::array<float,2>{0.74530673f, 0.0174644738f},
std::array<float,2>{0.538255632f, 0.659530401f},
std::array<float,2>{0.229889542f, 0.155200422f},
std::array<float,2>{0.423738211f, 0.951553583f},
std::array<float,2>{0.935133874f, 0.31156233f},
std::array<float,2>{0.735863268f, 0.831193566f},
std::array<float,2>{0.0758459121f, 0.431905895f},
std::array<float,2>{0.329015851f, 0.597039819f},
std::array<float,2>{0.754553378f, 0.107782215f},
std::array<float,2>{0.926744819f, 0.693079412f},
std::array<float,2>{0.435357392f, 0.224122137f},
std::array<float,2>{0.219441816f, 0.934031606f},
std::array<float,2>{0.539372861f, 0.334001988f},
std::array<float,2>{0.823289752f, 0.956479549f},
std::array<float,2>{0.257565051f, 0.285024136f},
std::array<float,2>{0.0197327752f, 0.683550298f},
std::array<float,2>{0.674245298f, 0.125283614f},
std::array<float,2>{0.600932777f, 0.535428047f},
std::array<float,2>{0.128905252f, 0.0141340215f},
std::array<float,2>{0.443190664f, 0.796661973f},
std::array<float,2>{0.981843054f, 0.490259707f},
std::array<float,2>{0.50458777f, 0.899196625f},
std::array<float,2>{0.213149697f, 0.346307904f},
std::array<float,2>{0.386377752f, 0.721102476f},
std::array<float,2>{0.89482975f, 0.196197882f},
std::array<float,2>{0.794700563f, 0.585934162f},
std::array<float,2>{0.372597873f, 0.0819742456f},
std::array<float,2>{0.109387711f, 0.85239768f},
std::array<float,2>{0.695345521f, 0.406169027f},
std::array<float,2>{0.942478299f, 0.77595067f},
std::array<float,2>{0.475205034f, 0.441301733f},
std::array<float,2>{0.171994612f, 0.518014789f},
std::array<float,2>{0.59001708f, 0.0524477698f},
std::array<float,2>{0.626856089f, 0.628923416f},
std::array<float,2>{0.0313238986f, 0.182594404f},
std::array<float,2>{0.281368256f, 0.980351925f},
std::array<float,2>{0.868547022f, 0.26324749f},
std::array<float,2>{0.571020126f, 0.811553359f},
std::array<float,2>{0.166253433f, 0.474153996f},
std::array<float,2>{0.490592688f, 0.553634226f},
std::array<float,2>{0.956486046f, 0.0197319183f},
std::array<float,2>{0.853859842f, 0.660611093f},
std::array<float,2>{0.303567916f, 0.149151847f},
std::array<float,2>{0.052893199f, 0.945704222f},
std::array<float,2>{0.654896975f, 0.306663603f},
std::array<float,2>{0.883392513f, 0.914215505f},
std::array<float,2>{0.402892679f, 0.313822657f},
std::array<float,2>{0.188957095f, 0.707662225f},
std::array<float,2>{0.529964983f, 0.248674124f},
std::array<float,2>{0.706904292f, 0.624295413f},
std::array<float,2>{0.108569883f, 0.115930229f},
std::array<float,2>{0.350860834f, 0.820774198f},
std::array<float,2>{0.80079037f, 0.412016273f},
std::array<float,2>{0.660092115f, 0.998631299f},
std::array<float,2>{0.0148015013f, 0.266563863f},
std::array<float,2>{0.268006146f, 0.655586421f},
std::array<float,2>{0.838451505f, 0.166590825f},
std::array<float,2>{0.999267757f, 0.510205209f},
std::array<float,2>{0.464642137f, 0.0460072495f},
std::array<float,2>{0.150894091f, 0.751596689f},
std::array<float,2>{0.619357765f, 0.467675239f},
std::array<float,2>{0.767459333f, 0.86100322f},
std::array<float,2>{0.322399199f, 0.380373627f},
std::array<float,2>{0.0849865377f, 0.575160325f},
std::array<float,2>{0.728461087f, 0.0772160441f},
std::array<float,2>{0.562140167f, 0.734924793f},
std::array<float,2>{0.234449476f, 0.210123643f},
std::array<float,2>{0.416671246f, 0.877278805f},
std::array<float,2>{0.916066527f, 0.367816329f},
std::array<float,2>{0.643701136f, 0.761485636f},
std::array<float,2>{0.058021687f, 0.454354167f},
std::array<float,2>{0.309241623f, 0.507005632f},
std::array<float,2>{0.850073576f, 0.0373768508f},
std::array<float,2>{0.96165514f, 0.643189788f},
std::array<float,2>{0.49310869f, 0.158994228f},
std::array<float,2>{0.157030255f, 0.991807878f},
std::array<float,2>{0.569172263f, 0.277811855f},
std::array<float,2>{0.809203923f, 0.890315235f},
std::array<float,2>{0.356015861f, 0.360622108f},
std::array<float,2>{0.0994864106f, 0.745622158f},
std::array<float,2>{0.714405775f, 0.211505473f},
std::array<float,2>{0.522676826f, 0.566965163f},
std::array<float,2>{0.202291355f, 0.0663254187f},
std::array<float,2>{0.395290822f, 0.870962024f},
std::array<float,2>{0.880809188f, 0.389860302f},
std::array<float,2>{0.612056911f, 0.941500664f},
std::array<float,2>{0.145439729f, 0.297920614f},
std::array<float,2>{0.45421797f, 0.665138423f},
std::array<float,2>{0.990254879f, 0.141281754f},
std::array<float,2>{0.835668087f, 0.555792809f},
std::array<float,2>{0.274484843f, 0.0282683689f},
std::array<float,2>{0.00207395595f, 0.80111599f},
std::array<float,2>{0.66863662f, 0.482829869f},
std::array<float,2>{0.907947302f, 0.814382792f},
std::array<float,2>{0.409004956f, 0.421172768f},
std::array<float,2>{0.246508628f, 0.615028322f},
std::array<float,2>{0.547569215f, 0.118793324f},
std::array<float,2>{0.72319001f, 0.718550622f},
std::array<float,2>{0.0929890275f, 0.239775151f},
std::array<float,2>{0.319749087f, 0.913631976f},
std::array<float,2>{0.776820958f, 0.326444656f},
std::array<float,2>{0.531907856f, 0.84868592f},
std::array<float,2>{0.232098177f, 0.397032142f},
std::array<float,2>{0.427362531f, 0.591807663f},
std::array<float,2>{0.93312186f, 0.0862998143f},
std::array<float,2>{0.759189546f, 0.731972039f},
std::array<float,2>{0.338680804f, 0.192783669f},
std::array<float,2>{0.0669766814f, 0.893978715f},
std::array<float,2>{0.749200106f, 0.357555449f},
std::array<float,2>{0.971348643f, 0.973829627f},
std::array<float,2>{0.449106663f, 0.256900191f},
std::array<float,2>{0.135756299f, 0.633742809f},
std::array<float,2>{0.608208239f, 0.176968932f},
std::array<float,2>{0.686536968f, 0.529023349f},
std::array<float,2>{0.0297198128f, 0.0546994992f},
std::array<float,2>{0.261126995f, 0.769066334f},
std::array<float,2>{0.816041231f, 0.451735646f},
std::array<float,2>{0.69292295f, 0.92803365f},
std::array<float,2>{0.119164988f, 0.336152345f},
std::array<float,2>{0.362397581f, 0.701307833f},
std::array<float,2>{0.786838889f, 0.227164388f},
std::array<float,2>{0.899284065f, 0.606849313f},
std::array<float,2>{0.375040829f, 0.0955601856f},
std::array<float,2>{0.205217078f, 0.843356133f},
std::array<float,2>{0.515022576f, 0.422067493f},
std::array<float,2>{0.866612315f, 0.788942814f},
std::array<float,2>{0.29552725f, 0.494389892f},
std::array<float,2>{0.0458950922f, 0.542446315f},
std::array<float,2>{0.638890684f, 0.00730829872f},
std::array<float,2>{0.578162551f, 0.671993554f},
std::array<float,2>{0.18637149f, 0.137994438f},
std::array<float,2>{0.481644511f, 0.968167126f},
std::array<float,2>{0.948888659f, 0.295713931f},
std::array<float,2>{0.676992476f, 0.874327123f},
std::array<float,2>{0.0190958157f, 0.383971959f},
std::array<float,2>{0.251391888f, 0.565511346f},
std::array<float,2>{0.827702224f, 0.0677656904f},
std::array<float,2>{0.977752447f, 0.749436855f},
std::array<float,2>{0.439491838f, 0.217967227f},
std::array<float,2>{0.131290764f, 0.883592784f},
std::array<float,2>{0.59685266f, 0.363725066f},
std::array<float,2>{0.750825584f, 0.986849546f},
std::array<float,2>{0.334643155f, 0.275200486f},
std::array<float,2>{0.07297194f, 0.648058355f},
std::array<float,2>{0.74089551f, 0.163044468f},
std::array<float,2>{0.544493198f, 0.50137645f},
std::array<float,2>{0.223974571f, 0.0327610709f},
std::array<float,2>{0.431388259f, 0.7630229f},
std::array<float,2>{0.922470927f, 0.459268034f},
std::array<float,2>{0.588017702f, 0.908707619f},
std::array<float,2>{0.176973626f, 0.320498526f},
std::array<float,2>{0.472375244f, 0.71284467f},
std::array<float,2>{0.940706015f, 0.234437272f},
std::array<float,2>{0.874626458f, 0.612168074f},
std::array<float,2>{0.286488652f, 0.121664546f},
std::array<float,2>{0.0389809497f, 0.81820029f},
std::array<float,2>{0.632071555f, 0.414977729f},
std::array<float,2>{0.892375588f, 0.799449742f},
std::array<float,2>{0.387180746f, 0.47828567f},
std::array<float,2>{0.216991708f, 0.559737265f},
std::array<float,2>{0.50303632f, 0.0253195781f},
std::array<float,2>{0.70205611f, 0.670816779f},
std::array<float,2>{0.113677539f, 0.144949332f},
std::array<float,2>{0.370299965f, 0.93771106f},
std::array<float,2>{0.791503012f, 0.302373141f},
std::array<float,2>{0.523790181f, 0.772107303f},
std::array<float,2>{0.192447782f, 0.44907704f},
std::array<float,2>{0.401455075f, 0.527292669f},
std::array<float,2>{0.889420331f, 0.0601064041f},
std::array<float,2>{0.799903631f, 0.639884353f},
std::array<float,2>{0.346263975f, 0.172537461f},
std::array<float,2>{0.105204336f, 0.971361816f},
std::array<float,2>{0.708570361f, 0.25306806f},
std::array<float,2>{0.959269106f, 0.89670378f},
std::array<float,2>{0.486482501f, 0.351699471f},
std::array<float,2>{0.169318467f, 0.729305208f},
std::array<float,2>{0.574227989f, 0.190008655f},
std::array<float,2>{0.651034832f, 0.588100731f},
std::array<float,2>{0.047832001f, 0.0933774561f},
std::array<float,2>{0.298318028f, 0.844816804f},
std::array<float,2>{0.8570804f, 0.393414199f},
std::array<float,2>{0.732375085f, 0.961956322f},
std::array<float,2>{0.0791268721f, 0.290641278f},
std::array<float,2>{0.326756179f, 0.677228749f},
std::array<float,2>{0.77046144f, 0.136419937f},
std::array<float,2>{0.921183348f, 0.545535088f},
std::array<float,2>{0.420865268f, 0.00377424853f},
std::array<float,2>{0.24019675f, 0.784689486f},
std::array<float,2>{0.554956198f, 0.499892473f},
std::array<float,2>{0.841722667f, 0.838554084f},
std::array<float,2>{0.272645235f, 0.428186834f},
std::array<float,2>{0.00996856485f, 0.602373719f},
std::array<float,2>{0.660914063f, 0.100493878f},
std::array<float,2>{0.622267425f, 0.69678396f},
std::array<float,2>{0.153272837f, 0.231071234f},
std::array<float,2>{0.466469496f, 0.924403906f},
std::array<float,2>{0.995506525f, 0.342289418f},
std::array<float,2>{0.717969f, 0.789370298f},
std::array<float,2>{0.096543029f, 0.487239867f},
std::array<float,2>{0.352175802f, 0.532673955f},
std::array<float,2>{0.806277573f, 0.00861823745f},
std::array<float,2>{0.876128256f, 0.685566306f},
std::array<float,2>{0.3908557f, 0.130589962f},
std::array<float,2>{0.196901023f, 0.959812105f},
std::array<float,2>{0.516608536f, 0.288652301f},
std::array<float,2>{0.846384287f, 0.929971814f},
std::array<float,2>{0.307804465f, 0.3295165f},
std::array<float,2>{0.0594196729f, 0.690645695f},
std::array<float,2>{0.64596051f, 0.219208688f},
std::array<float,2>{0.563522696f, 0.598453939f},
std::array<float,2>{0.161257222f, 0.101772062f},
std::array<float,2>{0.49827525f, 0.832961977f},
std::array<float,2>{0.968487561f, 0.437027156f},
std::array<float,2>{0.552529693f, 0.984328032f},
std::array<float,2>{0.245959327f, 0.259950846f},
std::array<float,2>{0.412269831f, 0.62613219f},
std::array<float,2>{0.91247189f, 0.186915338f},
std::array<float,2>{0.778126895f, 0.520487964f},
std::array<float,2>{0.315002084f, 0.0478576198f},
std::array<float,2>{0.0881046653f, 0.777625799f},
std::array<float,2>{0.722350419f, 0.443687856f},
std::array<float,2>{0.988068104f, 0.857434392f},
std::array<float,2>{0.460013062f, 0.401651949f},
std::array<float,2>{0.144268185f, 0.581818163f},
std::array<float,2>{0.615624666f, 0.0833853036f},
std::array<float,2>{0.667823732f, 0.726095915f},
std::array<float,2>{0.00524750119f, 0.200979888f},
std::array<float,2>{0.278112054f, 0.90593785f},
std::array<float,2>{0.831952572f, 0.350088805f},
std::array<float,2>{0.603711426f, 0.827633619f},
std::array<float,2>{0.14038451f, 0.408315986f},
std::array<float,2>{0.449283719f, 0.620561659f},
std::array<float,2>{0.9734025f, 0.11301136f},
std::array<float,2>{0.817822039f, 0.705366433f},
std::array<float,2>{0.262069106f, 0.242456138f},
std::array<float,2>{0.0250268914f, 0.92067039f},
std::array<float,2>{0.683010697f, 0.317660153f},
std::array<float,2>{0.937381327f, 0.950842321f},
std::array<float,2>{0.425636381f, 0.309156239f},
std::array<float,2>{0.228048787f, 0.656349421f},
std::array<float,2>{0.53675431f, 0.153389156f},
std::array<float,2>{0.743399382f, 0.547546446f},
std::array<float,2>{0.0639812276f, 0.0188676547f},
std::array<float,2>{0.341744125f, 0.804742396f},
std::array<float,2>{0.765201032f, 0.47045064f},
std::array<float,2>{0.634750962f, 0.878949523f},
std::array<float,2>{0.0405119285f, 0.371849477f},
std::array<float,2>{0.292748779f, 0.740143061f},
std::array<float,2>{0.860964656f, 0.20656611f},
std::array<float,2>{0.952198088f, 0.571609437f},
std::array<float,2>{0.478418827f, 0.0708700791f},
std::array<float,2>{0.181750908f, 0.864067078f},
std::array<float,2>{0.585318387f, 0.378342927f},
std::array<float,2>{0.781628966f, 0.755233407f},
std::array<float,2>{0.366920561f, 0.464055896f},
std::array<float,2>{0.122085206f, 0.515239894f},
std::array<float,2>{0.687646091f, 0.0412371345f},
std::array<float,2>{0.509734035f, 0.651030004f},
std::array<float,2>{0.207144022f, 0.168428943f},
std::array<float,2>{0.380990416f, 0.993964911f},
std::array<float,2>{0.90313822f, 0.270026803f},
std::array<float,2>{0.749719203f, 0.851222098f},
std::array<float,2>{0.0666207373f, 0.394728392f},
std::array<float,2>{0.338054419f, 0.589969575f},
std::array<float,2>{0.759556234f, 0.0895569921f},
std::array<float,2>{0.932775736f, 0.733447015f},
std::array<float,2>{0.427163869f, 0.194750264f},
std::array<float,2>{0.23192513f, 0.890891552f},
std::array<float,2>{0.531436384f, 0.356162637f},
std::array<float,2>{0.815654993f, 0.974789143f},
std::array<float,2>{0.261635572f, 0.255072862f},
std::array<float,2>{0.0301910732f, 0.635607481f},
std::array<float,2>{0.687354565f, 0.177887112f},
std::array<float,2>{0.60744524f, 0.53021121f},
std::array<float,2>{0.136443287f, 0.0577642284f},
std::array<float,2>{0.448423654f, 0.766412735f},
std::array<float,2>{0.970947206f, 0.449319124f},
std::array<float,2>{0.515375257f, 0.926603138f},
std::array<float,2>{0.205711529f, 0.339239568f},
std::array<float,2>{0.375589848f, 0.700530529f},
std::array<float,2>{0.898711205f, 0.230234817f},
std::array<float,2>{0.786318421f, 0.60885483f},
std::array<float,2>{0.363196611f, 0.0973215923f},
std::array<float,2>{0.119919941f, 0.84099102f},
std::array<float,2>{0.692465246f, 0.425756007f},
std::array<float,2>{0.948715746f, 0.785352349f},
std::array<float,2>{0.482379675f, 0.493316442f},
std::array<float,2>{0.185918048f, 0.540269554f},
std::array<float,2>{0.578986824f, 0.00516165327f},
std::array<float,2>{0.639558315f, 0.675437927f},
std::array<float,2>{0.0451579913f, 0.138973802f},
std::array<float,2>{0.295081288f, 0.965742528f},
std::array<float,2>{0.867116511f, 0.294630975f},
std::array<float,2>{0.568762124f, 0.758758843f},
std::array<float,2>{0.156395614f, 0.455686033f},
std::array<float,2>{0.492403358f, 0.504274189f},
std::array<float,2>{0.961293221f, 0.0362500101f},
std::array<float,2>{0.850218594f, 0.641323388f},
std::array<float,2>{0.308742136f, 0.15789403f},
std::array<float,2>{0.0582884401f, 0.989551842f},
std::array<float,2>{0.644492209f, 0.280154288f},
std::array<float,2>{0.880344868f, 0.88857913f},
std::array<float,2>{0.394671023f, 0.362235039f},
std::array<float,2>{0.203089297f, 0.743647099f},
std::array<float,2>{0.523147166f, 0.214783579f},
std::array<float,2>{0.714191556f, 0.569698155f},
std::array<float,2>{0.0989900753f, 0.0628602803f},
std::array<float,2>{0.355537683f, 0.867891371f},
std::array<float,2>{0.808594823f, 0.387770146f},
std::array<float,2>{0.66834408f, 0.943890035f},
std::array<float,2>{0.00282911072f, 0.300510108f},
std::array<float,2>{0.275188506f, 0.667399645f},
std::array<float,2>{0.834977925f, 0.143700376f},
std::array<float,2>{0.990798235f, 0.557899356f},
std::array<float,2>{0.454749882f, 0.0299076568f},
std::array<float,2>{0.144795537f, 0.803460062f},
std::array<float,2>{0.611389697f, 0.48108986f},
std::array<float,2>{0.77727139f, 0.814697266f},
std::array<float,2>{0.319958746f, 0.419741452f},
std::array<float,2>{0.0935427025f, 0.615519762f},
std::array<float,2>{0.722857177f, 0.120466448f},
std::array<float,2>{0.547290027f, 0.715487599f},
std::array<float,2>{0.246960893f, 0.240772203f},
std::array<float,2>{0.408591539f, 0.910618067f},
std::array<float,2>{0.907349169f, 0.324325949f},
std::array<float,2>{0.654631495f, 0.810213685f},
std::array<float,2>{0.0534324273f, 0.476516038f},
std::array<float,2>{0.302799076f, 0.552533984f},
std::array<float,2>{0.854077518f, 0.0226263069f},
std::array<float,2>{0.956701636f, 0.663340986f},
std::array<float,2>{0.491017669f, 0.150681272f},
std::array<float,2>{0.16678305f, 0.948736608f},
std::array<float,2>{0.570603967f, 0.306199312f},
std::array<float,2>{0.801314712f, 0.917110085f},
std::array<float,2>{0.351160437f, 0.315229177f},
std::array<float,2>{0.10894832f, 0.709937513f},
std::array<float,2>{0.706064582f, 0.246408224f},
std::array<float,2>{0.529560924f, 0.622991145f},
std::array<float,2>{0.189066559f, 0.11423748f},
std::array<float,2>{0.402717501f, 0.823428094f},
std::array<float,2>{0.882924199f, 0.412721395f},
std::array<float,2>{0.620071054f, 0.996750951f},
std::array<float,2>{0.150448233f, 0.269428015f},
std::array<float,2>{0.464100987f, 0.653752089f},
std::array<float,2>{0.999906182f, 0.165511474f},
std::array<float,2>{0.838021517f, 0.509445846f},
std::array<float,2>{0.268355638f, 0.0434187688f},
std::array<float,2>{0.0152651677f, 0.75273174f},
std::array<float,2>{0.659393609f, 0.466567218f},
std::array<float,2>{0.91661638f, 0.862190485f},
std::array<float,2>{0.416266173f, 0.381609261f},
std::array<float,2>{0.234940782f, 0.576420426f},
std::array<float,2>{0.561819613f, 0.0757879913f},
std::array<float,2>{0.727912545f, 0.737567902f},
std::array<float,2>{0.0858198032f, 0.208537221f},
std::array<float,2>{0.322835654f, 0.875693738f},
std::array<float,2>{0.766788363f, 0.369244337f},
std::array<float,2>{0.539629877f, 0.829064667f},
std::array<float,2>{0.21876727f, 0.430896848f},
std::array<float,2>{0.434592605f, 0.595189273f},
std::array<float,2>{0.926078379f, 0.107184753f},
std::array<float,2>{0.754309177f, 0.694047809f},
std::array<float,2>{0.328342676f, 0.224845663f},
std::array<float,2>{0.0754231513f, 0.93690145f},
std::array<float,2>{0.735570133f, 0.33277607f},
std::array<float,2>{0.982077122f, 0.954040587f},
std::array<float,2>{0.44247961f, 0.282518923f},
std::array<float,2>{0.127971515f, 0.681090355f},
std::array<float,2>{0.601362586f, 0.127496421f},
std::array<float,2>{0.674800992f, 0.538663924f},
std::array<float,2>{0.0203146804f, 0.0131235532f},
std::array<float,2>{0.256940126f, 0.794728577f},
std::array<float,2>{0.824122071f, 0.48895815f},
std::array<float,2>{0.696114182f, 0.900844336f},
std::array<float,2>{0.110302769f, 0.345441312f},
std::array<float,2>{0.3720752f, 0.719703794f},
std::array<float,2>{0.794060886f, 0.197603837f},
std::array<float,2>{0.895184755f, 0.58263433f},
std::array<float,2>{0.385981083f, 0.0798597857f},
std::array<float,2>{0.21385403f, 0.854574382f},
std::array<float,2>{0.504125953f, 0.40338546f},
std::array<float,2>{0.868725181f, 0.775194287f},
std::array<float,2>{0.282093555f, 0.438961715f},
std::array<float,2>{0.0322029479f, 0.517107427f},
std::array<float,2>{0.625993073f, 0.0529745072f},
std::array<float,2>{0.590384781f, 0.630929589f},
std::array<float,2>{0.172394231f, 0.180297703f},
std::array<float,2>{0.474792451f, 0.976776361f},
std::array<float,2>{0.942889094f, 0.264079064f},
std::array<float,2>{0.683302581f, 0.824973762f},
std::array<float,2>{0.0245383941f, 0.406401426f},
std::array<float,2>{0.262328416f, 0.61751622f},
std::array<float,2>{0.818203568f, 0.111059196f},
std::array<float,2>{0.972716212f, 0.703920841f},
std::array<float,2>{0.449747056f, 0.244723931f},
std::array<float,2>{0.14004983f, 0.918704152f},
std::array<float,2>{0.604366124f, 0.318380535f},
std::array<float,2>{0.764654756f, 0.951722264f},
std::array<float,2>{0.341296822f, 0.312115997f},
std::array<float,2>{0.0637619123f, 0.660069406f},
std::array<float,2>{0.743672729f, 0.154571176f},
std::array<float,2>{0.536396027f, 0.550659239f},
std::array<float,2>{0.22791861f, 0.0167052075f},
std::array<float,2>{0.424965173f, 0.807938397f},
std::array<float,2>{0.93678695f, 0.471755743f},
std::array<float,2>{0.585702538f, 0.88141644f},
std::array<float,2>{0.182578295f, 0.373696953f},
std::array<float,2>{0.477594823f, 0.740345955f},
std::array<float,2>{0.952809274f, 0.203910455f},
std::array<float,2>{0.860513508f, 0.574175358f},
std::array<float,2>{0.292125463f, 0.0735430196f},
std::array<float,2>{0.0406400003f, 0.866671741f},
std::array<float,2>{0.633949339f, 0.375217915f},
std::array<float,2>{0.902480006f, 0.757229447f},
std::array<float,2>{0.381426215f, 0.462259889f},
std::array<float,2>{0.207621083f, 0.512282491f},
std::array<float,2>{0.509271801f, 0.0405611172f},
std::array<float,2>{0.68809104f, 0.648975551f},
std::array<float,2>{0.122742712f, 0.170648769f},
std::array<float,2>{0.36667639f, 0.994903922f},
std::array<float,2>{0.781764209f, 0.273354709f},
std::array<float,2>{0.517426133f, 0.792777061f},
std::array<float,2>{0.196529299f, 0.486178935f},
std::array<float,2>{0.391348273f, 0.534955621f},
std::array<float,2>{0.876951039f, 0.0105849421f},
std::array<float,2>{0.806038439f, 0.684525967f},
std::array<float,2>{0.351701945f, 0.132718608f},
std::array<float,2>{0.0961674079f, 0.958159745f},
std::array<float,2>{0.718266368f, 0.285653323f},
std::array<float,2>{0.967901707f, 0.932599664f},
std::array<float,2>{0.498753935f, 0.331905842f},
std::array<float,2>{0.161782265f, 0.687880039f},
std::array<float,2>{0.564110398f, 0.220806301f},
std::array<float,2>{0.646376252f, 0.600768864f},
std::array<float,2>{0.059009023f, 0.10468474f},
std::array<float,2>{0.308408499f, 0.835058928f},
std::array<float,2>{0.845990539f, 0.435184032f},
std::array<float,2>{0.721818447f, 0.980965674f},
std::array<float,2>{0.0887009054f, 0.258656681f},
std::array<float,2>{0.314727038f, 0.627580941f},
std::array<float,2>{0.777493834f, 0.184830636f},
std::array<float,2>{0.912942588f, 0.522062361f},
std::array<float,2>{0.412670523f, 0.0491231158f},
std::array<float,2>{0.245484367f, 0.780221283f},
std::array<float,2>{0.552078724f, 0.441889226f},
std::array<float,2>{0.83118397f, 0.856808305f},
std::array<float,2>{0.277406037f, 0.398939043f},
std::array<float,2>{0.00554368924f, 0.580048978f},
std::array<float,2>{0.667207479f, 0.0840893909f},
std::array<float,2>{0.616153717f, 0.722729445f},
std::array<float,2>{0.143861428f, 0.201845959f},
std::array<float,2>{0.460460812f, 0.903064787f},
std::array<float,2>{0.987594128f, 0.348725945f},
std::array<float,2>{0.708181679f, 0.770703673f},
std::array<float,2>{0.104962207f, 0.446851611f},
std::array<float,2>{0.345790863f, 0.524799764f},
std::array<float,2>{0.800603569f, 0.0611510724f},
std::array<float,2>{0.888831198f, 0.637418091f},
std::array<float,2>{0.402339488f, 0.175327182f},
std::array<float,2>{0.192913696f, 0.969710767f},
std::array<float,2>{0.52422595f, 0.250270754f},
std::array<float,2>{0.85682559f, 0.894970775f},
std::array<float,2>{0.298576355f, 0.353613555f},
std::array<float,2>{0.046964474f, 0.728108108f},
std::array<float,2>{0.650502026f, 0.188415796f},
std::array<float,2>{0.575072408f, 0.586373091f},
std::array<float,2>{0.169528335f, 0.0907322243f},
std::array<float,2>{0.48726508f, 0.847136438f},
std::array<float,2>{0.959614217f, 0.391880155f},
std::array<float,2>{0.555642664f, 0.963007212f},
std::array<float,2>{0.239631176f, 0.291871607f},
std::array<float,2>{0.420407921f, 0.678777814f},
std::array<float,2>{0.921461165f, 0.13420926f},
std::array<float,2>{0.769817948f, 0.543469727f},
std::array<float,2>{0.326616257f, 0.00142118672f},
std::array<float,2>{0.0796380714f, 0.782996595f},
std::array<float,2>{0.731633186f, 0.496096641f},
std::array<float,2>{0.996037602f, 0.837646365f},
std::array<float,2>{0.466170967f, 0.427625388f},
std::array<float,2>{0.152359053f, 0.605338216f},
std::array<float,2>{0.622989714f, 0.0985027328f},
std::array<float,2>{0.660518587f, 0.698638141f},
std::array<float,2>{0.010534049f, 0.23317422f},
std::array<float,2>{0.2733531f, 0.922105968f},
std::array<float,2>{0.841134787f, 0.341178626f},
std::array<float,2>{0.597628951f, 0.872821867f},
std::array<float,2>{0.131750137f, 0.386673689f},
std::array<float,2>{0.4402982f, 0.562629998f},
std::array<float,2>{0.978212774f, 0.0697892904f},
std::array<float,2>{0.827264309f, 0.747555733f},
std::array<float,2>{0.251866907f, 0.215191439f},
std::array<float,2>{0.0188593138f, 0.885653138f},
std::array<float,2>{0.677528203f, 0.365849763f},
std::array<float,2>{0.922312081f, 0.986186862f},
std::array<float,2>{0.430942297f, 0.275847226f},
std::array<float,2>{0.224514097f, 0.644863188f},
std::array<float,2>{0.544349074f, 0.161277413f},
std::array<float,2>{0.740691245f, 0.503029048f},
std::array<float,2>{0.0722841993f, 0.0344291739f},
std::array<float,2>{0.334298342f, 0.764678478f},
std::array<float,2>{0.750222206f, 0.457292885f},
std::array<float,2>{0.632581234f, 0.906324804f},
std::array<float,2>{0.0382378101f, 0.322471797f},
std::array<float,2>{0.287013799f, 0.71331501f},
std::array<float,2>{0.874416232f, 0.237169564f},
std::array<float,2>{0.94121623f, 0.61008817f},
std::array<float,2>{0.47197476f, 0.123673975f},
std::array<float,2>{0.177329049f, 0.819158494f},
std::array<float,2>{0.588735521f, 0.416676134f},
std::array<float,2>{0.791690588f, 0.797872543f},
std::array<float,2>{0.370857626f, 0.480117559f},
std::array<float,2>{0.113860421f, 0.561294079f},
std::array<float,2>{0.701458097f, 0.0263342839f},
std::array<float,2>{0.503706634f, 0.668358624f},
std::array<float,2>{0.217675075f, 0.147308111f},
std::array<float,2>{0.387454361f, 0.939876616f},
std::array<float,2>{0.89173311f, 0.304534823f},
std::array<float,2>{0.693636179f, 0.8428635f},
std::array<float,2>{0.119029306f, 0.42279166f},
std::array<float,2>{0.360367626f, 0.607401371f},
std::array<float,2>{0.788370788f, 0.0947868973f},
std::array<float,2>{0.901373982f, 0.70183146f},
std::array<float,2>{0.377624154f, 0.226985916f},
std::array<float,2>{0.203550473f, 0.928579867f},
std::array<float,2>{0.513314486f, 0.336550862f},
std::array<float,2>{0.8643381f, 0.968652904f},
std::array<float,2>{0.294159353f, 0.29492715f},
std::array<float,2>{0.0439040586f, 0.672377765f},
std::array<float,2>{0.6381073f, 0.138343632f},
std::array<float,2>{0.580310881f, 0.54292649f},
std::array<float,2>{0.184390903f, 0.00736708427f},
std::array<float,2>{0.483856529f, 0.788535774f},
std::array<float,2>{0.94588238f, 0.495028853f},
std::array<float,2>{0.534968793f, 0.894096375f},
std::array<float,2>{0.233811662f, 0.358331591f},
std::array<float,2>{0.42857641f, 0.731593132f},
std::array<float,2>{0.930151761f, 0.193159506f},
std::array<float,2>{0.760336161f, 0.592734337f},
std::array<float,2>{0.337344825f, 0.0869093463f},
std::array<float,2>{0.0686303005f, 0.849336207f},
std::array<float,2>{0.746669114f, 0.396942556f},
std::array<float,2>{0.96985054f, 0.768875182f},
std::array<float,2>{0.445322573f, 0.451242417f},
std::array<float,2>{0.134639874f, 0.528491437f},
std::array<float,2>{0.607122898f, 0.0555784516f},
std::array<float,2>{0.684047759f, 0.633140326f},
std::array<float,2>{0.028289469f, 0.177527636f},
std::array<float,2>{0.258794099f, 0.974247813f},
std::array<float,2>{0.813928068f, 0.257718354f},
std::array<float,2>{0.611198664f, 0.801696956f},
std::array<float,2>{0.147774875f, 0.483030021f},
std::array<float,2>{0.455947399f, 0.556487322f},
std::array<float,2>{0.989554405f, 0.0275021289f},
std::array<float,2>{0.832796693f, 0.66584909f},
std::array<float,2>{0.2759552f, 0.140657917f},
std::array<float,2>{0.000649529975f, 0.941914618f},
std::array<float,2>{0.670979321f, 0.298540503f},
std::array<float,2>{0.90970403f, 0.913118184f},
std::array<float,2>{0.406528622f, 0.326821893f},
std::array<float,2>{0.249579459f, 0.717922032f},
std::array<float,2>{0.549000323f, 0.239356995f},
std::array<float,2>{0.725692451f, 0.614660323f},
std::array<float,2>{0.0900706127f, 0.118304215f},
std::array<float,2>{0.317985415f, 0.813904464f},
std::array<float,2>{0.774798512f, 0.421542883f},
std::array<float,2>{0.642290533f, 0.991345882f},
std::array<float,2>{0.056189537f, 0.278008103f},
std::array<float,2>{0.312092066f, 0.642969072f},
std::array<float,2>{0.849594235f, 0.158239409f},
std::array<float,2>{0.964227378f, 0.507443964f},
std::array<float,2>{0.496067911f, 0.0376357324f},
std::array<float,2>{0.15984568f, 0.761005282f},
std::array<float,2>{0.567712009f, 0.454784781f},
std::array<float,2>{0.811603963f, 0.870232701f},
std::array<float,2>{0.358496457f, 0.390301198f},
std::array<float,2>{0.0999462306f, 0.566703796f},
std::array<float,2>{0.712288678f, 0.0658429116f},
std::array<float,2>{0.521009445f, 0.745550275f},
std::array<float,2>{0.200742051f, 0.211419746f},
std::array<float,2>{0.396634877f, 0.889705479f},
std::array<float,2>{0.882321298f, 0.361234486f},
std::array<float,2>{0.657552719f, 0.751230597f},
std::array<float,2>{0.0123361805f, 0.467140615f},
std::array<float,2>{0.266455889f, 0.510476053f},
std::array<float,2>{0.837465942f, 0.0468209051f},
std::array<float,2>{0.997612298f, 0.655857623f},
std::array<float,2>{0.461037815f, 0.166175723f},
std::array<float,2>{0.149884418f, 0.998099029f},
std::array<float,2>{0.617903113f, 0.265707254f},
std::array<float,2>{0.767623544f, 0.877707779f},
std::array<float,2>{0.320489973f, 0.367558688f},
std::array<float,2>{0.0829417557f, 0.734623194f},
std::array<float,2>{0.729566216f, 0.210508987f},
std::array<float,2>{0.558737874f, 0.574294865f},
std::array<float,2>{0.237891942f, 0.0780812055f},
std::array<float,2>{0.414961129f, 0.860477865f},
std::array<float,2>{0.915073514f, 0.379888147f},
std::array<float,2>{0.572583079f, 0.946097493f},
std::array<float,2>{0.16536133f, 0.307471931f},
std::array<float,2>{0.48894763f, 0.66087538f},
std::array<float,2>{0.953946829f, 0.148656771f},
std::array<float,2>{0.852192819f, 0.553107917f},
std::array<float,2>{0.301719427f, 0.0201100316f},
std::array<float,2>{0.0516640171f, 0.812492251f},
std::array<float,2>{0.653472126f, 0.473919362f},
std::array<float,2>{0.886545956f, 0.82082361f},
std::array<float,2>{0.40584144f, 0.411413908f},
std::array<float,2>{0.190265447f, 0.624597728f},
std::array<float,2>{0.528952539f, 0.115380853f},
std::array<float,2>{0.703684449f, 0.707267225f},
std::array<float,2>{0.105615877f, 0.248425633f},
std::array<float,2>{0.348684669f, 0.914565742f},
std::array<float,2>{0.804654598f, 0.314422727f},
std::array<float,2>{0.506346941f, 0.851843178f},
std::array<float,2>{0.21273905f, 0.405305922f},
std::array<float,2>{0.38474825f, 0.585396767f},
std::array<float,2>{0.897576988f, 0.081338577f},
std::array<float,2>{0.796679199f, 0.721299171f},
std::array<float,2>{0.373638839f, 0.195788667f},
std::array<float,2>{0.112757906f, 0.898857892f},
std::array<float,2>{0.698471427f, 0.346094579f},
std::array<float,2>{0.944912851f, 0.979685247f},
std::array<float,2>{0.473857194f, 0.262933969f},
std::array<float,2>{0.1750395f, 0.629548788f},
std::array<float,2>{0.592642784f, 0.181664154f},
std::array<float,2>{0.627173901f, 0.518372118f},
std::array<float,2>{0.0336630084f, 0.0518663824f},
std::array<float,2>{0.283363611f, 0.77582854f},
std::array<float,2>{0.870156884f, 0.440908134f},
std::array<float,2>{0.73778826f, 0.934551597f},
std::array<float,2>{0.0776612759f, 0.334844887f},
std::array<float,2>{0.331731409f, 0.692688942f},
std::array<float,2>{0.755936801f, 0.223762691f},
std::array<float,2>{0.928891599f, 0.597494364f},
std::array<float,2>{0.437130481f, 0.108063765f},
std::array<float,2>{0.222149655f, 0.831701458f},
std::array<float,2>{0.542517424f, 0.432133555f},
std::array<float,2>{0.820534408f, 0.796347916f},
std::array<float,2>{0.254330397f, 0.490987062f},
std::array<float,2>{0.021875916f, 0.535663903f},
std::array<float,2>{0.6721223f, 0.0144156106f},
std::array<float,2>{0.598547518f, 0.682760894f},
std::array<float,2>{0.126335129f, 0.125786379f},
std::array<float,2>{0.44440794f, 0.95695287f},
std::array<float,2>{0.982984543f, 0.284239501f},
std::array<float,2>{0.635871172f, 0.863699317f},
std::array<float,2>{0.0425012894f, 0.37889275f},
std::array<float,2>{0.290536135f, 0.57184118f},
std::array<float,2>{0.86228174f, 0.0703127161f},
std::array<float,2>{0.950760126f, 0.739318013f},
std::array<float,2>{0.479272693f, 0.206526369f},
std::array<float,2>{0.181424007f, 0.879435718f},
std::array<float,2>{0.583519816f, 0.371241212f},
std::array<float,2>{0.784383357f, 0.993558764f},
std::array<float,2>{0.364387721f, 0.269698441f},
std::array<float,2>{0.124627769f, 0.65058738f},
std::array<float,2>{0.691190124f, 0.168532327f},
std::array<float,2>{0.510088503f, 0.515077353f},
std::array<float,2>{0.209155455f, 0.0416283049f},
std::array<float,2>{0.379959792f, 0.755543649f},
std::array<float,2>{0.905943274f, 0.464556545f},
std::array<float,2>{0.603413165f, 0.920063555f},
std::array<float,2>{0.138595328f, 0.317946076f},
std::array<float,2>{0.451441199f, 0.705964804f},
std::array<float,2>{0.976005673f, 0.242786512f},
std::array<float,2>{0.819863379f, 0.620716035f},
std::array<float,2>{0.265069872f, 0.112476483f},
std::array<float,2>{0.0264762584f, 0.82779038f},
std::array<float,2>{0.680197775f, 0.409047097f},
std::array<float,2>{0.934858859f, 0.805653811f},
std::array<float,2>{0.423278362f, 0.469746083f},
std::array<float,2>{0.230053023f, 0.547236383f},
std::array<float,2>{0.538695335f, 0.0193972569f},
std::array<float,2>{0.745933294f, 0.657126904f},
std::array<float,2>{0.0658929646f, 0.154269904f},
std::array<float,2>{0.342577875f, 0.950337887f},
std::array<float,2>{0.763290465f, 0.308733672f},
std::array<float,2>{0.553596199f, 0.778089702f},
std::array<float,2>{0.242731616f, 0.444290817f},
std::array<float,2>{0.411879957f, 0.519648373f},
std::array<float,2>{0.910382032f, 0.0485016741f},
std::array<float,2>{0.779588938f, 0.626933038f},
std::array<float,2>{0.312655896f, 0.187258944f},
std::array<float,2>{0.0867385715f, 0.983454883f},
std::array<float,2>{0.7207008f, 0.260551065f},
std::array<float,2>{0.98601371f, 0.905606985f},
std::array<float,2>{0.457141101f, 0.350239754f},
std::array<float,2>{0.140863106f, 0.725702345f},
std::array<float,2>{0.613458991f, 0.200529054f},
std::array<float,2>{0.665435731f, 0.581521869f},
std::array<float,2>{0.00778023433f, 0.0836379826f},
std::array<float,2>{0.280779064f, 0.857925892f},
std::array<float,2>{0.828799605f, 0.402101785f},
std::array<float,2>{0.716737509f, 0.959385097f},
std::array<float,2>{0.0951211303f, 0.288241863f},
std::array<float,2>{0.355371892f, 0.686433733f},
std::array<float,2>{0.807413876f, 0.129900143f},
std::array<float,2>{0.878671288f, 0.532977283f},
std::array<float,2>{0.393891066f, 0.00784364622f},
std::array<float,2>{0.197639063f, 0.79001087f},
std::array<float,2>{0.51927048f, 0.486498028f},
std::array<float,2>{0.84527266f, 0.832307577f},
std::array<float,2>{0.304965377f, 0.436673135f},
std::array<float,2>{0.061234355f, 0.598067582f},
std::array<float,2>{0.646528482f, 0.102494843f},
std::array<float,2>{0.564456582f, 0.691305995f},
std::array<float,2>{0.163066566f, 0.219668821f},
std::array<float,2>{0.497818738f, 0.930231929f},
std::array<float,2>{0.965427279f, 0.329746783f},
std::array<float,2>{0.733941495f, 0.784405529f},
std::array<float,2>{0.080865927f, 0.499477088f},
std::array<float,2>{0.324960619f, 0.545232415f},
std::array<float,2>{0.773370683f, 0.00319292722f},
std::array<float,2>{0.919013381f, 0.677517772f},
std::array<float,2>{0.419619679f, 0.135752037f},
std::array<float,2>{0.241832107f, 0.962581158f},
std::array<float,2>{0.558593154f, 0.29004854f},
std::array<float,2>{0.842602491f, 0.923940539f},
std::array<float,2>{0.271386176f, 0.342263192f},
std::array<float,2>{0.00943086669f, 0.696598649f},
std::array<float,2>{0.66397506f, 0.230528757f},
std::array<float,2>{0.623736322f, 0.601810873f},
std::array<float,2>{0.15505968f, 0.0998880938f},
std::array<float,2>{0.467229158f, 0.838220596f},
std::array<float,2>{0.992254674f, 0.428457379f},
std::array<float,2>{0.527274966f, 0.970831096f},
std::array<float,2>{0.194998905f, 0.253690898f},
std::array<float,2>{0.399851799f, 0.640187562f},
std::array<float,2>{0.888597548f, 0.172194362f},
std::array<float,2>{0.797539234f, 0.526382089f},
std::array<float,2>{0.344868928f, 0.0597493164f},
std::array<float,2>{0.101926655f, 0.771903217f},
std::array<float,2>{0.710135162f, 0.448279142f},
std::array<float,2>{0.957357645f, 0.845564902f},
std::array<float,2>{0.486070603f, 0.392649442f},
std::array<float,2>{0.170745119f, 0.58879751f},
std::array<float,2>{0.576327741f, 0.0931315646f},
std::array<float,2>{0.648442566f, 0.728613317f},
std::array<float,2>{0.0489575677f, 0.189924642f},
std::array<float,2>{0.299196571f, 0.89738822f},
std::array<float,2>{0.857655585f, 0.352188736f},
std::array<float,2>{0.587829351f, 0.817459524f},
std::array<float,2>{0.178194255f, 0.41415447f},
std::array<float,2>{0.470192254f, 0.61136353f},
std::array<float,2>{0.93855691f, 0.121578202f},
std::array<float,2>{0.87237376f, 0.711982012f},
std::array<float,2>{0.287372768f, 0.235077262f},
std::array<float,2>{0.0353094451f, 0.908493221f},
std::array<float,2>{0.630712867f, 0.321042329f},
std::array<float,2>{0.893064737f, 0.938092649f},
std::array<float,2>{0.390235484f, 0.301934004f},
std::array<float,2>{0.21569851f, 0.670346916f},
std::array<float,2>{0.500817716f, 0.145219401f},
std::array<float,2>{0.700427473f, 0.560378551f},
std::array<float,2>{0.116853617f, 0.0246480703f},
std::array<float,2>{0.368543237f, 0.79907757f},
std::array<float,2>{0.78997016f, 0.477905959f},
std::array<float,2>{0.679640889f, 0.883036792f},
std::array<float,2>{0.0156582538f, 0.364152551f},
std::array<float,2>{0.253322035f, 0.749529481f},
std::array<float,2>{0.826046765f, 0.218712196f},
std::array<float,2>{0.979778469f, 0.565969586f},
std::array<float,2>{0.439138621f, 0.0682080463f},
std::array<float,2>{0.13052085f, 0.874917865f},
std::array<float,2>{0.594990671f, 0.384737521f},
std::array<float,2>{0.753316224f, 0.763293743f},
std::array<float,2>{0.333236009f, 0.459936321f},
std::array<float,2>{0.0713072494f, 0.501730502f},
std::array<float,2>{0.738307059f, 0.0322547108f},
std::array<float,2>{0.546753883f, 0.647812009f},
std::array<float,2>{0.226519361f, 0.162490204f},
std::array<float,2>{0.432477832f, 0.986668944f},
std::array<float,2>{0.924083471f, 0.274580896f},
std::array<float,2>{0.711476982f, 0.868197262f},
std::array<float,2>{0.100851998f, 0.387088448f},
std::array<float,2>{0.357787132f, 0.56922698f},
std::array<float,2>{0.811078966f, 0.0635557696f},
std::array<float,2>{0.881346524f, 0.742761612f},
std::array<float,2>{0.397480756f, 0.213324219f},
std::array<float,2>{0.20007284f, 0.886765718f},
std::array<float,2>{0.519868314f, 0.362944782f},
std::array<float,2>{0.848094225f, 0.988578439f},
std::array<float,2>{0.310712457f, 0.280529529f},
std::array<float,2>{0.0552396066f, 0.642380893f},
std::array<float,2>{0.64149791f, 0.157051608f},
std::array<float,2>{0.566941082f, 0.505462229f},
std::array<float,2>{0.158335552f, 0.0353073962f},
std::array<float,2>{0.494267195f, 0.759572625f},
std::array<float,2>{0.963576853f, 0.45673731f},
std::array<float,2>{0.549910724f, 0.911367059f},
std::array<float,2>{0.248335332f, 0.325231254f},
std::array<float,2>{0.40748021f, 0.71666497f},
std::array<float,2>{0.908982873f, 0.241903856f},
std::array<float,2>{0.774314642f, 0.616430342f},
std::array<float,2>{0.316868871f, 0.119202346f},
std::array<float,2>{0.0911996067f, 0.81635195f},
std::array<float,2>{0.725396574f, 0.418630153f},
std::array<float,2>{0.988609076f, 0.804367125f},
std::array<float,2>{0.456559777f, 0.481799215f},
std::array<float,2>{0.146612957f, 0.556779027f},
std::array<float,2>{0.609742343f, 0.0303849932f},
std::array<float,2>{0.670790195f, 0.666411459f},
std::array<float,2>{0.00166255655f, 0.14285253f},
std::array<float,2>{0.277193397f, 0.944562674f},
std::array<float,2>{0.833394766f, 0.298985749f},
std::array<float,2>{0.606290638f, 0.766921282f},
std::array<float,2>{0.133122355f, 0.451082617f},
std::array<float,2>{0.44685781f, 0.530714512f},
std::array<float,2>{0.968798459f, 0.057020057f},
std::array<float,2>{0.813242376f, 0.636274636f},
std::array<float,2>{0.258670807f, 0.17957139f},
std::array<float,2>{0.0285069458f, 0.975946784f},
std::array<float,2>{0.68511343f, 0.254645139f},
std::array<float,2>{0.930946171f, 0.891893566f},
std::array<float,2>{0.429074168f, 0.356795669f},
std::array<float,2>{0.232623681f, 0.733194828f},
std::array<float,2>{0.533450782f, 0.193504885f},
std::array<float,2>{0.747643709f, 0.590952754f},
std::array<float,2>{0.0694873482f, 0.0888082907f},
std::array<float,2>{0.336879581f, 0.849951327f},
std::array<float,2>{0.761116922f, 0.395775139f},
std::array<float,2>{0.63690275f, 0.966097534f},
std::array<float,2>{0.0444847457f, 0.293551534f},
std::array<float,2>{0.293648094f, 0.674290836f},
std::array<float,2>{0.86404556f, 0.140063643f},
std::array<float,2>{0.947177947f, 0.539686799f},
std::array<float,2>{0.483326286f, 0.00485050073f},
std::array<float,2>{0.184980825f, 0.786722064f},
std::array<float,2>{0.581377625f, 0.49237749f},
std::array<float,2>{0.787169278f, 0.840297818f},
std::array<float,2>{0.359901011f, 0.423843175f},
std::array<float,2>{0.117281146f, 0.60823673f},
std::array<float,2>{0.694669306f, 0.096449025f},
std::array<float,2>{0.512215197f, 0.699886918f},
std::array<float,2>{0.204868123f, 0.229233116f},
std::array<float,2>{0.378567278f, 0.927453101f},
std::array<float,2>{0.901195109f, 0.338495165f},
std::array<float,2>{0.672923505f, 0.793717027f},
std::array<float,2>{0.0231413897f, 0.489282072f},
std::array<float,2>{0.254905194f, 0.537216842f},
std::array<float,2>{0.821983218f, 0.0121046854f},
std::array<float,2>{0.983678818f, 0.679845631f},
std::array<float,2>{0.444271833f, 0.128669322f},
std::array<float,2>{0.12564671f, 0.955016494f},
std::array<float,2>{0.598959446f, 0.281435728f},
std::array<float,2>{0.757057488f, 0.935938954f},
std::array<float,2>{0.330340326f, 0.333499253f},
std::array<float,2>{0.0768551379f, 0.694521487f},
std::array<float,2>{0.736361563f, 0.226100072f},
std::array<float,2>{0.541498303f, 0.594659448f},
std::array<float,2>{0.221193761f, 0.106347978f},
std::array<float,2>{0.436358303f, 0.829184651f},
std::array<float,2>{0.928548396f, 0.430050433f},
std::array<float,2>{0.592930198f, 0.978121102f},
std::array<float,2>{0.174446538f, 0.265186191f},
std::array<float,2>{0.473632693f, 0.632415056f},
std::array<float,2>{0.943554163f, 0.181460336f},
std::array<float,2>{0.869843304f, 0.516500711f},
std::array<float,2>{0.284571916f, 0.0543504581f},
std::array<float,2>{0.0346803963f, 0.774068475f},
std::array<float,2>{0.628536344f, 0.437729627f},
std::array<float,2>{0.896932364f, 0.854082108f},
std::array<float,2>{0.382894486f, 0.403166622f},
std::array<float,2>{0.211836055f, 0.583916128f},
std::array<float,2>{0.506900907f, 0.0789894983f},
std::array<float,2>{0.697914958f, 0.720528424f},
std::array<float,2>{0.112098388f, 0.198937446f},
std::array<float,2>{0.374987155f, 0.901909292f},
std::array<float,2>{0.795460463f, 0.344382197f},
std::array<float,2>{0.527407408f, 0.822922587f},
std::array<float,2>{0.191213325f, 0.413866669f},
std::array<float,2>{0.405054629f, 0.621289968f},
std::array<float,2>{0.885462523f, 0.114427581f},
std::array<float,2>{0.802998602f, 0.710274816f},
std::array<float,2>{0.347720563f, 0.247755945f},
std::array<float,2>{0.10671141f, 0.916357338f},
std::array<float,2>{0.704919815f, 0.316003889f},
std::array<float,2>{0.954242408f, 0.947283566f},
std::array<float,2>{0.490128249f, 0.304838002f},
std::array<float,2>{0.164404169f, 0.662748337f},
std::array<float,2>{0.573609769f, 0.152076215f},
std::array<float,2>{0.652750015f, 0.551404417f},
std::array<float,2>{0.0518102385f, 0.0215879101f},
std::array<float,2>{0.301860601f, 0.808659077f},
std::array<float,2>{0.853451908f, 0.475129962f},
std::array<float,2>{0.72891587f, 0.876924813f},
std::array<float,2>{0.0830434486f, 0.370954067f},
std::array<float,2>{0.321293205f, 0.73712188f},
std::array<float,2>{0.768687725f, 0.207997292f},
std::array<float,2>{0.914859176f, 0.577683806f},
std::array<float,2>{0.415641069f, 0.0745611116f},
std::array<float,2>{0.236733913f, 0.863229632f},
std::array<float,2>{0.560470104f, 0.38226077f},
std::array<float,2>{0.836398244f, 0.753614604f},
std::array<float,2>{0.267354071f, 0.465342402f},
std::array<float,2>{0.0135069583f, 0.50830555f},
std::array<float,2>{0.65682584f, 0.0444020368f},
std::array<float,2>{0.618429124f, 0.652809024f},
std::array<float,2>{0.148860171f, 0.164348677f},
std::array<float,2>{0.462643772f, 0.997638881f},
std::array<float,2>{0.996219814f, 0.267873317f},
std::array<float,2>{0.64797163f, 0.834831893f},
std::array<float,2>{0.0618059374f, 0.433977008f},
std::array<float,2>{0.306064516f, 0.599808335f},
std::array<float,2>{0.844544947f, 0.104340151f},
std::array<float,2>{0.966272354f, 0.688735604f},
std::array<float,2>{0.49687615f, 0.221739382f},
std::array<float,2>{0.163382232f, 0.933150232f},
std::array<float,2>{0.565783799f, 0.330322623f},
std::array<float,2>{0.808535457f, 0.957607687f},
std::array<float,2>{0.353565067f, 0.286543041f},
std::array<float,2>{0.0940212756f, 0.68501246f},
std::array<float,2>{0.715380609f, 0.131106198f},
std::array<float,2>{0.518150091f, 0.533412218f},
std::array<float,2>{0.198679373f, 0.0117158387f},
std::array<float,2>{0.39320448f, 0.791643202f},
std::array<float,2>{0.877641678f, 0.48514834f},
std::array<float,2>{0.614509642f, 0.903694093f},
std::array<float,2>{0.142133608f, 0.347756922f},
std::array<float,2>{0.458807319f, 0.724376738f},
std::array<float,2>{0.985334337f, 0.202529714f},
std::array<float,2>{0.83007741f, 0.579082072f},
std::array<float,2>{0.280106962f, 0.0857020617f},
std::array<float,2>{0.0066935434f, 0.856160283f},
std::array<float,2>{0.664654732f, 0.400314897f},
std::array<float,2>{0.911312401f, 0.780989349f},
std::array<float,2>{0.411052495f, 0.442672461f},
std::array<float,2>{0.244024575f, 0.523412824f},
std::array<float,2>{0.554131687f, 0.0506660379f},
std::array<float,2>{0.71951139f, 0.628007233f},
std::array<float,2>{0.0878291652f, 0.183692858f},
std::array<float,2>{0.314171642f, 0.982339561f},
std::array<float,2>{0.780764222f, 0.258954912f},
std::array<float,2>{0.537817836f, 0.807469964f},
std::array<float,2>{0.22889547f, 0.471002162f},
std::array<float,2>{0.422510535f, 0.548974156f},
std::array<float,2>{0.93413496f, 0.0165322684f},
std::array<float,2>{0.761859477f, 0.658914506f},
std::array<float,2>{0.343640029f, 0.156093806f},
std::array<float,2>{0.065086402f, 0.952892005f},
std::array<float,2>{0.744494498f, 0.310956627f},
std::array<float,2>{0.975287974f, 0.919845462f},
std::array<float,2>{0.45224601f, 0.319603175f},
std::array<float,2>{0.137690589f, 0.704623103f},
std::array<float,2>{0.602345407f, 0.245629668f},
std::array<float,2>{0.680695951f, 0.619088531f},
std::array<float,2>{0.0257882196f, 0.110328108f},
std::array<float,2>{0.264022976f, 0.825690448f},
std::array<float,2>{0.819188118f, 0.407845855f},
std::array<float,2>{0.690088451f, 0.995227098f},
std::array<float,2>{0.123168722f, 0.272205919f},
std::array<float,2>{0.363295913f, 0.649576843f},
std::array<float,2>{0.783261895f, 0.171747074f},
std::array<float,2>{0.904474556f, 0.512766838f},
std::array<float,2>{0.379538119f, 0.039230451f},
std::array<float,2>{0.210122108f, 0.756566405f},
std::array<float,2>{0.511406124f, 0.461841524f},
std::array<float,2>{0.862767816f, 0.86607486f},
std::array<float,2>{0.289560556f, 0.376872569f},
std::array<float,2>{0.0419516712f, 0.572557986f},
std::array<float,2>{0.635075867f, 0.0727849379f},
std::array<float,2>{0.582977712f, 0.741584122f},
std::array<float,2>{0.179851219f, 0.204507455f},
std::array<float,2>{0.47967875f, 0.882375181f},
std::array<float,2>{0.949283719f, 0.374888062f},
std::array<float,2>{0.740059912f, 0.764220536f},
std::array<float,2>{0.0707962885f, 0.458747983f},
std::array<float,2>{0.33210355f, 0.502090812f},
std::array<float,2>{0.752373517f, 0.0336998478f},
std::array<float,2>{0.925021648f, 0.645606935f},
std::array<float,2>{0.43346855f, 0.160258144f},
std::array<float,2>{0.224728093f, 0.984410703f},
std::array<float,2>{0.545073688f, 0.277000844f},
std::array<float,2>{0.82508558f, 0.886072099f},
std::array<float,2>{0.252295017f, 0.366926312f},
std::array<float,2>{0.0173822455f, 0.746637702f},
std::array<float,2>{0.6779989f, 0.215868428f},
std::array<float,2>{0.594097316f, 0.563551307f},
std::array<float,2>{0.129072919f, 0.0687047839f},
std::array<float,2>{0.438323975f, 0.871485233f},
std::array<float,2>{0.979342937f, 0.38547349f},
std::array<float,2>{0.501797676f, 0.940531671f},
std::array<float,2>{0.216190428f, 0.303313464f},
std::array<float,2>{0.388929516f, 0.669336736f},
std::array<float,2>{0.893666089f, 0.147871107f},
std::array<float,2>{0.79073596f, 0.562269986f},
std::array<float,2>{0.367323548f, 0.0264902208f},
std::array<float,2>{0.116189137f, 0.797147691f},
std::array<float,2>{0.699795008f, 0.478539348f},
std::array<float,2>{0.938314915f, 0.819866061f},
std::array<float,2>{0.468923986f, 0.417551875f},
std::array<float,2>{0.179634005f, 0.611193657f},
std::array<float,2>{0.586510897f, 0.124193579f},
std::array<float,2>{0.629856288f, 0.71418041f},
std::array<float,2>{0.0361647084f, 0.238015145f},
std::array<float,2>{0.288159192f, 0.907231569f},
std::array<float,2>{0.872038364f, 0.32374543f},
std::array<float,2>{0.577704549f, 0.84627074f},
std::array<float,2>{0.171316251f, 0.390937805f},
std::array<float,2>{0.485251188f, 0.587846696f},
std::array<float,2>{0.958398283f, 0.0908901915f},
std::array<float,2>{0.859215558f, 0.727078259f},
std::array<float,2>{0.300505847f, 0.189190254f},
std::array<float,2>{0.0502615906f, 0.895651579f},
std::array<float,2>{0.649703801f, 0.355201185f},
std::array<float,2>{0.887259245f, 0.970680594f},
std::array<float,2>{0.39909023f, 0.251181483f},
std::array<float,2>{0.194159806f, 0.638097346f},
std::array<float,2>{0.525656223f, 0.174716756f},
std::array<float,2>{0.70942992f, 0.524033487f},
std::array<float,2>{0.102795891f, 0.0622175038f},
std::array<float,2>{0.34453544f, 0.770410776f},
std::array<float,2>{0.798332691f, 0.446191192f},
std::array<float,2>{0.662285686f, 0.923105478f},
std::array<float,2>{0.00861349236f, 0.340668231f},
std::array<float,2>{0.270196706f, 0.697655261f},
std::array<float,2>{0.843228757f, 0.234198913f},
std::array<float,2>{0.993350923f, 0.603972018f},
std::array<float,2>{0.468443513f, 0.099320896f},
std::array<float,2>{0.155307174f, 0.835978925f},
std::array<float,2>{0.624517143f, 0.426100343f},
std::array<float,2>{0.772353053f, 0.781860292f},
std::array<float,2>{0.326049894f, 0.497750193f},
std::array<float,2>{0.0816797316f, 0.544336736f},
std::array<float,2>{0.733190596f, 0.000248887431f},
std::array<float,2>{0.557612777f, 0.678446054f},
std::array<float,2>{0.240578711f, 0.133385181f},
std::array<float,2>{0.41875267f, 0.964836657f},
std::array<float,2>{0.918014765f, 0.292102516f},
std::array<float,2>{0.724232793f, 0.812961996f},
std::array<float,2>{0.0927450806f, 0.420797557f},
std::array<float,2>{0.319092602f, 0.613574803f},
std::array<float,2>{0.776181281f, 0.117619731f},
std::array<float,2>{0.906459391f, 0.717095137f},
std::array<float,2>{0.409262776f, 0.238730192f},
std::array<float,2>{0.247369498f, 0.912717819f},
std::array<float,2>{0.54859972f, 0.327379495f},
std::array<float,2>{0.834109366f, 0.942749083f},
std::array<float,2>{0.273901582f, 0.297336072f},
std::array<float,2>{0.00326180761f, 0.664788604f},
std::array<float,2>{0.669769585f, 0.142094985f},
std::array<float,2>{0.612496972f, 0.555430412f},
std::array<float,2>{0.146127f, 0.0284616053f},
std::array<float,2>{0.453363359f, 0.802033365f},
std::array<float,2>{0.991432905f, 0.483776718f},
std::array<float,2>{0.522376418f, 0.889252901f},
std::array<float,2>{0.202050194f, 0.359548599f},
std::array<float,2>{0.395520538f, 0.744715154f},
std::array<float,2>{0.879311264f, 0.212219179f},
std::array<float,2>{0.809704781f, 0.567406237f},
std::array<float,2>{0.356655985f, 0.0651322007f},
std::array<float,2>{0.097957924f, 0.869899273f},
std::array<float,2>{0.712980628f, 0.389442652f},
std::array<float,2>{0.962594986f, 0.760733664f},
std::array<float,2>{0.493926257f, 0.453595608f},
std::array<float,2>{0.157993704f, 0.506722987f},
std::array<float,2>{0.569506824f, 0.0384932756f},
std::array<float,2>{0.642788172f, 0.643751323f},
std::array<float,2>{0.0575075708f, 0.159918129f},
std::array<float,2>{0.309691042f, 0.990771353f},
std::array<float,2>{0.851453245f, 0.279123634f},
std::array<float,2>{0.579978108f, 0.787984312f},
std::array<float,2>{0.187254593f, 0.495709807f},
std::array<float,2>{0.481385827f, 0.541220546f},
std::array<float,2>{0.948215485f, 0.0064181285f},
std::array<float,2>{0.865390539f, 0.67322284f},
std::array<float,2>{0.296177328f, 0.137007236f},
std::array<float,2>{0.0460213199f, 0.96692872f},
std::array<float,2>{0.639946759f, 0.29590863f},
std::array<float,2>{0.900317967f, 0.928729236f},
std::array<float,2>{0.376493603f, 0.337134063f},
std::array<float,2>{0.206556559f, 0.702940047f},
std::array<float,2>{0.514563739f, 0.227561429f},
std::array<float,2>{0.691469371f, 0.606399298f},
std::array<float,2>{0.121042475f, 0.0943905637f},
std::array<float,2>{0.361570001f, 0.842142642f},
std::array<float,2>{0.785168707f, 0.423584312f},
std::array<float,2>{0.686163127f, 0.972794056f},
std::array<float,2>{0.0304290876f, 0.256640643f},
std::array<float,2>{0.260616571f, 0.634153426f},
std::array<float,2>{0.814877808f, 0.176260307f},
std::array<float,2>{0.972617865f, 0.528257668f},
std::array<float,2>{0.44774124f, 0.0557934791f},
std::array<float,2>{0.135642469f, 0.768374324f},
std::array<float,2>{0.608823597f, 0.45243299f},
std::array<float,2>{0.758484602f, 0.84815532f},
std::array<float,2>{0.339560002f, 0.397827089f},
std::array<float,2>{0.0674445331f, 0.593693018f},
std::array<float,2>{0.748238087f, 0.0871720016f},
std::array<float,2>{0.532641232f, 0.730623245f},
std::array<float,2>{0.231136337f, 0.191852376f},
std::array<float,2>{0.426373124f, 0.892744124f},
std::array<float,2>{0.931676745f, 0.358605325f},
std::array<float,2>{0.625268996f, 0.776516974f},
std::array<float,2>{0.0325024948f, 0.440076143f},
std::array<float,2>{0.282965183f, 0.518862486f},
std::array<float,2>{0.867296994f, 0.0514769554f},
std::array<float,2>{0.941810369f, 0.630682051f},
std::array<float,2>{0.476199985f, 0.182780027f},
std::array<float,2>{0.173092231f, 0.978858173f},
std::array<float,2>{0.590878189f, 0.26221329f},
std::array<float,2>{0.793507457f, 0.899571478f},
std::array<float,2>{0.371368647f, 0.346851528f},
std::array<float,2>{0.110408112f, 0.722091377f},
std::array<float,2>{0.696408451f, 0.197045013f},
std::array<float,2>{0.505464077f, 0.584706843f},
std::array<float,2>{0.214155465f, 0.0805550292f},
std::array<float,2>{0.385616869f, 0.853130698f},
std::array<float,2>{0.896208107f, 0.404813349f},
std::array<float,2>{0.599654138f, 0.955281317f},
std::array<float,2>{0.127051964f, 0.284082979f},
std::array<float,2>{0.441665947f, 0.682272911f},
std::array<float,2>{0.981073141f, 0.126881421f},
std::array<float,2>{0.822605193f, 0.536471248f},
std::array<float,2>{0.256763875f, 0.0149852894f},
std::array<float,2>{0.0209018812f, 0.795600712f},
std::array<float,2>{0.675238371f, 0.492049158f},
std::array<float,2>{0.92700851f, 0.830419242f},
std::array<float,2>{0.433811128f, 0.433382332f},
std::array<float,2>{0.220382184f, 0.596137404f},
std::array<float,2>{0.54067868f, 0.108719416f},
std::array<float,2>{0.734711111f, 0.691515267f},
std::array<float,2>{0.0748514086f, 0.222866535f},
std::array<float,2>{0.329852521f, 0.934632421f},
std::array<float,2>{0.754929304f, 0.335571736f},
std::array<float,2>{0.561254799f, 0.85978961f},
std::array<float,2>{0.236022353f, 0.378992736f},
std::array<float,2>{0.417636812f, 0.575964153f},
std::array<float,2>{0.91774112f, 0.0770761073f},
std::array<float,2>{0.766138971f, 0.736323655f},
std::array<float,2>{0.32410273f, 0.209115922f},
std::array<float,2>{0.0846897811f, 0.878035486f},
std::array<float,2>{0.726648986f, 0.368487269f},
std::array<float,2>{0.998106837f, 0.999377906f},
std::array<float,2>{0.463415414f, 0.266885072f},
std::array<float,2>{0.151445478f, 0.654703259f},
std::array<float,2>{0.620466471f, 0.167009965f},
std::array<float,2>{0.659148335f, 0.511463046f},
std::array<float,2>{0.0145284999f, 0.0452751517f},
std::array<float,2>{0.268991351f, 0.750497699f},
std::array<float,2>{0.839835703f, 0.468139201f},
std::array<float,2>{0.705949664f, 0.915949047f},
std::array<float,2>{0.107631966f, 0.313357592f},
std::array<float,2>{0.349921137f, 0.708854079f},
std::array<float,2>{0.802381933f, 0.249497056f},
std::array<float,2>{0.883948445f, 0.62379235f},
std::array<float,2>{0.403707832f, 0.116511211f},
std::array<float,2>{0.188097775f, 0.821358025f},
std::array<float,2>{0.530523121f, 0.411056191f},
std::array<float,2>{0.855043411f, 0.811439455f},
std::array<float,2>{0.304442555f, 0.473385662f},
std::array<float,2>{0.0541951209f, 0.55418396f},
std::array<float,2>{0.655919373f, 0.021376526f},
std::array<float,2>{0.571550131f, 0.66165632f},
std::array<float,2>{0.167932689f, 0.149718761f},
std::array<float,2>{0.491383791f, 0.946291924f},
std::array<float,2>{0.955208719f, 0.308273256f},
std::array<float,2>{0.666401505f, 0.859186471f},
std::array<float,2>{0.00458693365f, 0.400760382f},
std::array<float,2>{0.278385729f, 0.580997109f},
std::array<float,2>{0.830695033f, 0.0828322321f},
std::array<float,2>{0.986828625f, 0.724910378f},
std::array<float,2>{0.459548652f, 0.19954057f},
std::array<float,2>{0.143142238f, 0.90465492f},
std::array<float,2>{0.617060184f, 0.350682646f},
std::array<float,2>{0.778546453f, 0.982849836f},
std::array<float,2>{0.316133261f, 0.260909677f},
std::array<float,2>{0.089300625f, 0.625737607f},
std::array<float,2>{0.721071482f, 0.186453894f},
std::array<float,2>{0.550794482f, 0.520595789f},
std::array<float,2>{0.244343832f, 0.0473882109f},
std::array<float,2>{0.413241655f, 0.77867198f},
std::array<float,2>{0.913122535f, 0.444975972f},
std::array<float,2>{0.56336683f, 0.931242228f},
std::array<float,2>{0.160348505f, 0.328969747f},
std::array<float,2>{0.499856412f, 0.689651012f},
std::array<float,2>{0.967667401f, 0.220389724f},
std::array<float,2>{0.847284555f, 0.599564254f},
std::array<float,2>{0.307063043f, 0.103257254f},
std::array<float,2>{0.0600573793f, 0.833095789f},
std::array<float,2>{0.644927859f, 0.435932696f},
std::array<float,2>{0.87516439f, 0.79074049f},
std::array<float,2>{0.391857117f, 0.487445474f},
std::array<float,2>{0.195327014f, 0.531279385f},
std::array<float,2>{0.516225278f, 0.00958888792f},
std::array<float,2>{0.717152536f, 0.686935544f},
std::array<float,2>{0.0968137085f, 0.129668638f},
std::array<float,2>{0.352664173f, 0.960668802f},
std::array<float,2>{0.805518508f, 0.287194848f},
std::array<float,2>{0.508136272f, 0.753965318f},
std::array<float,2>{0.208604708f, 0.463860154f},
std::array<float,2>{0.38253051f, 0.513794541f},
std::array<float,2>{0.904207289f, 0.0428125896f},
std::array<float,2>{0.78245914f, 0.652170479f},
std::array<float,2>{0.365755081f, 0.169134378f},
std::array<float,2>{0.121289395f, 0.992583692f},
std::array<float,2>{0.68898195f, 0.270514786f},
std::array<float,2>{0.951229692f, 0.880165815f},
std::array<float,2>{0.476893634f, 0.37270388f},
std::array<float,2>{0.183429956f, 0.738575697f},
std::array<float,2>{0.584254026f, 0.205305472f},
std::array<float,2>{0.633591533f, 0.570880592f},
std::array<float,2>{0.0397321358f, 0.0716746002f},
std::array<float,2>{0.291828632f, 0.864337146f},
std::array<float,2>{0.85966301f, 0.377034426f},
std::array<float,2>{0.742740929f, 0.949821472f},
std::array<float,2>{0.0632412732f, 0.310530514f},
std::array<float,2>{0.340346694f, 0.657930315f},
std::array<float,2>{0.764404535f, 0.153311238f},
std::array<float,2>{0.936152816f, 0.548073292f},
std::array<float,2>{0.42461279f, 0.0183894895f},
std::array<float,2>{0.226628721f, 0.80576098f},
std::array<float,2>{0.535878778f, 0.468857467f},
std::array<float,2>{0.816816688f, 0.826286256f},
std::array<float,2>{0.262853563f, 0.40969342f},
std::array<float,2>{0.0238388199f, 0.62007159f},
std::array<float,2>{0.68217063f, 0.111893155f},
std::array<float,2>{0.604617596f, 0.706697941f},
std::array<float,2>{0.139234066f, 0.243605122f},
std::array<float,2>{0.451135814f, 0.921185553f},
std::array<float,2>{0.974326372f, 0.316432714f},
std::array<float,2>{0.702711463f, 0.80019784f},
std::array<float,2>{0.114314727f, 0.477426112f},
std::array<float,2>{0.369325876f, 0.558981657f},
std::array<float,2>{0.792477429f, 0.0235049427f},
std::array<float,2>{0.890678525f, 0.671070457f},
std::array<float,2>{0.387886077f, 0.146392912f},
std::array<float,2>{0.218066484f, 0.939308524f},
std::array<float,2>{0.502387702f, 0.301507473f},
std::array<float,2>{0.873864591f, 0.90982753f},
std::array<float,2>{0.285948455f, 0.321900636f},
std::array<float,2>{0.0374377519f, 0.711387932f},
std::array<float,2>{0.630926907f, 0.236234635f},
std::array<float,2>{0.589532912f, 0.61278224f},
std::array<float,2>{0.176051602f, 0.123033769f},
std::array<float,2>{0.471068174f, 0.817133844f},
std::array<float,2>{0.940014184f, 0.415850878f},
std::array<float,2>{0.543112338f, 0.987905622f},
std::array<float,2>{0.22300531f, 0.273445904f},
std::array<float,2>{0.429955363f, 0.647291541f},
std::array<float,2>{0.923278809f, 0.16324231f},
std::array<float,2>{0.75126797f, 0.500483215f},
std::array<float,2>{0.335089743f, 0.0319417156f},
std::array<float,2>{0.0739412233f, 0.762496054f},
std::array<float,2>{0.741606832f, 0.460090458f},
std::array<float,2>{0.976891637f, 0.873951793f},
std::array<float,2>{0.440865904f, 0.38373819f},
std::array<float,2>{0.132245511f, 0.565312445f},
std::array<float,2>{0.596296489f, 0.0668421984f},
std::array<float,2>{0.67578274f, 0.748841465f},
std::array<float,2>{0.0181043595f, 0.216861397f},
std::array<float,2>{0.250605524f, 0.88448137f},
std::array<float,2>{0.826891005f, 0.364904523f},
std::array<float,2>{0.621557891f, 0.839282274f},
std::array<float,2>{0.153378233f, 0.429088086f},
std::array<float,2>{0.465067148f, 0.603249073f},
std::array<float,2>{0.994585574f, 0.100924507f},
std::array<float,2>{0.840251923f, 0.695600033f},
std::array<float,2>{0.272173911f, 0.231655434f},
std::array<float,2>{0.0110482741f, 0.925712109f},
std::array<float,2>{0.661358714f, 0.343112499f},
std::array<float,2>{0.920674324f, 0.961226463f},
std::array<float,2>{0.421723247f, 0.289312154f},
std::array<float,2>{0.239110664f, 0.676538527f},
std::array<float,2>{0.556574464f, 0.13555713f},
std::array<float,2>{0.730605185f, 0.546232581f},
std::array<float,2>{0.0782758296f, 0.00240111887f},
std::array<float,2>{0.32744661f, 0.783237398f},
std::array<float,2>{0.771088958f, 0.498825043f},
std::array<float,2>{0.652280867f, 0.898190022f},
std::array<float,2>{0.0487129018f, 0.352652907f},
std::array<float,2>{0.297252148f, 0.729945064f},
std::array<float,2>{0.855890274f, 0.191025108f},
std::array<float,2>{0.96035552f, 0.589390635f},
std::array<float,2>{0.487846136f, 0.0918459743f},
std::array<float,2>{0.168851122f, 0.844017684f},
std::array<float,2>{0.575290442f, 0.394014716f},
std::array<float,2>{0.799727738f, 0.772742689f},
std::array<float,2>{0.346918672f, 0.448067158f},
std::array<float,2>{0.10379447f, 0.525678396f},
std::array<float,2>{0.707263231f, 0.0591463894f},
std::array<float,2>{0.525092065f, 0.638697982f},
std::array<float,2>{0.191819936f, 0.173560441f},
std::array<float,2>{0.40062207f, 0.972327828f},
std::array<float,2>{0.890018165f, 0.252027243f}} |
Oakland police arrested a man who allegedly burglarized a car and later shot four people on Saturday afternoon.
Officers were dispatched to a shooting in the 1700 block of Telegraph Avenue at 4:10 p.m. Saturday, Oakland police Officer Johnna Watson said.
Prior to the shooting, the suspect allegedly broke into a car, stole items and fled, Watson said.
Police said witnesses chased down the suspect and recovered the property. The suspect then returned to the scene on a bicycle with a firearm.
He allegedly shot two women and two men then fled the scene, Watson said.
All four victims suffered gunshot wounds that are not considered life-threatening, according to police.
Police eventually arrested the suspect but have not released his identity pending review of the case by the Alameda County District Attorney's Office. |
import SectionHeader from '@celo/react-components/components/SectionHead'
import colors from '@celo/react-components/styles/colors'
import { componentStyles } from '@celo/react-components/styles/styles'
import variables from '@celo/react-components/styles/variables'
import * as React from 'react'
import { WithNamespaces, withNamespaces } from 'react-i18next'
import { ScrollView, StyleSheet, View } from 'react-native'
import SafeAreaView from 'react-native-safe-area-view'
import { connect } from 'react-redux'
import { EscrowedPayment } from 'src/escrow/actions'
import EscrowedPaymentListItem from 'src/escrow/EscrowedPaymentListItem'
import { getReclaimableEscrowPayments } from 'src/escrow/saga'
import { updatePaymentRequestStatus } from 'src/firebase/actions'
import i18n, { Namespaces } from 'src/i18n'
import { fetchPhoneAddresses } from 'src/identity/actions'
import { e164NumberToAddressSelector, E164NumberToAddressType } from 'src/identity/reducer'
import { headerWithBackButton } from 'src/navigator/Headers'
import PaymentRequestBalance from 'src/paymentRequest/PaymentRequestBalance'
import PaymentRequestListEmpty from 'src/paymentRequest/PaymentRequestListEmpty'
import { NumberToRecipient } from 'src/recipients/recipient'
import { recipientCacheSelector } from 'src/recipients/reducer'
import { RootState } from 'src/redux/reducers'
import DisconnectBanner from 'src/shared/DisconnectBanner'
const { contentPadding } = variables
interface StateProps {
dollarBalance: string | null
sentEscrowedPayments: EscrowedPayment[]
e164PhoneNumberAddressMapping: E164NumberToAddressType
recipientCache: NumberToRecipient
}
interface DispatchProps {
updatePaymentRequestStatus: typeof updatePaymentRequestStatus
fetchPhoneAddresses: typeof fetchPhoneAddresses
}
const mapStateToProps = (state: RootState): StateProps => ({
dollarBalance: state.stableToken.balance,
sentEscrowedPayments: getReclaimableEscrowPayments(state.escrow.sentEscrowedPayments),
e164PhoneNumberAddressMapping: e164NumberToAddressSelector(state),
recipientCache: recipientCacheSelector(state),
})
type Props = WithNamespaces & StateProps & DispatchProps
export class EscrowedPaymentListScreen extends React.Component<Props> {
static navigationOptions = () => ({
...headerWithBackButton,
headerTitle: i18n.t('inviteFlow11:pedningInvitations'),
})
renderRequest = (payment: EscrowedPayment, key: number, allPayments: EscrowedPayment[]) => {
return (
<View key={key}>
<EscrowedPaymentListItem payment={payment} />
{key < allPayments.length - 1 && <View style={styles.separator} />}
</View>
)
}
render() {
return (
<SafeAreaView style={styles.container}>
<DisconnectBanner />
<PaymentRequestBalance dollarBalance={this.props.dollarBalance} />
<SectionHeader text={this.props.t('payments')} />
{this.props.sentEscrowedPayments.length > 0 ? (
<ScrollView>
<View style={[componentStyles.roundedBorder, styles.scrollArea]}>
{this.props.sentEscrowedPayments.map(this.renderRequest)}
</View>
</ScrollView>
) : (
<PaymentRequestListEmpty />
)}
</SafeAreaView>
)
}
}
const styles = StyleSheet.create({
container: {
backgroundColor: colors.background,
flex: 1,
},
separator: {
borderBottomColor: colors.darkLightest,
borderBottomWidth: 1,
marginLeft: 50,
},
scrollArea: {
margin: contentPadding,
},
})
export default connect<StateProps, DispatchProps, {}, RootState>(
mapStateToProps,
{
updatePaymentRequestStatus,
fetchPhoneAddresses,
}
)(withNamespaces(Namespaces.global)(EscrowedPaymentListScreen))
|
package club.lylgjiang.main.listener;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;
public class NoBugListener implements ServletContextListener {
@Override
public void contextInitialized(ServletContextEvent sce) {
// 代码护体神兽
Logger log = LogManager.getLogger(NoBugListener.class);
log.debug(" \r\n ━━━━━━神兽出没━━━━━━\r\n" +
"\r\n" +
" ┏┓ ┏┓\r\n" +
"\r\n" +
" ┏┛┻━━━┛┻┓\r\n" +
"\r\n" +
" ┃ ━ ┃\r\n" +
"\r\n" +
" ┃ ┳┛ ┗┳ ┃\r\n" +
"\r\n" +
" ┃ ┻ ┃\r\n" +
"\r\n" +
" ┗━┓ ┏━┛Code is far away from bug with the animal protecting\r\n" +
"\r\n" +
" ┃ ┃ 神兽保佑,代码无bug\r\n" +
"\r\n" +
" ┃ ┗━━━┓\r\n" +
"\r\n" +
" ┃ ┣┓\r\n" +
"\r\n" +
" ┃ ┏┛\r\n" +
"\r\n" +
" ┗┓┓┏━┳┓┏┛\r\n" +
"\r\n" +
" ┗┻┛ ┗┻┛\r\n" +
"\r\n" +
" \r\n" +
"\r\n" +
" ━━━━━━bug消失━━━━━━");
}
@Override
public void contextDestroyed(ServletContextEvent sce) {
}
}
|
def sequence_from_system(self, system, attribute, default=None):
return list(itertools.chain(*(
self.sequence_from_mol(molecule, attribute, default)
for molecule in system.molecules
))) |
<filename>examples/tftp-model/generate-tftp-lus.py<gh_stars>10-100
#
# Copyright (C) 2017, <NAME>
# All rights reserved.
#
# This software may be modified and distributed under the terms
# of the 3-clause BSD license. See the LICENSE file for details.
#
import sys
MAX_PAYLOAD_LENGTH = 514;
TFTP_MODEL_BODY_FORMAT = '''
--
-- Copyright (C) 2017, <NAME>
-- All rights reserved.
--
-- This software may be modified and distributed under the terms
-- of the 3-clause BSD license. See the LICENSE file for details.
--
type uint16 = int;
const tftp_max_payload_size : int = %(max_payload_length)d;
const opcode_wrq = 1;
const opcode_rrq = 2;
const opcode_data = 3;
const opcode_ack = 4;
const opcode_error = 5;
const mode_fuzzed = 0;
const mode_netascii = 1;
const mode_octet = 2;
const mode_mail = 3;
const ascii_uc_a = 65;
const ascii_uc_c = 67;
const ascii_uc_e = 69;
const ascii_uc_i = 73;
const ascii_uc_l = 76;
const ascii_uc_m = 77;
const ascii_uc_n = 78;
const ascii_uc_o = 79;
const ascii_uc_s = 83;
const ascii_uc_t = 84;
const ascii_lc_a = 97;
const ascii_lc_c = 99;
const ascii_lc_e = 101;
const ascii_lc_i = 105;
const ascii_lc_l = 108;
const ascii_lc_m = 109;
const ascii_lc_n = 110;
const ascii_lc_o = 111;
const ascii_lc_s = 115;
const ascii_lc_t = 116;
node historically(x: bool) returns (r: bool);
let
r = x and (true -> (pre r));
tel
node once(x: bool) returns (r: bool);
let
r = x or (false -> (pre r));
tel
type TftpPacket = struct
{
opcode : uint16;
payload : int[%(max_payload_length)d]
};
function file_size() returns (r : int);
function filename_length() returns (r : int);
function mode_num() returns (r : int);
function mode_length() returns (r : int);
function error_msg_length(clock : int) returns (r : int);
function fuzz_block_number(clock : int) returns (r : bool);
function fuzz_block_size(clock : int) returns (r : bool);
function fuzzy_block_number(clock : int) returns (r : int);
function fuzzy_block_size(clock : int) returns (r : int);
function ascii_case(clock : int; offset : int) returns (r : int);
function payload(clock : int; addr : int) returns (r : int);
node mode_fuzzed_constraint(clock : int; offset : int) returns (r : bool);
let
r = (payload(clock, offset + mode_length()) = 0);
tel
node mode_netascii_constraint(clock : int; offset : int) returns (r : bool);
let
r = (mode_length() = 8)
and (payload(clock, offset + 0) = ascii_uc_n + (ascii_case(clock, 0) * (ascii_lc_n - ascii_uc_n)))
and (payload(clock, offset + 1) = ascii_uc_e + (ascii_case(clock, 1) * (ascii_lc_e - ascii_uc_e)))
and (payload(clock, offset + 2) = ascii_uc_t + (ascii_case(clock, 2) * (ascii_lc_t - ascii_uc_t)))
and (payload(clock, offset + 3) = ascii_uc_a + (ascii_case(clock, 3) * (ascii_lc_a - ascii_uc_a)))
and (payload(clock, offset + 4) = ascii_uc_s + (ascii_case(clock, 4) * (ascii_lc_s - ascii_uc_s)))
and (payload(clock, offset + 5) = ascii_uc_c + (ascii_case(clock, 5) * (ascii_lc_c - ascii_uc_c)))
and (payload(clock, offset + 6) = ascii_uc_i + (ascii_case(clock, 6) * (ascii_lc_i - ascii_uc_i)))
and (payload(clock, offset + 7) = ascii_uc_i + (ascii_case(clock, 7) * (ascii_lc_i - ascii_uc_i)))
and (payload(clock, offset + mode_length()) = 0);
tel
node mode_octet_constraint(clock : int; offset : int) returns (r : bool);
let
r = (mode_length() = 5)
and (payload(clock, offset + 0) = ascii_uc_o + (ascii_case(clock, 0) * (ascii_lc_o - ascii_uc_o)))
and (payload(clock, offset + 1) = ascii_uc_c + (ascii_case(clock, 1) * (ascii_lc_c - ascii_uc_c)))
and (payload(clock, offset + 2) = ascii_uc_t + (ascii_case(clock, 2) * (ascii_lc_t - ascii_uc_t)))
and (payload(clock, offset + 3) = ascii_uc_e + (ascii_case(clock, 3) * (ascii_lc_e - ascii_uc_e)))
and (payload(clock, offset + 4) = ascii_uc_t + (ascii_case(clock, 4) * (ascii_lc_t - ascii_uc_t)))
and (payload(clock, offset + mode_length()) = 0);
tel
node mode_mail_constraint(clock : int; offset : int) returns (r : bool);
let
r = (mode_length() = 4)
and (payload(clock, offset + 0) = ascii_uc_m + (ascii_case(clock, 0) * (ascii_lc_m - ascii_uc_m)))
and (payload(clock, offset + 1) = ascii_uc_a + (ascii_case(clock, 1) * (ascii_lc_a - ascii_uc_a)))
and (payload(clock, offset + 2) = ascii_uc_i + (ascii_case(clock, 2) * (ascii_lc_i - ascii_uc_i)))
and (payload(clock, offset + 3) = ascii_uc_l + (ascii_case(clock, 3) * (ascii_lc_l - ascii_uc_l)))
and (payload(clock, offset + mode_length()) = 0);
tel
node mode_constraint(clock : int; offset : int) returns (r : bool);
let
r = if (mode_num() = mode_fuzzed) then mode_fuzzed_constraint(clock, offset)
else if (mode_num() = mode_netascii) then mode_netascii_constraint(clock, offset)
else if (mode_num() = mode_octet) then mode_octet_constraint(clock, offset)
else if (mode_num() = mode_mail) then mode_mail_constraint(clock, offset)
else true;
tel
node main(msg: TftpPacket; payload_length : int) returns ();
var
clock : int;
block_number : int;
current_size : int;
remaining_size : int;
rrq_constraint : bool;
wrq_constraint : bool;
data_constraint : bool;
ack_constraint : bool;
error_constraint : bool;
fuzz_rrq : bool;
fuzz_wrq : bool;
fuzz_rrq_protocol : bool;
fuzz_wrq_protocol : bool;
fuzz_rrq_protocol_fuzzy_block_numbers : bool;
fuzz_wrq_protocol_fuzzy_block_numbers : bool;
fuzz_wrq_protocol_fuzzy_block_sizes : bool;
let
clock = 0 -> ((pre clock) + 1);
-- Input type assertions
-- TODO: Fuzz overflowing the payload size
-- Uninterpreted function assertions
assert(0 <= msg.opcode and msg.opcode < 65536);
assert(0 <= payload_length);
assert(0 < file_size());
assert(0 <= filename_length());
assert(mode_fuzzed <= mode_num() and mode_num() <= mode_mail);
assert(0 <= mode_length());
assert(0 <= error_msg_length(clock));
assert(0 <= fuzzy_block_number(clock) and fuzzy_block_number(clock) < 65536);
assert(0 <= fuzzy_block_size(clock));
assert(0 <= ascii_case(clock, 0) and ascii_case(clock, 0) <= 1);
assert(0 <= ascii_case(clock, 1) and ascii_case(clock, 1) <= 1);
assert(0 <= ascii_case(clock, 2) and ascii_case(clock, 2) <= 1);
assert(0 <= ascii_case(clock, 3) and ascii_case(clock, 3) <= 1);
assert(0 <= ascii_case(clock, 4) and ascii_case(clock, 4) <= 1);
assert(0 <= ascii_case(clock, 5) and ascii_case(clock, 5) <= 1);
assert(0 <= ascii_case(clock, 6) and ascii_case(clock, 6) <= 1);
assert(0 <= ascii_case(clock, 7) and ascii_case(clock, 7) <= 1);
%(payload_range_assertions)s
%(payload_uf_assertions)s
-- Block sizes are all 512 execept for the last in the file.
current_size = if (fuzz_block_size(clock))
then fuzzy_block_size(clock)
else (0 -> if (msg.opcode = opcode_data)
then (if ((pre remaining_size) < 512) then (pre remaining_size) else 512)
else 0);
remaining_size = file_size() -> ((pre remaining_size) - current_size);
-- Block numbers start with 1 and increment at each data message (sent or acked)
block_number = if (fuzz_block_number(clock))
then fuzzy_block_number(clock)
else (0 -> (pre block_number) + (if (msg.opcode = opcode_data or msg.opcode = opcode_ack) then 1 else 0));
rrq_constraint = (msg.opcode = opcode_rrq)
and (payload_length = 2 + filename_length() + 1 + mode_length() + 1)
and (payload(clock, filename_length()) = 0)
and mode_constraint(clock, 2 + filename_length() + 1);
wrq_constraint = (msg.opcode = opcode_wrq)
and (payload_length = 2 + filename_length() + 1 + mode_length() + 1)
and (payload(clock, filename_length()) = 0)
and mode_constraint(clock, 2 + filename_length() + 1);
data_constraint = (msg.opcode = opcode_data)
and (payload_length = 2 + current_size)
and ((256 * payload(clock, 0)) + payload(clock, 1) = block_number);
ack_constraint = (msg.opcode = opcode_ack)
and (payload_length = 2)
and ((256 * payload(clock, 0)) + payload(clock, 1) = block_number);
error_constraint = (msg.opcode = opcode_error)
and (payload_length = 2 + error_msg_length(clock) + 1)
and (payload(clock, 2 + error_msg_length(clock)) = 0);
-- Fuzz the server with a RRQ followed by a series of either ACK or ERROR
fuzz_rrq = rrq_constraint -> (ack_constraint or error_constraint);
fuzz_rrq_protocol = (historically(fuzz_rrq) and once(ack_constraint) and historically(not fuzz_block_number(clock)));
-- Fuzz the server with a WRQ followed by a series of either DATA or ERROR
fuzz_wrq = wrq_constraint -> (data_constraint or error_constraint);
fuzz_wrq_protocol = (historically(fuzz_wrq) and once(data_constraint) and remaining_size = 0
and historically(not fuzz_block_number(clock)) and historically(not fuzz_block_size(clock)));
-- Fuzz the server with a RRQ followed by a series of either ACK or ERROR with fuzzy block numbers
fuzz_rrq_protocol_fuzzy_block_numbers = not (historically(fuzz_rrq) and once(ack_constraint));
-- Fuzz the server with a WRQ followed by a series of either DATA or ERROR and fuzzy block numbers
fuzz_wrq_protocol_fuzzy_block_numbers = not (historically(fuzz_wrq) and once(data_constraint) and remaining_size = 0
and historically(not fuzz_block_size(clock)));
-- Fuzz the server with a WRQ followed by a series of either DATA or ERROR and fuzzy block numbers
fuzz_wrq_protocol_fuzzy_block_sizes = not (historically(fuzz_wrq) and once(data_constraint) and remaining_size = 0
and historically(not fuzz_block_number(clock)));
--%%PROPERTY fuzz_rrq_protocol;
--%%PROPERTY fuzz_wrq_protocol;
-- -- %%PROPERTY fuzz_rrq_protocol_fuzzy_block_numbers;
-- -- %%PROPERTY fuzz_wrq_protocol_fuzzy_block_numbers;
-- -- %%PROPERTY fuzz_wrq_protocol_fuzzy_block_sizes;
tel'''
###############################################################################
def generate_payload_uf_assertions():
result = ""
for index in range(0,MAX_PAYLOAD_LENGTH):
result = result + (" assert(msg.payload[" + str(index) + "] = payload(clock, " + str(index) + "));\n")
return result
###############################################################################
def generate_payload_range_assertions():
result = ""
for index in range(0,MAX_PAYLOAD_LENGTH):
result = result + (" assert(msg.payload[" + str(index) + "] >= 0 and msg.payload["+ str(index) +"] < 256);\n")
return result
###############################################################################
def main():
print(TFTP_MODEL_BODY_FORMAT %
{ 'max_payload_length' : MAX_PAYLOAD_LENGTH,
'payload_uf_assertions' : generate_payload_uf_assertions(),
'payload_range_assertions' : generate_payload_range_assertions() })
###############################################################################
if __name__ == "__main__":
sys.exit(main())
|
John F. Nash Jr. is widely known as the subject of the Oscar-winning film “A Beautiful Mind,” but his contributions to the advancement of human knowledge are far greater. Nash paved the way for game theory to spread from a collection of toy cases in mathematics to a generalizable theory applicable to virtually anything — board games, economics, politics, international relations — to the point where now it’s practically a mode of critical thinking in its own right.
On Saturday, the 86-year-old mathematician and his wife, Alicia, were killed in a car crash in New Jersey. There have been many excellent obituaries about Nash’s life and accomplishments, so I wanted to briefly discuss a few details about what he did that was so important, and why his work is still so relevant today.
Nash’s 1951 article “Non-Cooperative Games” refined the definition of an “equilibrium” as a situation in which each player is employing a strategy that is optimal given the strategies of all the other players. For example, in the Prisoner’s Dilemma — a game formalized by Nash’s thesis adviser Albert W. Tucker — the two suspects betraying each other is an equilibrium, despite the best overall outcome being for both of them to remain silent. Nash’s definition would (appropriately) become known as the “Nash Equilibrium” — a term familiar to students in a wide range of academic disciplines.
Given this new definition, Nash was able to prove that a “mixed-strategy” equilibrium exists for virtually any finite game. A “mixed” strategy is one where, instead of choosing a single action, a player chooses a mix of actions with a certain probability for each — for example, the strategy of choosing rock, paper or scissors one-third of the time each in Rock Paper Scissors. It doesn’t matter if your opponent knows what strategy you’re playing, they can’t do anything about it.
One area in which Nash’s legacy continues to be especially relevant and fruitful is sports analysis. One of the cleanest examples is the mini-game of penalty kicks in soccer. If a player always kicks the same direction, the goalkeeper can profitably adapt by always diving in that direction. Thus “always kick right” or “always kick left” can’t be equilibrium strategies. Similarly, if the goalkeeper always dived in one direction, the player would be able to profitably deviate by kicking in the other. Thus the equilibrium strategy for the kicking player is to “mix it up” (use a mixed strategy) by kicking one way some of the time and the other way some of the time. Presuming the player selects randomly and doesn’t telegraph his moves, the goalkeeper can do no better than guessing. Therefore, the goalkeeper’s equilibrium response is to also mix it up, diving in each direction often enough to keep the kicker from exploiting his tendencies. This is why you often see wildly inaccurate dives: It’s not necessarily because they were faked out, it’s just that they picked scissors when the striker picked rock.
And, of course, the same principles apply in much more complicated scenarios, like run/pass balance in football. If teams pass too often, defenses will exploit it by keying against the pass. If defenses key against the pass too much, offenses will exploit it by running more. Indeed, a key insight of game theory is that how you balance the different options in an “optimal” (meaning equilibrium) strategy isn’t just a matter of how good each option seems in a vacuum; it matters how your opponent will adapt to your strategy overall. For example, it doesn’t matter if you’re theoretically “better” at passing than running: If your opponent is defending optimally, you should be indifferent between the two. Thus your “optimal” balance between the two should actually be a matter of ensuring that the defense has nothing to exploit. (Of course, if the defense isn’t defending optimally, you should do more of whichever gives you the best results.)
Let’s use a concrete example: Should the Seattle Seahawks have run or passed at the end of their ill-fated Super Bowl drive? The game theory-savvy answer is basically “neither”: They should use whatever strategy gives the Patriots the maximum headache on defense — likely a mix of passes and runs.
Another situation relevant to sports headlines today is the recent discussions and controversies over how valuable 3-point shots are in basketball and the viability of strategies like Houston Rockets GM Daryl Morey’s (in a nutshell: abandon midrange shooting). While the math suggests 3-point shots are underutilized, if teams shoot more and more from beyond the arc, defenses should adjust to defend those shots. In equilibrium, teams should be indifferent (on average) between 3-point and midrange shooting, and the idea that 3-point shots are intrinsically more valuable than long jumpers can only be true if defenses are literally incapable of diverting any more resources to their defense. From a game-theoretical perspective, underutilized and underdefended are basically the same thing.
Similar questions and scenarios come up in baseball, hockey, tennis and virtually every other sport. Indeed, once you get in this mode of thinking, you start seeing it everywhere (much like with Bayesian inference, or Tetris).
In 1994, for his contributions to the field of game theory, Nash received the Nobel Prize in economics. But his greatest accomplishment may be the role he played in the emergence of a whole new and important way of thinking about the world and the things that happen in it.
Rest in peace. |
Retreating Glacier Fronts on the Antarctic Peninsula over the Past Half-Century
The continued retreat of ice shelves on the Antarctic Peninsula has been widely attributed to recent atmospheric warming, but there is little published work describing changes in glacier margin positions. We present trends in 244 marine glacier fronts on the peninsula and associated islands over the past 61 years. Of these glaciers, 87% have retreated and a clear boundary between mean advance and retreat has migrated progressively southward. The pattern is broadly compatible with retreat driven by atmospheric warming, but the rapidity of the migration suggests that this may not be the sole driver of glacier retreat in this region. |
def add(self, key, comments=""):
try:
assert isinstance(key,(ARgorithmHashable,int,bool,str,float))
except AssertionError as ae:
raise TypeError("Invalid key error : Please provide data with ARgorithmHashable type or (int, float, bool, str)") from ae
if isinstance(key, ARgorithmHashable):
self.body.add(key.to_json())
else:
self.body.add(key)
self.__working_set.add(key)
state = self.state_generator.set_add(self.body, key,comments)
self.algo.add_state(state) |
/// Generate types as in [generate_types], but with assumed proof properties.
pub fn generate_types_with_proof(
doc: &EIP712Value,
primary_type: Option<StructName>,
) -> Result<HashMap<StructName, StructType>, TypesGenerationError> {
let mut map = if let EIP712Value::Struct(ref map) = doc {
map.clone()
} else {
return Err(TypesGenerationError::ExpectedObject);
};
if map.get("proof").is_some() {
return Err(TypesGenerationError::ProofAlreadyExists);
}
// Put dummy data in proof object so that types for it can be generated.
// Note: @context is not added.
map.insert(
"proof".to_string(),
EIP712Value::Struct(
vec![
(
"type".to_string(),
EIP712Value::String("ExampleSignatureType".to_string()),
),
(
"created".to_string(),
EIP712Value::String("2022-02-03T19:18:58Z".to_string()),
),
(
"proofPurpose".to_string(),
EIP712Value::String("assertionMethod".to_string()),
),
(
"verificationMethod".to_string(),
EIP712Value::String("did:example:eip712sig".to_string()),
),
]
.into_iter()
.collect(),
),
);
generate_types(&EIP712Value::Struct(map), primary_type)
} |
<reponame>tgsnake/parser
// Tgsnake - Telegram MTProto framework developed based on gram.js.
// Copyright (C) 2021 Butthx <https://guthub.com/butthx>
//
// This file is part of Tgsnake
//
// Tgsnake is a free software : you can redistribute it and/or modify
// it under the terms of the MIT License as published.
import { Parser } from "htmlparser2";
import { Handler } from "htmlparser2/lib/Parser";
import { Entities, IEntities } from "./Entities";
function stripText(text: string, entities: Entities[]) {
if (!entities || !entities.length) {
return text.trim();
}
while (text && text[text.length - 1].trim() === "") {
const e = entities[entities.length - 1];
if (e.offset + e.length == text.length) {
if (e.length == 1) {
entities.pop();
if (!entities.length) {
return text.trim();
}
} else {
e.length -= 1;
}
}
text = text.slice(0, -1);
}
while (text && text[0].trim() === "") {
for (let i = 0; i < entities.length; i++) {
const e = entities[i];
if (e.offset != 0) {
e.offset--;
continue;
}
if (e.length == 1) {
entities.shift();
if (!entities.length) {
return text.trimLeft();
}
} else {
e.length -= 1;
}
}
text = text.slice(1);
}
return text;
}
class HTMLParser implements Handler {
text: string;
entities: Entities[];
private readonly _buildingEntities: Map<string, Entities>;
private readonly _openTags: string[];
private readonly _openTagsMeta: (string | undefined)[];
constructor() {
this.text = "";
this.entities = [];
this._buildingEntities = new Map<string, Entities>();
this._openTags = [];
this._openTagsMeta = [];
}
onopentag(
name: string,
attributes: {
[s: string]: string;
}
) {
this._openTags.unshift(name);
this._openTagsMeta.unshift(undefined);
let EntityType;
const args: any = {};
if (name == "strong" || name == "b") {
EntityType = "bold";
} else if (name == "em" || name == "i") {
EntityType = "italic";
} else if (name == "u") {
EntityType = "underline";
} else if (name == "del" || name == "s") {
EntityType = "strike";
} else if (name == "blockquote") {
EntityType = "blockquote";
} else if (name == "code") {
const pre = this._buildingEntities.get("pre");
if (pre && pre.type == "pre") {
try {
pre.language = attributes.class.slice(
"language-".length,
attributes.class.length
);
} catch (e) {}
} else {
EntityType = "code";
}
} else if (name == "pre") {
EntityType = "pre";
args["language"] = "";
} else if (name == "a") {
let url: string | undefined = attributes.href;
if (!url) {
return;
}
let mention = /tg:\/\/user\?id=(\d+)/gi.exec(url);
if (url.startsWith("mailto:")) {
url = url.slice("mailto:".length, url.length);
EntityType = "email";
} else if (mention) {
(EntityType = "mentionName"),
(args["userId"] = BigInt(String(mention[1])));
url = undefined;
} else {
EntityType = "textUrl";
args["url"] = url;
url = undefined;
}
this._openTagsMeta.shift();
this._openTagsMeta.unshift(url);
} else if (
name == "spoiler" ||
(name == "span" &&
attributes.class &&
attributes.class == "tg-spoiler") ||
name == "sp" ||
name == "tg-spoiler"
) {
EntityType = "spoiler";
}
if (EntityType && !this._buildingEntities.has(name)) {
this._buildingEntities.set(
name,
new Entities({
offset: this.text.length,
length: 0,
type: EntityType,
...args,
})
);
}
}
ontext(text: string) {
const previousTag = this._openTags.length > 0 ? this._openTags[0] : "";
if (previousTag == "a") {
const url = this._openTagsMeta[0];
if (url) {
text = url;
}
}
for (let [tag, entity] of this._buildingEntities) {
entity.length += text.length;
}
this.text += text;
}
onclosetag(tagname: string) {
this._openTagsMeta.shift();
this._openTags.shift();
const entity = this._buildingEntities.get(tagname);
if (entity) {
this._buildingEntities.delete(tagname);
this.entities.push(entity);
}
}
onattribute(
name: string,
value: string,
quote?: string | undefined | null
): void {}
oncdataend(): void {}
oncdatastart(): void {}
oncomment(data: string): void {}
oncommentend(): void {}
onend(): void {}
onerror(error: Error): void {}
onopentagname(name: string): void {}
onparserinit(parser: Parser): void {}
onprocessinginstruction(name: string, data: string): void {}
onreset(): void {}
}
function inRange(x, min, max) {
return (x - min) * (x - max) <= 0;
}
function unEscape(text) {
return text
.replace(/\&\;/gm, "&")
.replace(/\<\;/gm, "<")
.replace(/\&rt\;/gm, ">");
}
export function parse(html: string): [string, Entities[]] {
if (!html) {
return [html, []];
}
const handler = new HTMLParser();
const parser = new Parser(handler);
parser.write(html);
parser.end();
const text = stripText(handler.text, handler.entities);
const entities: Entities[] = handler.entities;
entities.sort((a, b) => {
return a.offset - b.offset;
});
// remove any entities if it inside code-style.
for (let im = 0; im < entities.length; im++) {
let em = entities[im];
let pm = entities[im - 1];
let nm = entities[im + 1];
if (nm) {
if (inRange(nm.offset, em.offset, em.offset + em.length)) {
if (em.type == "code") {
if (nm.type !== "spoiler") entities.splice(im + 1, 1);
} else if (nm.type == "code") {
if (em.type !== "spoiler") entities.splice(im, 1);
}
}
} else if (pm) {
if (inRange(pm.offset, em.offset, em.offset + em.length)) {
if (em.type == "code") {
if (pm.type !== "spoiler") entities.splice(im - 1, 1);
} else if (pm.type == "code") {
if (em.type !== "spoiler") entities.splice(im, 1);
}
}
}
}
return [unEscape(text), entities];
}
|
<reponame>vtenq/graphql-toolkit
import {
Source,
parseGraphQLJSON,
SchemaPointerSingle,
DocumentLoader,
isValidPath,
SingleFileOptions,
} from '@graphql-toolkit/common';
const FILE_EXTENSIONS = ['.json'];
export interface JsonFileLoaderOptions extends SingleFileOptions {
fs?: typeof import('fs');
path?: typeof import('path');
}
export class JsonFileLoader implements DocumentLoader {
loaderId(): string {
return 'json-file';
}
async canLoad(pointer: SchemaPointerSingle, options: JsonFileLoaderOptions): Promise<boolean> {
return this.canLoadSync(pointer, options);
}
canLoadSync(pointer: SchemaPointerSingle, options: JsonFileLoaderOptions): boolean {
if (isValidPath(pointer) && options.path && options.fs) {
const { resolve, isAbsolute } = options.path;
if (FILE_EXTENSIONS.find(extension => pointer.endsWith(extension))) {
const normalizedFilePath = isAbsolute(pointer) ? pointer : resolve(options.cwd || process.cwd(), pointer);
const { existsSync } = options.fs;
if (existsSync(normalizedFilePath)) {
return true;
}
}
}
return false;
}
async load(pointer: SchemaPointerSingle, options: JsonFileLoaderOptions): Promise<Source> {
return this.loadSync(pointer, options);
}
loadSync(pointer: SchemaPointerSingle, options: JsonFileLoaderOptions): Source {
const { resolve: resolvePath, isAbsolute } = options.path;
const normalizedFilepath = isAbsolute(pointer) ? pointer : resolvePath(options.cwd || process.cwd(), pointer);
try {
const { readFileSync } = options.fs;
const jsonContent = readFileSync(normalizedFilepath, 'utf8');
return parseGraphQLJSON(pointer, jsonContent, options);
} catch (e) {
throw new Error(`Unable to read JSON file: ${normalizedFilepath}: ${e.message || e}`);
}
}
}
|
New single 783 square metre screen will feature facial and vehicle recognition technology, providing advertisers with targeted marketing opportunities and maximum brand exposure
New 783 square metre screen will feature facial and vehicle recognition technology, providing advertisers with targeted marketing opportunities and maximum brand exposure
A brand new state of the art 783 square metre digital screen is set to go live in Piccadilly Circus for the first time this month, with the firm behind it hailing it the “most technically advanced” on the planet.
Piccadilly lights in London, one of the most iconic advertising sites in the world – attracting more than 70 million people a year, fell dark in January (2017) after the decision was made to replace the six existing displays with a single one in a move designed to help raise revenues whilst enhance exposure for advertisers.
The project has been managed by large-format digital out of home specialists Ocean Outdoor, who commissioned South Dakota based manufacturer Daktronics to build the new screen, which is made up of more than 5,500 individual LED panels.
Equal voice
The screen allows all brands (Hyundai, Coca Cola, L’Oréal, Samsung, Ebay and Stella McCartney/Hunter) to receive equal exposure, with ads changing locations every 90 seconds. This is in contrast to the old design, which saw six individual displays, each of which were managed by separate companies.
“Before we took over, it was six screens, six contracts and six different prices,” Ocean Outdoor head of design David Tait told AVTE. “Each brand had its own location, with some locations deemed to better than others and the price reflective of that.
“The idea of the new screen is that it still has the six different advertising spaces, but unlike before, they all switch around. So, whilst the six screens have become one, the traditions of Piccadilly Circus have remained intact. It’s a constantly moving and changing screen and every brand has an equal share 24/7.”
From a revenue proposition point of view it makes complete sense, and from an advertisers point of view it means they have an equal share of voice
Richard Malton, the group-marketing director of Ocean Outdoor, added: “By levelling the playing field it meant we could sell it in a more efficient way and maximise exposure for every brand. From a revenue proposition point of view it makes complete sense, and from an advertisers point of view it means they have an equal share of voice.”
A smarter way of advertising
In addition, the screen now features a number of new camera technologies, including facial recognition and vehicle recognition, which help to provide advertisers with more targeted marketing.
Facial recognition software (Look Out), built in-house is capable of counting the number of people in the area, but also distinguish if those people are male, female, their age (to within five years), if they have facial hair, are looking at a specific ad and even judge their mind-set – i.e. if they’re happy or sad.
For vehicle recognition, the technology is able to determine what cars are being driven, including their age, model and whether they are diesel or petrol.
The data received from this information can be used to automatically determine and select what type of ad should be displayed by a specific brand.
“If you’re a brand that has a male product and a female product, the system is able analyse the average make up of those in its sights before making the best decision,” said Tait. “If the answer is, say, 70 per cent female, then it can play the female ad. The more triggers you can build into your artwork, the better.”
“Advertising can make assumptions about people based on the value of the vehicle they’re driving. If someone is driving a Porsche, you can probably make some assumptions about them.”
Molton concluded: “It’s the worlds biggest smartphone. The opportunities for advertisers are huge and we’re working with them on some very exciting and creative content.”
Details on the launch date and time are expected to be confirmed in the coming days.
A full interview with Ocean Outdoor discussing the Piccadilly Lights will feature in our next issue of AV Technology Europe magazine, which goes out next month.
Never miss a thing, by signing up to receive your complimentary copy of AV Technology Europe magazine (print or digital edition) and our weekly newsletters.
You can also follow us on Twitter @AVTechnologyEurope or contact our editor Michael Garwood directly via email: [email protected] |
#t=int(input())
#for j in range(t):
#x,y,k=input().split(" ")
#x,y,k=int(x),int(y),int(k)
#a=list(map(int,input().split()))
s=input()
t=input()
if(s[::-1]==t):
print("YES")
else:
print("NO")
|
def _to_nanoseconds(val: Optional[float]) -> Optional[int]:
if val is None:
return None
return int(val * _NANOSECOND) |
#pragma once
#include "Engine/Graphics/Effects/Utils/RenderTargetStackAllocator.h"
#include "Engine/Graphics/Effects/Logic/Components/RenderContext.h"
namespace bv {
class RenderLogicState
{
private:
RenderTargetStackAllocator m_renderTargetAllocator;
RenderQueueStackAllocator m_renderQueueAllocator;
RenderContext m_ctx;
bool m_initialized;
bool m_editMode;
public:
RenderLogicState ( unsigned int width, unsigned int height );
RenderContext * GetRenderContext ();
RenderTargetStackAllocator * GetRenderTargetStackAllocator ();
RenderQueueStackAllocator * GetRenderQueueStackAllocator ();
bool IsInitialized () const;
bool IsEditMode () const;
void SwitchEditMode ( bool value );
void Initialize ( Renderer * renderer, audio::AudioRenderer * audio );
};
// ************************
//
inline RenderContext * context ( RenderLogicState & state )
{
return state.GetRenderContext();
}
// ************************
//
inline RenderTargetStackAllocator * render_target_allocator ( RenderLogicState & state )
{
return state.GetRenderTargetStackAllocator();
}
// ************************
//
inline RenderQueueStackAllocator * render_queu_allocator ( RenderLogicState & state )
{
return state.GetRenderQueueStackAllocator();
}
} // bv
|
#!/usr/bin/env python3
from .settings import Settings
from .certbase import CertBase
from .certca import CertCA
from .certserver import CertServer
from .certuser import CertUser
from .usermanager import UserManager
|
/**
* Collection of static locks to be used in the app.
*/
public class Locks {
/**
* Settings Logger Lock.
* @see es.um.dga.features.utils.Settings#getLogger()
*/
public static final Object LOGGER = new Object();
/**
* Configuration Lock.
* @see es.um.dga.features.utils.Settings#loadConfiguration()
*/
public static final Object CONFIGURATION = new Object();
/**
* English cache storage Lock.
* @see es.um.dga.nlp.utils.EnglishCache
*/
public final static Object ENGLISH_CACHE = new Object();
public final static Object LOAD_MONGO_CONFIGURATION = new Object();
} |
The quad configuration is available now in North America (France, Germany and the UK get it later in the year) for $1,699 and ships with the usual 16GB of RAM, a 3,200 x 1,800 screen as well as a 512GB SSD. Razer clearly sees the more powerful chip as an upsell at this stage rather than an across-the-board upgrade for every model, and that price is perilously close to the $1,900 you'll pay for the brawnier 14-inch Razer Blade. You'll want to think carefully about buying this model, then. Still, if you're more interested in raw portability than playing Destiny 2 on the road, this is one of the speedier options.
Don't worry if you prefer the Stealth but still want to plug in for some games, though. Razer is launching the Core V2, which tweaks its familiar external GPU housing to better serve as a general-purpose hub. It now has dual Thunderbolt 3 controllers that splits the pipelines for both your video card and other devices, so you don't have to worry about the Core's Ethernet connection or USB ports taking precious bandwidth away from your GPU. The V2 also accommodates a wider array of video cards, including GeForce 10-series and Radeon 500-series boards as well as Quadro workstation cards.
The new Core sells for a familiar $499 and ships "soon" to North America as well as France, Germany and the UK. That remains a lot of money to spend just to get desktop-level graphics on your laptop (the price doesn't include the card itself, remember), but the V2 upgrades make the Core more practical if it doubles as a docking station for your peripherals. |
#![allow(unused_macros)]
extern crate core;
extern crate alloc;
#[macro_use] pub mod tuple_match;
#[macro_use] pub mod tuple_gen;
use core::convert::TryInto;
use alloc::borrow::{Cow, ToOwned};
use alloc::vec::Vec;
use alloc::string::String;
/// Serialize a `self` into an existing vector
pub trait Serialize {
fn serialize(&self, buf: &mut Vec<u8>);
}
/// Deserialize a buffer, creating a Some(`Self`) if the serialization succeeds,
/// otherwise a `None` is returned. `ptr` should be a mutable reference to a
/// slice, this allows the deserializer to "consume" bytes by advancing the
/// pointer. To see how many bytes were deserialized, you can check the
/// difference in the `ptr`'s length before and after the call to deserialize.
///
/// If deserialization fails at any point, all intermediate objects created
/// will be destroyed, and the `ptr` will not be be changed.
///
/// This effectively behaves the same as `std::io::Read`. Since we don't have
/// `std` access in this lib we opt to go this route.
pub trait Deserialize: Sized {
fn deserialize(ptr: &mut &[u8]) -> Option<Self>;
}
/// Implement `Serialize` trait for types which provide `to_le_bytes()`
macro_rules! serialize_le {
// Serialize `$input_type` as an `$wire_type` by using `to_le_bytes()`
// and `from_le_bytes()`. The `$input_type` gets converted to an
// `$wire_type` via `TryInto`
($input_type:ty, $wire_type:ty) => {
impl Serialize for $input_type {
fn serialize(&self, buf: &mut Vec<u8>) {
let wire: $wire_type = (*self).try_into()
.expect("Should never happen, input type to wire type");
buf.extend_from_slice(&wire.to_le_bytes());
}
}
impl Deserialize for $input_type {
fn deserialize(orig_ptr: &mut &[u8]) -> Option<Self> {
// Get the slice pointed to by `orig_ptr`
let ptr: &[u8] = *orig_ptr;
// Convert the slice to a fixed-size array
let arr: [u8; core::mem::size_of::<$wire_type>()] =
ptr.get(0..core::mem::size_of::<$wire_type>())?
.try_into().ok()?;
// Convert the array of bytes into the `$wire_type`
let wire_val = <$wire_type>::from_le_bytes(arr);
// Try to convert the wire-format type into the desired type
let converted: $input_type = wire_val.try_into().ok()?;
// Update the pointer
*orig_ptr = &ptr[core::mem::size_of::<$wire_type>()..];
// Return out the deserialized `Self`!
Some(converted)
}
}
};
// Serialize an $input_type using `to_le_bytes()` and `from_le_bytes()`
($input_type:ty) => {
serialize_le!($input_type, $input_type);
};
}
// Implement serialization for all of the primitive types
serialize_le!(u8);
serialize_le!(u16);
serialize_le!(u32);
serialize_le!(u64);
serialize_le!(u128);
serialize_le!(i8);
serialize_le!(i16);
serialize_le!(i32);
serialize_le!(i64);
serialize_le!(i128);
serialize_le!(usize, u64);
serialize_le!(isize, i64);
/// Implement serialize for `&str`
impl Serialize for str {
fn serialize(&self, buf: &mut Vec<u8>) {
// Serialize the underlying bytes of the string
Serialize::serialize(self.as_bytes(), buf);
}
}
/// Implement serialize for `&str`
impl Serialize for &str {
fn serialize(&self, buf: &mut Vec<u8>) {
// Serialize the underlying bytes of the string
Serialize::serialize(self.as_bytes(), buf);
}
}
/// Implement serialize for `[T]`
impl<T: Serialize> Serialize for [T] {
fn serialize(&self, buf: &mut Vec<u8>) {
// Serialize the number of elements
Serialize::serialize(&self.len(), buf);
// Serialize all of the values
self.iter().for_each(|x| Serialize::serialize(x, buf));
}
}
/// Implement `Serialize` for `Option`
impl<T: Serialize> Serialize for Option<T> {
fn serialize(&self, buf: &mut Vec<u8>) {
if let Some(val) = self.as_ref() {
// Serialize that this is a some type
buf.push(1);
// Serialize the underlying bytes of the value
Serialize::serialize(val, buf);
} else {
// `None` value case
buf.push(0);
}
}
}
/// Implement `Deserialize` for `Option`
impl<T: Deserialize> Deserialize for Option<T> {
fn deserialize(orig_ptr: &mut &[u8]) -> Option<Self> {
// Make a copy of the original pointer
let mut ptr = *orig_ptr;
// Get if this option is a `Some` value
let is_some = <u8 as Deserialize>::deserialize(&mut ptr)? != 0;
let ret = if is_some {
// Deserialize payload
Some(<T as Deserialize>::deserialize(&mut ptr)?)
} else {
None
};
// Update the original pointer
*orig_ptr = ptr;
Some(ret)
}
}
/// Implement `Serialize` for `String`
impl Serialize for String {
fn serialize(&self, buf: &mut Vec<u8>) {
// Serialize the underlying bytes of the string
Serialize::serialize(self.as_bytes(), buf);
}
}
/// Implement `Deserialize` for `String`
impl Deserialize for String {
fn deserialize(orig_ptr: &mut &[u8]) -> Option<Self> {
// Make a copy of the original pointer
let mut ptr = *orig_ptr;
// Deserialize a vector of bytes
let vec = <Vec<u8> as Deserialize>::deserialize(&mut ptr)?;
// Convert it to a string and return it out
let ret = String::from_utf8(vec).ok()?;
// Update the original pointer
*orig_ptr = ptr;
Some(ret)
}
}
/// Implement `Serialize` for types which can be `Cow`ed
impl<'a, T: 'a> Serialize for Cow<'a, T>
where T: Serialize + ToOwned + ?Sized {
fn serialize(&self, buf: &mut Vec<u8>) {
Serialize::serialize(self.as_ref(), buf);
}
}
/// Implement `Deserialize` for types which can be `Cow`ed
impl<'a, T: 'a> Deserialize for Cow<'a, T>
where T: ToOwned + ?Sized,
<T as ToOwned>::Owned: Deserialize,
Cow<'a, T>: From<<T as ToOwned>::Owned> {
fn deserialize(orig_ptr: &mut &[u8]) -> Option<Self> {
// Make a copy of the original pointer
let mut ptr = *orig_ptr;
// Deserialize into the owned type for the `Cow`
let ret =
<<T as ToOwned>::Owned as Deserialize>::deserialize(&mut ptr)?;
// Update the original pointer
*orig_ptr = ptr;
Some(Cow::from(ret))
}
}
/// Implement `Serialize` for `Vec<T>`
impl<T: Serialize> Serialize for Vec<T> {
fn serialize(&self, buf: &mut Vec<u8>) {
// Serialize the number of elements
Serialize::serialize(&self.len(), buf);
// Serialize all of the values
self.iter().for_each(|x| Serialize::serialize(x, buf));
}
}
/// Implement `Deserialize` for `Vec`s that contain all `Deserialize` types
impl<T: Deserialize> Deserialize for Vec<T> {
fn deserialize(orig_ptr: &mut &[u8]) -> Option<Self> {
// Make a copy of the original pointer
let mut ptr = *orig_ptr;
// Get the length of the vector in elements
let len = <usize as Deserialize>::deserialize(&mut ptr)?;
// Allocate the vector we're going to return
let mut vec = Vec::with_capacity(len);
// Deserialize all the components
for _ in 0..len {
vec.push(<T as Deserialize>::deserialize(&mut ptr)?);
}
// Update original pointer and return out the deserialized vector
*orig_ptr = ptr;
Some(vec)
}
}
/// Implement `Serialize` trait for arrays of types which implement `Serialize`
macro_rules! serialize_arr {
($arrsize:expr, $($foo:expr),*) => {
impl<T: Serialize> Serialize for [T; $arrsize] {
fn serialize(&self, buf: &mut Vec<u8>) {
// Serialize all of the values
self.iter().for_each(|x| Serialize::serialize(x, buf));
}
}
impl<T: Deserialize> Deserialize for [T; $arrsize] {
fn deserialize(orig_ptr: &mut &[u8]) -> Option<Self> {
// Make a copy of the original pointer
let mut _ptr = *orig_ptr;
// Deserialize the array
let arr = [$(
{let _ = $foo; Deserialize::deserialize(&mut _ptr)?},
)*];
// Update the original pointer and return out the array
*orig_ptr = _ptr;
Some(arr)
}
}
}
}
// Implement serialization and deserialization for all arrays of types which
// are serializable and/or deserialiable up to fixed-width 32 entry arrays
serialize_arr!( 0,);
serialize_arr!( 1, 0);
serialize_arr!( 2, 0, 0);
serialize_arr!( 3, 0, 0, 0);
serialize_arr!( 4, 0, 0, 0, 0);
serialize_arr!( 5, 0, 0, 0, 0, 0);
serialize_arr!( 6, 0, 0, 0, 0, 0, 0);
serialize_arr!( 7, 0, 0, 0, 0, 0, 0, 0);
serialize_arr!( 8, 0, 0, 0, 0, 0, 0, 0, 0);
serialize_arr!( 9, 0, 0, 0, 0, 0, 0, 0, 0, 0);
serialize_arr!(10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
serialize_arr!(11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
serialize_arr!(12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
serialize_arr!(13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
serialize_arr!(14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
serialize_arr!(15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
serialize_arr!(16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
serialize_arr!(17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
serialize_arr!(18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
serialize_arr!(19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
serialize_arr!(20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
serialize_arr!(21, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
serialize_arr!(22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
serialize_arr!(23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
serialize_arr!(24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
serialize_arr!(25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
serialize_arr!(26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
serialize_arr!(27, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
serialize_arr!(28, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
serialize_arr!(29, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
serialize_arr!(30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
serialize_arr!(31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
serialize_arr!(32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
/// Implement serialize and deserialize on an enum or structure definition.
///
/// This is used by just wrapping a structure definition like:
///
/// `noodle!(serialize, deserialize, struct Foo { bar: u32 })`
///
/// This can be used on any structure or enum definition and automatically
/// implements the serialize and deserialize traits for it by enumerating every
/// field in the structure (or enum variant) and serializing it out in
/// definition order.
///
/// This all looks really complicated, but it's really just a lot of copied
/// and pasted code that can represent a structure or enum shape in macros.
/// These macros destruct all possible structs and enums and gives us "access"
/// to the inner field names, ordering, and types. This allows us to invoke
/// the `serialize` or `deserialize` routines for every member of the
/// structure. It's that simple!
#[macro_export]
macro_rules! noodle {
// Create a new struct with serialize and deserialize implemented
(serialize, deserialize,
$(#[$attr:meta])* $vis:vis struct $structname:ident
// Named struct
$({
$(
$(#[$named_attr:meta])*
$named_vis:vis $named_field:ident: $named_type:ty
),*$(,)?
})?
// Named tuple
$((
$(
$(#[$tuple_meta:meta])* $tuple_vis:vis $tuple_typ:ty
),*$(,)?
);)?
// Eat semicolons
$(;)?
) => {
noodle!(define_struct,
$(#[$attr])* $vis struct $structname
// Named struct
$({
$(
$(#[$named_attr])*
$named_vis $named_field: $named_type
),*
})?
// Named tuple
$((
$(
$(#[$tuple_meta])* $tuple_vis $tuple_typ
),*
);)?
);
noodle!(impl_serialize_struct,
$(#[$attr])* $vis struct $structname
// Named struct
$({
$(
$(#[$named_attr])*
$named_vis $named_field: $named_type
),*
})?
// Named tuple
$((
$(
$(#[$tuple_meta])* $tuple_vis $tuple_typ
),*
);)?
);
noodle!(impl_deserialize_struct,
$(#[$attr])* $vis struct $structname
// Named struct
$({
$(
$(#[$named_attr])*
$named_vis $named_field: $named_type
),*
})?
// Named tuple
$((
$(
$(#[$tuple_meta])* $tuple_vis $tuple_typ
),*
);)?
);
};
// Define an empty structure
(define_struct,
$(#[$attr:meta])* $vis:vis struct $structname:ident
) => {
$(#[$attr])* $vis struct $structname;
};
// Define a structure
(define_struct,
$(#[$attr:meta])* $vis:vis struct $structname:ident
// Named struct
$({
$(
$(#[$named_attr:meta])*
$named_vis:vis $named_field:ident: $named_type:ty
),*$(,)?
})?
// Named tuple
$((
$(
$(#[$tuple_meta:meta])* $tuple_vis:vis $tuple_typ:ty
),*$(,)?
);)?
) => {
$(#[$attr])* $vis struct $structname
// Named struct
$({
$(
$(#[$named_attr])*
$named_vis $named_field: $named_type
),*
})?
// Named tuple
$((
$(
$(#[$tuple_meta])* $tuple_vis $tuple_typ
),*
);)?
};
// Implement serialization for a structure
(impl_serialize_struct,
$(#[$attr:meta])* $vis:vis struct $structname:ident
// Named struct
$({
$(
$(#[$named_attr:meta])*
$named_vis:vis $named_field:ident: $named_type:ty
),*$(,)?
})?
// Named tuple
$((
$(
$(#[$tuple_meta:meta])* $tuple_vis:vis $tuple_typ:ty
),*$(,)?
);)?
) => {
impl Serialize for $structname {
fn serialize(&self, buf: &mut Vec<u8>) {
// Named struct
$(
$(
Serialize::serialize(&self.$named_field, buf);
)*
)?
// Named tuple
handle_serialize_named_tuple!(
self, buf $($(, $tuple_typ)*)?);
}
}
};
// Implement deserialization for a field-less structs
(impl_deserialize_struct,
$(#[$attr:meta])* $vis:vis struct $structname:ident
) => {
impl Deserialize for $structname {
fn deserialize(orig_ptr: &mut &[u8]) -> Option<Self> {
Some($structname)
}
}
};
// Implement deserialization for a structure
(impl_deserialize_struct,
$(#[$attr:meta])* $vis:vis struct $structname:ident
// Named struct
$({
$(
$(#[$named_attr:meta])*
$named_vis:vis $named_field:ident: $named_type:ty
),*$(,)?
})?
// Named tuple
$((
$(
$(#[$tuple_meta:meta])* $tuple_vis:vis $tuple_typ:ty
),*$(,)?
);)?
) => {
impl Deserialize for $structname {
fn deserialize(orig_ptr: &mut &[u8]) -> Option<Self> {
// Get the original pointer
let mut ptr = *orig_ptr;
// Named struct
$(if true {
let ret = $structname {
$(
$named_field: Deserialize::deserialize(&mut ptr)?,
)*
};
// Update the original pointer
*orig_ptr = ptr;
return Some(ret);
})?
// Named tuple
$(if true {
let ret = $structname(
$(
<$tuple_typ as Deserialize>::
deserialize(&mut ptr)?,
)*
);
// Update the original pointer
*orig_ptr = ptr;
return Some(ret);
})?
// Not reachable
unreachable!("How'd you get here?");
}
}
};
// Create a new enum with serialize and deserialize implemented
(serialize, deserialize,
$(#[$attr:meta])* $vis:vis enum $enumname:ident {
// Go through each variant in the enum
$(
// Variant attributes
$(#[$variant_attr:meta])*
// Identifier for the enum variant, always present
$variant_ident:ident
// An enum item struct
$({
$(
$(#[$named_attr:meta])*
$named_field:ident: $named_type:ty
),*$(,)?
})?
// An enum item tuple
$((
$(
$(#[$tuple_meta:meta])* $tuple_typ:ty
),*$(,)?
))?
// An enum discriminant
$(= $expr:expr)?
),*$(,)?
}
) => {
noodle!(define_enum,
$(#[$attr])* $vis enum $enumname {
// Go through each variant in the enum
$(
// Variant attributes
$(#[$variant_attr])*
// Identifier for the enum variant, always present
$variant_ident
// An enum item struct
$({
$(
$(#[$named_attr])* $named_field: $named_type
),*
})?
// An enum item tuple
$((
$(
$(#[$tuple_meta])* $tuple_typ
),*
))?
// An enum discriminant
$(= $expr)?
),*
});
noodle!(impl_serialize_enum,
$(#[$attr])* $vis enum $enumname {
// Go through each variant in the enum
$(
// Variant attributes
$(#[$variant_attr])*
// Identifier for the enum variant, always present
$variant_ident
// An enum item struct
$({
$(
$(#[$named_attr])* $named_field: $named_type
),*
})?
// An enum item tuple
$((
$(
$(#[$tuple_meta])* $tuple_typ
),*
))?
// An enum discriminant
$(= $expr)?
),*
});
noodle!(impl_deserialize_enum,
$(#[$attr])* $vis enum $enumname {
// Go through each variant in the enum
$(
// Variant attributes
$(#[$variant_attr])*
// Identifier for the enum variant, always present
$variant_ident
// An enum item struct
$({
$(
$(#[$named_attr])* $named_field: $named_type
),*
})?
// An enum item tuple
$((
$(
$(#[$tuple_meta])* $tuple_typ
),*
))?
// An enum discriminant
$(= $expr)?
),*
});
};
(define_enum,
$(#[$attr:meta])* $vis:vis enum $enumname:ident {
// Go through each variant in the enum
$(
// Variant attributes
$(#[$variant_attr:meta])*
// Identifier for the enum variant, always present
$variant_ident:ident
// An enum item struct
$({
$(
$(#[$named_attr:meta])*
$named_field:ident: $named_type:ty
),*$(,)?
})?
// An enum item tuple
$((
$(
$(#[$tuple_meta:meta])* $tuple_typ:ty
),*$(,)?
))?
// An enum discriminant
$(= $expr:expr)?
),*$(,)?
}) => {
// Just define the enum as is
$(#[$attr])* $vis enum $enumname {
// Go through each variant in the enum
$(
// Variant attributes
$(#[$variant_attr])*
// Identifier for the enum variant, always present
$variant_ident
// An enum item struct
$({
$(
$(#[$named_attr])* $named_field: $named_type
),*
})?
// An enum item tuple
$((
$(
$(#[$tuple_meta])* $tuple_typ
),*
))?
// An enum discriminant
$(= $expr)?
),*
}
};
(impl_serialize_enum,
$(#[$attr:meta])* $vis:vis enum $enumname:ident {
// Go through each variant in the enum
$(
// Variant attributes
$(#[$variant_attr:meta])*
// Identifier for the enum variant, always present
$variant_ident:ident
// An enum item struct
$({
$(
$(#[$named_attr:meta])*
$named_field:ident: $named_type:ty
),*$(,)?
})?
// An enum item tuple
$((
$(
$(#[$tuple_meta:meta])* $tuple_typ:ty
),*$(,)?
))?
// An enum discriminant
$(= $expr:expr)?
),*$(,)?
}) => {
impl Serialize for $enumname {
fn serialize(&self, buf: &mut Vec<u8>) {
let mut _count = 0u32;
// Go through each variant
$(
handle_serialize_enum_variants!(
self, $enumname, $variant_ident, buf, &_count,
$({$($named_field),*})? $(($($tuple_typ),*))?);
_count += 1;
)*
}
}
};
(impl_deserialize_enum,
$(#[$attr:meta])* $vis:vis enum $enumname:ident {
// Go through each variant in the enum
$(
// Variant attributes
$(#[$variant_attr:meta])*
// Identifier for the enum variant, always present
$variant_ident:ident
// An enum item struct
$({
$(
$(#[$named_attr:meta])*
$named_field:ident: $named_type:ty
),*$(,)?
})?
// An enum item tuple
$((
$(
$(#[$tuple_meta:meta])* $tuple_typ:ty
),*$(,)?
))?
// An enum discriminant
$(= $expr:expr)?
),*$(,)?
}) => {
impl Deserialize for $enumname {
fn deserialize(orig_ptr: &mut &[u8]) -> Option<Self> {
// Get the original pointer
let mut ptr = *orig_ptr;
// Count tracking enum variants
let mut _count = 0u32;
// Get the enum variant
let variant = u32::deserialize(&mut ptr)?;
// Go through each variant
$(
handle_deserialize_enum_variants!(
variant, $enumname, $variant_ident,
orig_ptr, ptr, _count,
$({$($named_field),*})? $(($($tuple_typ),*))?);
_count += 1;
)*
// Failed to find a matching variant, return `None`
None
}
}
};
}
/// Handles serializing of the 3 different enum variant types. Enum struct
/// variants, enum tuple variants, and enum discriminant/bare variants
#[macro_export]
macro_rules! handle_serialize_enum_variants {
// Named enum variants
($self:ident, $enumname:ident, $variant_ident:ident,
$buf:expr, $count:expr, {$($named_field:ident),*}) => {
if let $enumname::$variant_ident { $($named_field),* } = $self {
// Serialize the variant ID
Serialize::serialize($count, $buf);
// Serialize all fields
$(
Serialize::serialize($named_field, $buf);
)*
}
};
// Tuple enum variants
($self:ident, $enumname:ident, $variant_ident:ident,
$buf:expr, $count:expr, ($($tuple_typ:ty),*)) => {
handle_serialize_tuple_match!($self, $count, $buf, $enumname,
$variant_ident $(, $tuple_typ)*);
};
// Discriminant or empty enum variants
($self:ident, $enumname:ident, $variant_ident:ident,
$buf:expr, $count:expr,) => {
if let $enumname::$variant_ident = $self {
// Serialize the variant ID
Serialize::serialize($count, $buf);
}
};
}
/// Handles deserializing of the 3 different enum variant types. Enum struct
/// variants, enum tuple variants, and enum discriminant/bare variants
#[macro_export]
macro_rules! handle_deserialize_enum_variants {
// Named enum variants
($variant:ident, $enumname:ident, $variant_ident:ident, $orig_ptr:expr,
$buf:expr, $count:expr, {$($named_field:ident),*}) => {
if $count == $variant {
// Construct the enum
let ret = $enumname::$variant_ident {
$(
$named_field: Deserialize::deserialize(&mut $buf)?,
)*
};
// Update the original pointer
*$orig_ptr = $buf;
return Some(ret);
}
};
// Tuple enum variants
($variant:ident, $enumname:ident, $variant_ident:ident, $orig_ptr:expr,
$buf:expr, $count:expr, ($($tuple_typ:ty),*)) => {
if $count == $variant {
// Construct the enum
let ret = $enumname::$variant_ident (
$(
<$tuple_typ as Deserialize>::deserialize(&mut $buf)?,
)*
);
// Update the original pointer
*$orig_ptr = $buf;
return Some(ret);
}
};
// Discriminant or empty enum variants
($variant:ident, $enumname:ident, $variant_ident:ident, $orig_ptr:expr,
$buf:expr, $count:expr,) => {
if $count == $variant {
// Construct the enum
let ret = $enumname::$variant_ident;
// Update the original pointer
*$orig_ptr = $buf;
return Some(ret);
}
};
}
#[cfg(test)]
mod test {
#![allow(unused)]
use crate::*;
// Serialize a payload and then validate that when it is deserialized it
// matches the serialized payload identically
macro_rules! test_serdes {
($payload_ty:ty, $payload:expr) => {
// Allocate serialization buffer
let mut buf = Vec::new();
// Serialize `payload`
$payload.serialize(&mut buf);
// Allocate a pointer to the serialized buffer
let mut ptr = &buf[..];
// Deserialize the payload
let deser_payload = <$payload_ty>::deserialize(&mut ptr)
.expect("Failed to deserialize payload");
// Make sure all bytes were consumed from the serialized buffer
assert!(ptr.len() == 0,
"Deserialization did not consume all serialized bytes");
// Make sure the original payload and the deserialized payload
// match
assert!($payload == deser_payload,
"Serialization and deserialization did not match original");
}
}
#[test]
fn test_enums() {
// Not constructable, but we should handle this empty enum case
noodle!(serialize, deserialize,
enum TestA {}
);
// Basic enum
noodle!(serialize, deserialize,
#[derive(PartialEq)]
enum TestB {
Apples,
Bananas,
}
);
test_serdes!(TestB, TestB::Apples);
test_serdes!(TestB, TestB::Bananas);
// Enum with a discriminant
noodle!(serialize, deserialize,
#[derive(PartialEq)]
enum TestC {
Apples = 6,
Bananas
}
);
test_serdes!(TestC, TestC::Apples);
test_serdes!(TestC, TestC::Bananas);
// Enum with all types of variants, and some extra attributes at each
// level to test attribute handling
noodle!(serialize, deserialize,
/// Big doc comment here
/// with many lines
/// you know?
#[derive(PartialEq)]
enum TestD {
#[cfg(test)]
Apples {},
Cars,
Bananas {
/* comment
*/
#[cfg(test)]
x: u32,
/// doc comment
z: i32
},
// Another comment
Cake(),
Weird(,),
Cakes(u32),
Foopie(i8, i32,),
Testing(i128, i64),
Arrayz([u8; 4]),
Lotsotuple(i8,i8,i8,i8,i8,i8,i8,i8,i8,i8,i8,i8,i8,i8,i8,i8),
}
);
test_serdes!(TestD, TestD::Apples {});
test_serdes!(TestD, TestD::Cars);
test_serdes!(TestD, TestD::Bananas { x: 932923, z: -348192 });
test_serdes!(TestD, TestD::Cake());
test_serdes!(TestD, TestD::Weird());
test_serdes!(TestD, TestD::Cakes(0x13371337));
test_serdes!(TestD, TestD::Foopie(-9, 19));
test_serdes!(TestD, TestD::Testing(0xc0c0c0c0c0c0c0c0c0c0c0, -10000));
test_serdes!(TestD, TestD::Arrayz([9; 4]));
test_serdes!(TestD, TestD::Lotsotuple(0,0,0,0,0,5,0,0,0,0,0,0,0,9,0,0));
}
#[test]
fn test_struct() {
// Empty struct
noodle!(serialize, deserialize,
#[derive(PartialEq)]
struct TestA {}
);
test_serdes!(TestA, TestA {});
// Standard struct
noodle!(serialize, deserialize,
#[derive(PartialEq)]
struct TestB {
foo: u32,
bar: i32,
}
);
test_serdes!(TestB, TestB { foo: 4343, bar: -234 });
// Standard struct with some arrays
noodle!(serialize, deserialize,
#[derive(PartialEq)]
struct TestC {
foo: u32,
pub bar: [u32; 8],
}
);
test_serdes!(TestC, TestC { foo: 4343, bar: [10; 8] });
// Bare struct
noodle!(serialize, deserialize,
#[derive(PartialEq)]
struct TestD;
);
test_serdes!(TestD, TestD);
// Empty named tuple
noodle!(serialize, deserialize,
#[derive(PartialEq)]
struct TestE();
);
test_serdes!(TestE, TestE());
// Named tuple
noodle!(serialize, deserialize,
#[derive(PartialEq)]
struct TestF(u32, i128);
);
test_serdes!(TestF, TestF(!0, -42934822412));
// Named tuple with trailing comma
noodle!(serialize, deserialize,
#[derive(PartialEq)]
struct TestG(u32, i128,);
);
test_serdes!(TestG, TestG(4, 6));
// Named tuple with array and nested structure
noodle!(serialize, deserialize,
#[derive(PartialEq)]
struct TestH(u32, [i8; 4], TestG);
);
test_serdes!(TestH, TestH(99, [3; 4], TestG(5, -23)));
}
}
|
// Copyright 2016 The Gofem Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package main
import (
"testing"
"github.com/cpmech/gofem/ana"
"github.com/cpmech/gofem/ele/solid"
"github.com/cpmech/gofem/fem"
"github.com/cpmech/gofem/tests"
"github.com/cpmech/gosl/chk"
"github.com/cpmech/gosl/fun/dbf"
"github.com/cpmech/gosl/io"
"github.com/cpmech/gosl/la"
)
func Test_sigini01(tst *testing.T) {
//tests.Verbose()
chk.PrintTitle("sigini01. zero displacements. initial stresses")
// fem
main := fem.NewMain("data/sigini01.sim", "", true, false, false, false, chk.Verbose, 0)
// set stage
err := main.SetStage(0)
if err != nil {
tst.Errorf("SetStage failed:\n%v", err)
return
}
// initialise solution vectors
err = main.ZeroStage(0, true)
if err != nil {
tst.Errorf("ZeroStage failed:\n%v", err)
return
}
// domain
dom := main.Domains[0]
// check displacements
tolu := 1e-16
for _, n := range dom.Nodes {
eqx := n.GetEq("ux")
eqy := n.GetEq("uy")
u := []float64{dom.Sol.Y[eqx], dom.Sol.Y[eqy]}
chk.Array(tst, "u", tolu, u, nil)
}
// analytical solution
qnV, qnH := -100.0, -50.0
ν := 0.25
σx, σy := qnH, qnV
σz := ν * (σx + σy)
σref := []float64{σx, σy, σz, 0}
// check stresses
e := dom.Elems[0].(*solid.Solid)
tols := 1e-13
for idx, _ := range e.IpsElem {
σ := e.States[idx].Sig
io.Pforan("σ = %v\n", σ)
chk.Array(tst, "σ", tols, σ, σref)
}
}
func Test_sigini02(tst *testing.T) {
//tests.Verbose()
chk.PrintTitle("sigini02. initial stresses. run simulation")
// fem
main := fem.NewMain("data/sigini02.sim", "", true, false, false, false, chk.Verbose, 0)
// run simulation
err := main.Run()
if err != nil {
tst.Errorf("Run failed\n%v", err)
return
}
// domain
dom := main.Domains[0]
// external force
e := dom.Elems[0].(*solid.Solid)
la.PrintMat("K", e.K, "%10.2f", false)
// solution
var sol ana.CteStressPstrain
sol.Init(dbf.Params{
&dbf.P{N: "qnH0", V: -20},
&dbf.P{N: "qnV0", V: -20},
&dbf.P{N: "qnH", V: -50},
&dbf.P{N: "qnV", V: -100},
})
// check displacements
t := dom.Sol.T
tolu := 1e-16
for _, n := range dom.Nodes {
eqx := n.GetEq("ux")
eqy := n.GetEq("uy")
u := []float64{dom.Sol.Y[eqx], dom.Sol.Y[eqy]}
sol.CheckDispl(tst, t, u, n.Vert.C, tolu)
}
// check stresses
tols := 1e-13
for idx, ip := range e.IpsElem {
x := e.Cell.Shp.IpRealCoords(e.X, ip)
σ := e.States[idx].Sig
io.Pforan("σ = %v\n", σ)
sol.CheckStress(tst, t, σ, x, tols)
}
}
func Test_square01(tst *testing.T) {
//tests.Verbose()
chk.PrintTitle("square01. ini stress free square")
// fem
main := fem.NewMain("data/square01.sim", "", true, false, false, false, chk.Verbose, 0)
// run simulation
err := main.Run()
if err != nil {
tst.Errorf("Run failed\n%v", err)
return
}
// domain
dom := main.Domains[0]
// external force
e := dom.Elems[0].(*solid.Solid)
la.PrintMat("K", e.K, "%10.2f", false)
// solution
var sol ana.CteStressPstrain
sol.Init(dbf.Params{
&dbf.P{N: "qnH", V: -50},
&dbf.P{N: "qnV", V: -100},
})
// check displacements
t := dom.Sol.T
tolu := 1e-16
for _, n := range dom.Nodes {
eqx := n.GetEq("ux")
eqy := n.GetEq("uy")
u := []float64{dom.Sol.Y[eqx], dom.Sol.Y[eqy]}
io.Pfyel("u = %v\n", u)
sol.CheckDispl(tst, t, u, n.Vert.C, tolu)
}
// check stresses
tols := 1e-13
for idx, ip := range e.IpsElem {
x := e.Cell.Shp.IpRealCoords(e.X, ip)
σ := e.States[idx].Sig
io.Pforan("σ = %v\n", σ)
sol.CheckStress(tst, t, σ, x, tols)
}
}
func Test_selfweight01(tst *testing.T) {
//tests.Verbose()
chk.PrintTitle("selfweight01. self-weight")
// fem
main := fem.NewMain("data/selfweight01.sim", "", true, true, false, false, chk.Verbose, 0)
// run simulation
err := main.Run()
if err != nil {
tst.Errorf("Run failed\n%v", err)
return
}
// displacement @ top
dom := main.Domains[0]
nod := dom.Vid2node[0]
eqy := nod.GetEq("uy")
uy := dom.Sol.Y[eqy]
uy_cor := -8.737017006803450E-05
io.Pforan("uy @ top = %v (%v)\n", uy, uy_cor)
chk.Float64(tst, "uy @ top", 1e-11, uy, uy_cor)
// check
if true {
skipK := true
tolK := 1e-17
tolu := 1e-11
tols := 1e-5
tests.CompareResults(tst, "data/selfweight01.sim", "cmp/singleq9grav.cmp", "", tolK, tolu, tols, skipK, chk.Verbose, nil)
}
}
func Test_selfweight02(tst *testing.T) {
//tests.Verbose()
chk.PrintTitle("selfweight02. self-weight")
// fem
main := fem.NewMain("data/selfweight02.sim", "", true, true, false, false, chk.Verbose, 0)
// run simulation
err := main.Run()
if err != nil {
tst.Errorf("Run failed\n%v", err)
return
}
// domain and element
dom := main.Domains[0]
ele := dom.Elems[0].(*solid.Solid)
// solution
var sol ana.ConfinedSelfWeight
sol.Init(dbf.Params{
&dbf.P{N: "E", V: 1e3},
&dbf.P{N: "nu", V: 0.25},
&dbf.P{N: "rho", V: 2.0},
&dbf.P{N: "g", V: 10.0},
&dbf.P{N: "h", V: 1.0},
&dbf.P{N: "w", V: 1.0},
})
// check displacements
t := 1.0
tolu := 1e-16
for _, n := range dom.Nodes {
eqx := n.GetEq("ux")
eqy := n.GetEq("uy")
eqz := n.GetEq("uz")
u := []float64{dom.Sol.Y[eqx], dom.Sol.Y[eqy], dom.Sol.Y[eqz]}
io.Pfyel("x=%v u=%v\n", n.Vert.C, u)
sol.CheckDispl(tst, t, u, n.Vert.C, tolu)
}
// check stresses
tols := 1e-13
for idx, ip := range ele.IpsElem {
x := ele.Cell.Shp.IpRealCoords(ele.X, ip)
σ := ele.States[idx].Sig
//io.Pforan("\nσ = %v\n", σ)
sol.CheckStress(tst, t, σ, x, tols)
}
}
|
import * as Yup from 'yup'
import { ValidateOptions } from 'yup/lib/types'
import UnformValidationError from './UnformValidationError'
export const DEFAULT_VALIDATION_OPTIONS: ValidateOptions = {
abortEarly: false,
}
export default async function validateSchema<DataType>(
schema: Yup.AnyObjectSchema,
data: DataType
): Promise<DataType> {
try {
const validatedData = await schema.validate(
data,
DEFAULT_VALIDATION_OPTIONS
)
return validatedData as never
} catch (error) {
if (error instanceof Yup.ValidationError) {
throw new UnformValidationError(error)
}
throw error
}
}
|
def org_site_staff_config(r):
table = current.s3db.hrm_human_resource
settings = current.deployment_settings
if settings.has_module("vol"):
if settings.get_hrm_show_staff():
if settings.get_org_site_volunteers():
field = table.type
field.label = current.T("Type")
field.readable = field.writable = True
elif settings.get_org_site_volunteers():
table.type.default = 2
field = table.organisation_id
field.default = r.record.organisation_id
field.writable = False
field.comment = None |
def obrien_fleming_adjust_n(n, K, alpha, power):
if not isinstance(n, int) or n < 1:
raise ValueError('n must be an integer greater than 1.')
if not isinstance(K, int) or K < 1 or K > 10:
raise ValueError('K must be an integer between 1 and 10.')
if alpha not in [0.01, 0.05, 0.1]:
raise ValueError('alpha must be 0.01, 0.05, or 0.1.')
if power not in [0.8, 0.9]:
raise ValueError('power must be 0.8, or 0.9.')
factors = {
"0.8": {
"0.01": [1.000, 1.001, 1.007, 1.011, 1.015, 1.017, 1.019, 1.021, 1.022, 1.024],
"0.05": [1.000, 1.008, 1.017, 1.024, 1.028, 1.032, 1.035, 1.037, 1.038, 1.040],
"0.1": [1.000, 1.016, 1.027, 1.035, 1.040, 1.044, 1.047, 1.049, 1.051, 1.053],
},
"0.9": {
"0.01": [1.000, 1.001, 1.006, 1.010, 1.014, 1.016, 1.018, 1.020, 1.021, 1.022],
"0.05": [1.000, 1.007, 1.016, 1.022, 1.026, 1.030, 1.032, 1.034, 1.036, 1.037],
"0.1": [1.000, 1.014, 1.025, 1.032, 1.037, 1.041, 1.044, 1.046, 1.048, 1.049],
},
}
return math.ceil(n * factors[str(power)][str(alpha)][K - 1]) |
<reponame>kallisti5/lens
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable, getInjectionToken } from "@ogre-tools/injectable";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import type { KubeObjectStore } from "../kube-object.store";
import { ApiManager } from "./api-manager";
export const kubeObjectStoreInjectionToken = getInjectionToken<KubeObjectStore<any, any, any>>({
id: "kube-object-store-token",
});
const apiManagerInjectable = getInjectable({
id: "api-manager",
instantiate: (di) => {
const apiManager = new ApiManager();
if (di.inject(storesAndApisCanBeCreatedInjectionToken)) {
const stores = di.injectMany(kubeObjectStoreInjectionToken);
for (const store of stores) {
apiManager.registerStore(store);
}
}
return apiManager;
},
});
export default apiManagerInjectable;
|
// Run runs the map worker. It blocks, running until the map queue is
// empty, it encounters an error, or its context is canceled, whichever comes
// first. If this should be run in a goroutine, that is up to the caller.
// The task value is expected to be a JSON-serialized KV struct.
//
// Runs until the context is canceled or an unrecoverable error is encountered.
func (w *MapWorker) Run(ctx context.Context) error {
return w.client.NewWorker(w.InputQueue).Run(ctx, func(ctx context.Context, task *entroq.Task) ([]entroq.ModifyArg, error) {
emitter := w.newEmitter()
if w.EarlyReduce != nil {
emitter = newReducingProxyMapEmitter(emitter, w.EarlyReduce)
}
kv := new(KV)
if err := json.Unmarshal(task.Value, kv); err != nil {
return nil, fmt.Errorf("map run json: %w", err)
}
if err := w.Map(ctx, kv.Key, kv.Value, emitter.Emit); err != nil {
return nil, fmt.Errorf("map run map: %w", err)
}
return emitter.AsModifyArgs(w.OutputPrefix, task.AsDeletion())
})
} |
// Traits with bounds mentioning `Self` are not object safe
trait X {
type U: PartialEq<Self>;
}
fn f() -> Box<dyn X<U = u32>> {
//~^ ERROR the trait `X` cannot be made into an object
loop {}
}
fn main() {}
|
package org.jetbrains.jps.model.impl;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jps.model.JpsDummyElement;
import org.jetbrains.jps.model.ex.JpsElementBase;
/**
* @author nik
*/
public class JpsDummyElementImpl extends JpsElementBase<JpsDummyElementImpl> implements JpsDummyElement {
@NotNull
@Override
public JpsDummyElementImpl createCopy() {
return new JpsDummyElementImpl();
}
@Override
public void applyChanges(@NotNull JpsDummyElementImpl modified) {
}
}
|
/*
* This function is mapped over all of the tree_nodes to find the
* instructions that can be combined with others as an expression tree.
* Nothing is done until reaching a node that ends an expression. At that
* point, if the node is an tree_instr, all of the instructions in its
* expression tree are moved under that tree_instr. Afterwards, if the
* instructions are properly ordered, there should be no instructions
* remaining between the previous expression and the current node.
* If that is not the case, the remaining instructions are "promoted" to
* be independent expressions.
*/
void
cvt_tree_map (tree_node *t, void *x)
{
if (ends_expr(t)) {
if (t->is_instr()) {
tree_instr *ti = (tree_instr *)t;
ti->instr()->src_map(cvt_src_map, NULL);
}
tree_node_list_e *pos = t->list_e()->prev();
while (pos && !ends_expr(pos->contents)) {
tree_instr *ti = (tree_instr *)pos->contents;
assert(ti->is_instr());
operand d = ti->instr()->dst_op();
if (d.is_instr()) {
assert_msg(x,
("cvt_to_trees - node used across expressions but no parent symtab"));
fprintf(stderr, "Warning: cvt_to_trees - "
"node %u used across expressions (promoted)\n",
d.instr()->number());
promote_node(pos, (base_symtab *)x);
}
pos = pos->prev();
}
}
} |
def _isMaskItemSync(self):
if self.maskWidget.isItemMaskUpdated():
return numpy.all(numpy.equal(
self.maskWidget.getSelectionMask(),
self.plot.getActiveImage().getMaskData(copy=False)))
else:
return True |
<reponame>TianyiShi2001/rosalind
fn main() {
let inp = include_str!("hamm.txt")
.trim_end()
.split(char::is_whitespace)
.collect::<Vec<_>>();
let res = hamming_naive(inp[0], inp[1]);
dbg!(res);
}
fn hamming_naive(x: &str, y: &str) -> usize {
assert_eq!(
x.len(),
y.len(),
"The lengths of the two sequences must equal."
);
x.chars().zip(y.chars()).filter(|(p, q)| p != q).count()
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.