blob_id stringlengths 40 40 | directory_id stringlengths 40 40 | path stringlengths 3 264 | content_id stringlengths 40 40 | detected_licenses listlengths 0 85 | license_type stringclasses 2
values | repo_name stringlengths 5 140 | snapshot_id stringlengths 40 40 | revision_id stringlengths 40 40 | branch_name stringclasses 986
values | visit_date timestamp[us] | revision_date timestamp[us] | committer_date timestamp[us] | github_id int64 3.89k 681M ⌀ | star_events_count int64 0 209k | fork_events_count int64 0 110k | gha_license_id stringclasses 23
values | gha_event_created_at timestamp[us] | gha_created_at timestamp[us] | gha_language stringclasses 145
values | src_encoding stringclasses 34
values | language stringclasses 1
value | is_vendor bool 1
class | is_generated bool 2
classes | length_bytes int64 3 10.4M | extension stringclasses 122
values | content stringlengths 3 10.4M | authors listlengths 1 1 | author_id stringlengths 0 158 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
0ed6325fe599ab34e53919dba7e9d20a710e0e74 | c3ec29084bee36982cbb244b65ff96a3210c49a3 | /6.cpp | fcc132f6db406943676bcd1685bb461ac6eaf5ec | [] | no_license | mirnasumopawiro/Challenges-chapter-11 | 7005d6e7fd1dbd3f561b88fc6cd4751a5a4b7a65 | 18c6215c7119fe39db269a1a1d7eb7b4dceebbd7 | refs/heads/master | 2021-01-11T04:44:36.297874 | 2016-10-18T08:42:39 | 2016-10-18T08:42:39 | 71,127,676 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,465 | cpp | //
// 6.cpp
// 17 oct
//
// Created by Mirna Sumopawiro on 10/17/16.
// Copyright © 2016 Mirna Sumopawiro. All rights reserved.
//
#include <iostream>
#include <iomanip>
using namespace std;
struct playerData
{
string name;
int number;
int points;
};
int main ()
{
const int NUM_PLAYER = 12;
playerData input[NUM_PLAYER];
for (int i = 0; i < NUM_PLAYER; i++)
{
cout << "Enter the data for player #" << (i+1) << endl;
cout << "Name: ";
cin >> input[i].name;
cout << "Number: ";
cin >> input[i].number;
cout << "Point: ";
cin >> input[i].points;
}
cout << "Player name: " << "\t\t" << "Player number:" << "\t\t" << "Points:" << endl;
for (int i = 0; i < NUM_PLAYER; i++)
{
cout << input[i].name << "\t\t\t\t\t" << input[i].number << "\t\t\t\t\t" << input[i].points << endl;
}
int totalPoints = 0;
for (int i = 0; i < NUM_PLAYER; i++)
{
totalPoints += input[i].points;
}
cout << "The team total points is " << totalPoints << endl;
//Sort highest points
int highestPoint = 0;
int position;
for (int i = 0; i < NUM_PLAYER; i++)
{
if (input[i].points > highestPoint)
{
highestPoint = input[i].points;
position = i;
}
}
cout << "The highest point is " << highestPoint << " by " << input[position].name << endl;
return 0;
}
| [
"mirnasumopawiro@Rudys-MacBook-Pro.local"
] | mirnasumopawiro@Rudys-MacBook-Pro.local |
295d3be275b8b4861217f133a956ebe7308e7772 | 7ee32ddb0cdfdf1993aa4967e1045790690d7089 | /Codeforces/T3CHFESTProblem6.cpp | 1352703b289e206dc8d0222dc9519e2b5fee2933 | [] | no_license | ajimenezh/Programing-Contests | b9b91c31814875fd5544d63d7365b3fc20abd354 | ad47d1f38b780de46997f16fbaa3338c9aca0e1a | refs/heads/master | 2020-12-24T14:56:14.154367 | 2017-10-16T21:05:01 | 2017-10-16T21:05:01 | 11,746,917 | 1 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 777 | cpp | #include <iostream>
#include <sstream>
#include <vector>
#include <string>
#include <algorithm>
#include <utility>
#include <set>
#include <map>
#include <deque>
#include <queue>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cstdio>
#include <stdio.h>
using namespace std;
int equalization_steps ( const vector<int> &A ) {
int lo = 250000000;
int hi = -250000000;
int n = A.size();
for (int i=0; i<n; i++) {
lo = min(lo,A[i]);
hi = max(hi,A[i]);
}
int mi = (hi+lo)/2;
int res = max(hi-mi,mi-lo);
for (int i=0; i<n; i++) {
if ((abs(A[i]-mi)-res)%2!=0) return -1;
}
return res;
}
int main() {
//freopen("input.txt","r",stdin);
//freopen("output.txt","w",stdout);
return 0;
}
| [
"alejandrojh90@gmail.com"
] | alejandrojh90@gmail.com |
176e55ba515bad0679b51728ce76d3ddf05e212c | 335e56925e49716c7b7766f2bbca71590e0c77a8 | /hdoj/Problem Achieve/1097 A hard puzzle.cpp | 7fe1e6b1b19f0b1f39209c4c50a5954062b64442 | [] | no_license | suzumiyayuhi/AlgorithmTraining | 388b9bfd5aed5d76a20c71ad03b69a5269d2e7a7 | 1af9584fde2ec209429e6b85c5e0381685733c16 | refs/heads/master | 2021-01-18T17:54:03.491535 | 2018-01-20T10:57:12 | 2018-01-20T10:57:12 | 86,822,395 | 4 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 348 | cpp | #include<cstdio>
#include<iostream>
using namespace std;
int tab[10][4]={0,0,0,0,
1,1,1,1,
2,4,8,6,
3,9,7,1,
4,6,4,6,
5,5,5,5,
6,6,6,6,
7,9,3,1,
8,4,2,6,
9,1,9,1};
int main()
{
int n,c,res;
while(cin>>n>>c)
{
n%=10;
c%=4;
if(c!=0)
res=tab[n][c-1];
else
res=tab[n][3];
printf("%d\n",res);
}
}
| [
"923051761@qq.com"
] | 923051761@qq.com |
9cd9ca1147471402e5deba2074980575f8ebe822 | de5f555645ac0f70a129d5531fdc3934b1803bea | /Online-Judges/SPOJ/NAKANJ.cc | 5b7dd8c7a72b948608267b567afe3c329b4ee359 | [] | no_license | kaushal02/CP | 52737875c70a40b3e0f7885b2553fdb1b7447bf9 | 704543bcd17e75759a584f88300033a348dc71ab | refs/heads/master | 2022-10-20T06:59:33.421829 | 2022-10-18T05:25:54 | 2022-10-18T05:26:20 | 70,631,083 | 33 | 18 | null | 2018-10-26T13:48:52 | 2016-10-11T20:09:00 | C++ | UTF-8 | C++ | false | false | 2,486 | cc | #include <iostream>
#include <cassert>
#include <vector>
#include <queue>
using namespace std;
class ChessBoardKnights {
const int dx[8] = {-1, 1, -2, 2, -2, 2, -1, 1};
const int dy[8] = {-2, -2, -1, -1, 1, 1, 2, 2};
struct node {
int x, y, steps;
node(int _x, int _y, int _steps): x(_x), y(_y), steps(_steps) {}
bool invalid(int n) {
return x < 0 or x >= n or y < 0 or y >= n;
}
};
int n;
vector <vector <int> > ans;
int getId(int i, int j) {
return i * n + j;
}
int getIdFromName(string name) {
return getId(name[1] - '1', name[0] - 'a');
}
void bfs(int x, int y, vector <int>& visited) {
queue <node> q;
visited[getId(x, y)] = 0;
q.push(node(x, y, 0));
while (!q.empty()) {
node cur = q.front();
q.pop();
for (int d = 0; d < 8; d++) {
node next(cur.x + dx[d], cur.y + dy[d], cur.steps + 1);
if (next.invalid(n)) {
continue;
}
int id = getId(next.x, next.y);
if (visited[id] == -1) {
visited[id] = next.steps;
q.push(next);
}
}
}
}
void initHelper(int x, int y) {
int id = getId(x, y);
ans[id][id] = 0;
bfs(x, y, ans[id]);
}
public:
ChessBoardKnights(int _n): n(_n) {
ans.resize(n * n, vector <int>(n * n, -1));
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
initHelper(i, j);
}
}
}
int minimumMoves(string pos1, string pos2) {
return ans[getIdFromName(pos1)][getIdFromName(pos2)];
}
static void unittests() {
assert(ChessBoardKnights(8).minimumMoves("a1", "a1") == 0);
assert(ChessBoardKnights(8).minimumMoves("a1", "c2") == 1);
assert(ChessBoardKnights(8).minimumMoves("a1", "b3") == 1);
assert(ChessBoardKnights(8).minimumMoves("a1", "a3") == 2);
assert(ChessBoardKnights(8).minimumMoves("a1", "a5") == 2);
assert(ChessBoardKnights(8).minimumMoves("a1", "c3") == 4);
}
};
int main() {
ChessBoardKnights::unittests();
ChessBoardKnights board(8);
int cases; cin >> cases;
while (cases--) {
string pos1, pos2;
cin >> pos1 >> pos2;
cout << board.minimumMoves(pos1, pos2) << '\n';
}
return 0;
} | [
"kaushal0181@gmail.com"
] | kaushal0181@gmail.com |
f2ef5cb6e1965f4379541112dae262f9ee17e35d | c5b90ffa3acbefa7582bc73b43fa71a177853094 | /main.cpp | c2e0ef5fe36f4a1288baed1feaa2f97112b9bdaa | [] | no_license | keptil/NICOLE-AI | 89afe39c25268ec2f23e1a7407e8f099c52dcced | 6175211142192c4ad5368374b51a1c80d6924536 | refs/heads/master | 2021-01-19T00:39:34.258177 | 2010-10-09T03:19:30 | 2010-10-09T03:19:30 | 925,300 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 952 | cpp | #include <iostream>
#include <string>
#include "strmath.cpp"
#include "nicole_server.cpp"
using namespace std;
int main()
{
Tokenizer token;
token.add_break("!, :");
SERVER_INTERFACE *servint = new SERVER_INTERFACE();
cout << "Waiting for connections...\n";
while (!servint->Listen())
{
cout << "Waiting for connections.\n";
}
cout << "Connection received, starting.\n";
while (1)
{
cout << "Reading input from client application.\n";
string *a = new string;
*a = servint->read_input();
if (*a != "")
{
cout << *a << endl;
token.feed(*a);
token.tokenize();
}
if (!(low_string(token.word[5]).find("hello") == string::npos) && !(low_string(token.word[6]).find("nicole") == string::npos))
{
string tmp = "SEND Hello, " + token.word[1] + "! ";
servint->send(tmp);
}
cout << "End of loop.\n";
servint->send(" 0 ");
delete a;
}
delete servint;
}
| [
"keptilguitarplayer@gmail.com"
] | keptilguitarplayer@gmail.com |
7bc3be683bb381b89b73b18e6b114de4e71c5c99 | 9393361c9528b8f3d2942218fbad22830c362d1b | /session13/01LinkedList.cc | faf7a4b69604f9576b5057ec3c4466426affd7c5 | [] | no_license | 007Robin/Practice | 062b661208e2ac3f9e4f675800dc33a20e7e0785 | a619c9d2d3d891d90d1af14dec204a9b53ad8570 | refs/heads/master | 2021-06-09T09:30:54.946624 | 2020-08-24T03:43:46 | 2020-08-24T03:43:46 | 100,123,229 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 878 | cc | #include "01LinkedList.hh"
//template<typename T>
LinkedList::LinkedList(){
head = nullptr;
}
//template<typename T>
void LinkedList::addFirst(const string& v){
head = new Node(head, v);
}
//template<typename T>
void LinkedList::addLast(const string& v){
if(head == nullptr){
head = new Node(nullptr, v);
return;
}
LinkedList::Node* p;
for(p = head; p->next != nullptr; p = p->next)
;
p->next = new Node(nullptr, v);
}
//template<typename T>
void LinkedList::removeFirst() {
LinkedList::Node* temp = head;
head = head->next; //if head is null. head->next make no sense
delete temp; //must memory delete
}
//template<typename T>
std::ostream& operator<<(std::ostream& s, const LinkedList& list){ //c++11
LinkedList::Node* p;
for(p = list.head; p != nullptr; p = p->next){ //p++ only memery adress +1, must p = p->next
s << p->val << " ";
}
return s;
}
| [
"noreply@github.com"
] | 007Robin.noreply@github.com |
ea7a2106215317a949e90e90658eeab8367b3149 | 5899fefb8ec219f1b05035ec0c3c36c126c535a8 | /Data structures/Trees/Balanced Binary Tree.cpp | 93b98ae14fa75ed17ecc7608ac17eef59b4fc006 | [] | no_license | barani008/C-programs | ae702b58292e3439e1737c41cc95894132723162 | a8ea485c0b01b7d4051bea6b12dcd8111b0651ab | refs/heads/master | 2021-01-06T20:35:03.911077 | 2017-10-02T02:33:40 | 2017-10-02T02:33:40 | 99,524,882 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 892 | cpp | /**
Given a binary tree, determine if it is height-balanced.
For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of every node never differ by more than 1.
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
bool is_balanced;
bool isBalanced(TreeNode* root) {
is_balanced = true;
height1(root, 0);
return is_balanced;
}
int height1(TreeNode* root, int height){
if(root==NULL)
return height;
int left = height1(root->left, height+1);
int right = height1(root->right, height+1);
if(abs(left-right)>1)
is_balanced = false;
return max(left, right);
}
}; | [
"barani008@gmail.com"
] | barani008@gmail.com |
b0a268d0639f0acbbb591452d436617819332e11 | b1cd56bd4445a9a4b6dc1c164a41cc229b968c46 | /CODEFORCES/DIVISON 2/696/z.cpp | b92f1599823d2cb57324c5c4771d15d162ee7763 | [] | no_license | Manvityagi/Codechef-Codeforces-spoj | ee6668d8dee2c13adc1592ed53f5d1ce10accc46 | 2ea51729061f140086e967d90d5a52c634375676 | refs/heads/master | 2023-04-26T05:34:30.473878 | 2021-06-02T13:09:27 | 2021-06-02T13:09:27 | 201,567,207 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 691 | cpp | #include <bits/stdc++.h>
using namespace std;
#define PB push_back
#define F first
#define S second
#define MP make_pair
#define LL long long
#define ULL unsigned long long
#define LB lower_bound
#define MOD1 1000000007
#define MOD2 1000000009
#define int LL
#define pii pair<int,int>
#define all(a) a.begin(), a.end()
const int maxn = 1e5 + 1;
void solve()
{
int n;
cin >> n;
vector<int> p(n);
for(auto &i : p)cin >> i;
}
signed main()
{
static const int _ = []() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
return 0;
}();
int t = 1;
cin >> t;
while (t--){
solve();
}
return 0;
} | [
"manvityagi770@gmail.com"
] | manvityagi770@gmail.com |
21e43fd57fdcb8bc826ed04892fe447215059aa4 | 3cf9e141cc8fee9d490224741297d3eca3f5feff | /C++ Benchmark Programs/Benchmark Files 1/classtester/autogen-sources/source-12081.cpp | 1acb093375dff0091bb9fb0847a30834c24d1695 | [] | no_license | TeamVault/tauCFI | e0ac60b8106fc1bb9874adc515fc01672b775123 | e677d8cc7acd0b1dd0ac0212ff8362fcd4178c10 | refs/heads/master | 2023-05-30T20:57:13.450360 | 2021-06-14T09:10:24 | 2021-06-14T09:10:24 | 154,563,655 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 2,711 | cpp | struct c0;
void __attribute__ ((noinline)) tester0(c0* p);
struct c0
{
bool active0;
c0() : active0(true) {}
virtual ~c0()
{
tester0(this);
active0 = false;
}
virtual void f0(){}
};
void __attribute__ ((noinline)) tester0(c0* p)
{
p->f0();
}
struct c1;
void __attribute__ ((noinline)) tester1(c1* p);
struct c1
{
bool active1;
c1() : active1(true) {}
virtual ~c1()
{
tester1(this);
active1 = false;
}
virtual void f1(){}
};
void __attribute__ ((noinline)) tester1(c1* p)
{
p->f1();
}
struct c2;
void __attribute__ ((noinline)) tester2(c2* p);
struct c2 : virtual c1
{
bool active2;
c2() : active2(true) {}
virtual ~c2()
{
tester2(this);
c1 *p1_0 = (c1*)(c2*)(this);
tester1(p1_0);
active2 = false;
}
virtual void f2(){}
};
void __attribute__ ((noinline)) tester2(c2* p)
{
p->f2();
if (p->active1)
p->f1();
}
struct c3;
void __attribute__ ((noinline)) tester3(c3* p);
struct c3 : virtual c2, virtual c0
{
bool active3;
c3() : active3(true) {}
virtual ~c3()
{
tester3(this);
c0 *p0_0 = (c0*)(c3*)(this);
tester0(p0_0);
c1 *p1_0 = (c1*)(c2*)(c3*)(this);
tester1(p1_0);
c2 *p2_0 = (c2*)(c3*)(this);
tester2(p2_0);
active3 = false;
}
virtual void f3(){}
};
void __attribute__ ((noinline)) tester3(c3* p)
{
p->f3();
if (p->active0)
p->f0();
if (p->active1)
p->f1();
if (p->active2)
p->f2();
}
struct c4;
void __attribute__ ((noinline)) tester4(c4* p);
struct c4 : c2, c0, virtual c1
{
bool active4;
c4() : active4(true) {}
virtual ~c4()
{
tester4(this);
c0 *p0_0 = (c0*)(c4*)(this);
tester0(p0_0);
c1 *p1_0 = (c1*)(c2*)(c4*)(this);
tester1(p1_0);
c1 *p1_1 = (c1*)(c4*)(this);
tester1(p1_1);
c2 *p2_0 = (c2*)(c4*)(this);
tester2(p2_0);
active4 = false;
}
virtual void f4(){}
};
void __attribute__ ((noinline)) tester4(c4* p)
{
p->f4();
if (p->active0)
p->f0();
if (p->active2)
p->f2();
if (p->active1)
p->f1();
}
int __attribute__ ((noinline)) inc(int v) {return ++v;}
int main()
{
c0* ptrs0[25];
ptrs0[0] = (c0*)(new c0());
ptrs0[1] = (c0*)(c3*)(new c3());
ptrs0[2] = (c0*)(c4*)(new c4());
for (int i=0;i<3;i=inc(i))
{
tester0(ptrs0[i]);
delete ptrs0[i];
}
c1* ptrs1[25];
ptrs1[0] = (c1*)(new c1());
ptrs1[1] = (c1*)(c2*)(new c2());
ptrs1[2] = (c1*)(c2*)(c3*)(new c3());
ptrs1[3] = (c1*)(c2*)(c4*)(new c4());
ptrs1[4] = (c1*)(c4*)(new c4());
for (int i=0;i<5;i=inc(i))
{
tester1(ptrs1[i]);
delete ptrs1[i];
}
c2* ptrs2[25];
ptrs2[0] = (c2*)(new c2());
ptrs2[1] = (c2*)(c3*)(new c3());
ptrs2[2] = (c2*)(c4*)(new c4());
for (int i=0;i<3;i=inc(i))
{
tester2(ptrs2[i]);
delete ptrs2[i];
}
c3* ptrs3[25];
ptrs3[0] = (c3*)(new c3());
for (int i=0;i<1;i=inc(i))
{
tester3(ptrs3[i]);
delete ptrs3[i];
}
c4* ptrs4[25];
ptrs4[0] = (c4*)(new c4());
for (int i=0;i<1;i=inc(i))
{
tester4(ptrs4[i]);
delete ptrs4[i];
}
return 0;
}
| [
"ga72foq@mytum.de"
] | ga72foq@mytum.de |
7abc03fde70c4fbc9ac2d8818cf446ef153a0f31 | 9016e3870e9e06957f25e127b3f50225db4d65b4 | /src/net/http/http_auth_handler_ntlm_portable.cc | 37022cd4b2b86c3f20132a09b81be51e7dafdbe3 | [
"BSD-3-Clause"
] | permissive | bylond/naiveproxy | f0a30493e0662251247a87c73a1b73388ef16d1b | a04a8330a8bb0d0892259cf6d795271fbe6e6d0e | refs/heads/master | 2021-02-02T00:46:35.836722 | 2020-03-11T03:43:22 | 2020-03-11T03:43:22 | 243,525,007 | 1 | 0 | BSD-3-Clause | 2020-03-11T03:43:23 | 2020-02-27T13:23:59 | null | UTF-8 | C++ | false | false | 6,352 | cc | // Copyright (c) 2012 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 "net/http/http_auth_handler_ntlm.h"
#include "base/base64.h"
#include "base/metrics/histogram_macros.h"
#include "base/rand_util.h"
#include "base/time/time.h"
#include "net/base/net_errors.h"
#include "net/base/network_interfaces.h"
#include "net/dns/host_resolver.h"
#include "net/http/http_auth.h"
#include "net/http/http_auth_challenge_tokenizer.h"
#include "net/http/http_auth_handler_ntlm.h"
#include "net/http/http_auth_multi_round_parse.h"
#include "net/http/http_auth_preferences.h"
#include "net/http/http_auth_scheme.h"
#include "net/ssl/ssl_info.h"
namespace net {
namespace {
uint64_t GetMSTime() {
return base::Time::Now().since_origin().InMicroseconds() * 10;
}
void GenerateRandom(uint8_t* output, size_t n) {
base::RandBytes(output, n);
}
} // namespace
int HttpAuthHandlerNTLM::Factory::CreateAuthHandler(
HttpAuthChallengeTokenizer* challenge,
HttpAuth::Target target,
const SSLInfo& ssl_info,
const GURL& origin,
CreateReason reason,
int digest_nonce_count,
const NetLogWithSource& net_log,
HostResolver* host_resolver,
std::unique_ptr<HttpAuthHandler>* handler) {
if (reason == CREATE_PREEMPTIVE)
return ERR_UNSUPPORTED_AUTH_SCHEME;
// TODO(cbentzel): Move towards model of parsing in the factory
// method and only constructing when valid.
// NOTE: Default credentials are not supported for the portable implementation
// of NTLM.
std::unique_ptr<HttpAuthHandler> tmp_handler(
new HttpAuthHandlerNTLM(http_auth_preferences()));
if (!tmp_handler->InitFromChallenge(challenge, target, ssl_info, origin,
net_log))
return ERR_INVALID_RESPONSE;
handler->swap(tmp_handler);
return OK;
}
// static
HttpAuthHandlerNTLM::GetMSTimeProc HttpAuthHandlerNTLM::get_ms_time_proc_ =
GetMSTime;
// static
HttpAuthHandlerNTLM::GenerateRandomProc
HttpAuthHandlerNTLM::generate_random_proc_ = GenerateRandom;
// static
HttpAuthHandlerNTLM::HostNameProc HttpAuthHandlerNTLM::get_host_name_proc_ =
GetHostName;
HttpAuthHandlerNTLM::HttpAuthHandlerNTLM(
const HttpAuthPreferences* http_auth_preferences)
: ntlm_client_(ntlm::NtlmFeatures(
http_auth_preferences ? http_auth_preferences->NtlmV2Enabled()
: true)) {}
bool HttpAuthHandlerNTLM::NeedsIdentity() {
// This gets called for each round-trip. Only require identity on the first
// call (when challenge_token_ is empty). On subsequent calls, we use the
// initially established identity.
return challenge_token_.empty();
}
bool HttpAuthHandlerNTLM::AllowsDefaultCredentials() {
// Default credentials are not supported in the portable implementation of
// NTLM, but are supported in the SSPI implementation.
return false;
}
int HttpAuthHandlerNTLM::GenerateAuthTokenImpl(
const AuthCredentials* credentials,
const HttpRequestInfo* request,
CompletionOnceCallback callback,
std::string* auth_token) {
// TODO(cbentzel): Shouldn't be hitting this case.
if (!credentials) {
LOG(ERROR) << "Username and password are expected to be non-nullptr.";
return ERR_MISSING_AUTH_CREDENTIALS;
}
// The username may be in the form "DOMAIN\user". Parse it into the two
// components.
base::string16 domain;
base::string16 user;
const base::string16& username = credentials->username();
const base::char16 backslash_character = '\\';
size_t backslash_idx = username.find(backslash_character);
if (backslash_idx == base::string16::npos) {
user = username;
} else {
domain = username.substr(0, backslash_idx);
user = username.substr(backslash_idx + 1);
}
domain_ = domain;
credentials_.Set(user, credentials->password());
std::vector<uint8_t> next_token =
GetNextToken(base::as_bytes(base::make_span(challenge_token_)));
if (next_token.empty())
return ERR_UNEXPECTED;
// Base64 encode data in output buffer and prepend "NTLM ".
std::string encode_output;
base::Base64Encode(
base::StringPiece(reinterpret_cast<const char*>(next_token.data()),
next_token.size()),
&encode_output);
*auth_token = std::string("NTLM ") + encode_output;
return OK;
}
HttpAuthHandlerNTLM::~HttpAuthHandlerNTLM() = default;
// static
HttpAuthHandlerNTLM::GetMSTimeProc HttpAuthHandlerNTLM::SetGetMSTimeProc(
GetMSTimeProc proc) {
GetMSTimeProc old_proc = get_ms_time_proc_;
get_ms_time_proc_ = proc;
return old_proc;
}
// static
HttpAuthHandlerNTLM::GenerateRandomProc
HttpAuthHandlerNTLM::SetGenerateRandomProc(GenerateRandomProc proc) {
GenerateRandomProc old_proc = generate_random_proc_;
generate_random_proc_ = proc;
return old_proc;
}
// static
HttpAuthHandlerNTLM::HostNameProc HttpAuthHandlerNTLM::SetHostNameProc(
HostNameProc proc) {
HostNameProc old_proc = get_host_name_proc_;
get_host_name_proc_ = proc;
return old_proc;
}
std::vector<uint8_t> HttpAuthHandlerNTLM::GetNextToken(
base::span<const uint8_t> in_token) {
// If in_token is non-empty, then assume it contains a challenge message,
// and generate the Authenticate message in reply. Otherwise return the
// Negotiate message.
if (in_token.empty()) {
return ntlm_client_.GetNegotiateMessage();
}
std::string hostname = get_host_name_proc_();
if (hostname.empty())
return {};
uint8_t client_challenge[8];
generate_random_proc_(client_challenge, 8);
uint64_t client_time = get_ms_time_proc_();
return ntlm_client_.GenerateAuthenticateMessage(
domain_, credentials_.username(), credentials_.password(), hostname,
channel_bindings_, CreateSPN(origin_), client_time, client_challenge,
in_token);
}
HttpAuth::AuthorizationResult HttpAuthHandlerNTLM::ParseChallenge(
HttpAuthChallengeTokenizer* tok,
bool initial_challenge) {
challenge_token_.clear();
if (initial_challenge)
return ParseFirstRoundChallenge(HttpAuth::Scheme::AUTH_SCHEME_NTLM, tok);
std::string encoded_token;
return ParseLaterRoundChallenge(HttpAuth::Scheme::AUTH_SCHEME_NTLM, tok,
&encoded_token, &challenge_token_);
}
} // namespace net
| [
"kizdiv@gmail.com"
] | kizdiv@gmail.com |
02c92da178263af99c2c09237a230b808344c01c | db2a9059ece34bbce9fdd532a265ace38f0e1196 | /Timus/Graph Theory/1982.cpp | 2c039c6509199f487ead39c45a5724e87b0d9e50 | [] | no_license | aayushdw/Competitve | 65eba6f385a2fd047512d577e809480e8c75aadf | d883b80363f2447a353a1cd5d33ee33ea9ae217e | refs/heads/master | 2020-04-11T15:15:07.254957 | 2019-01-14T21:27:29 | 2019-01-14T21:27:29 | 161,885,303 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,269 | cpp | #include<bits/stdc++.h>
#define si(x) scanf("%d",&x)
#define sf(x) scanf("%lf",&x)
#define sl(x) scanf("%lld",&x)
#define pr(x) printf("%d\n",x)
#define prll(x) printf("%lld\n",x)
#define ll long long int
#define ull unsigned long long int
#define F first
#define S second
#define rep(i,x,y) for(int i=x;i<y;i++)
#define ii pair<int,int>
#define pll pair<ll,ll>
#define vi vector<int>
#define vvi vector< vi >
#define vl vector<long long int>
#define vvl vector< vl >
#define vii vector< ii >
#define vvii vector< vii >
#define priority_queue pq;
#define sz(a) ll((a).size())
#define pb push_back
#define mp make_pair
#define ROUNDOFFINT(d) d = (int)((double)d + 0.5)
#define SET(a,b) memset(a,b,sizeof(a))
#define all(c) (c).begin(),(c).end()
#define tr(i,c) for(typeof((c).begin()) i = (c).begin(); i != (c).end(); i++)
#define present(c,x) ((c).find(x) != (c).end())
#define cpresent(c,x) (find(all(c),x) != (c).end())
#define ison(x,i) (((x) >> (i)) & 1) //checks if ith bit is on
#define set0(x,i) (x & ~(1 << i)) //set ith bit in x to be zero
#define clr(a) memset(a,0,sizeof(a))
#define MOD 1000000007
#define INF 4000000000000000000
#define MAX 100+5
using namespace std;
int a[MAX];
set< pair< int,ii > > edge;
typeof(edge.begin()) it;
set<int> s;
class DSU
{
public:
vi par,rank,sum;
void init(int n)
{
par.assign(n,0);
rank.assign(n,1);
sum.assign(n,0);
rep(i,0,n)
par[i]=i;
}
int find(int u)
{ return (par[u]==u)?u:find(par[u]); }
int getSum(int u)
{ return (par[u]==u)?0:sum[u]^getSum(par[u]); }
void unite(int x,int v,int val)
{
x=find(x); v=find(v);
if(x==v) return;
if(rank[x]>rank[v]) swap(x,v);
if(s.find(x)!=s.end()) swap(x,v);
par[x]=v;
rank[v]+=rank[x];
sum[x]=val;
}
};
int main()
{
int n,k,p;
si(n); si(k);
rep(i,0,k)
{
si(a[i]);
a[i]--;
s.insert(a[i]);
}
rep(i,0,n)
rep(j,0,n)
{
si(p);
if(p)
edge.insert(mp(p,mp(i,j)));
}
int num=n,ans=0,cost;
DSU G;
G.init(n);
while(num>k)
{
it=edge.begin();
cost=it->F;
int u=it->S.F;
int v=it->S.S;
edge.erase(it);
int uu=G.find(u);
int vv=G.find(v);
if(uu!=vv)
{
if(s.find(uu)!=s.end() && s.find(vv)!=s.end())
continue;
ans+=cost;
G.unite(uu,vv,0);
num--;
}
}
pr(ans);
return 0;
} | [
"aayushdw@gmail.com"
] | aayushdw@gmail.com |
753f8ec7e62ef51981ca912cb416a309350ba9ab | a72d01c6c8dfdd687e9cc9b9bf4f4959e9d74f5d | /PRINCIPLE/plato/include/plato/import/shopImporter.hpp | b3cc0c3e8552b9364625db657c71be4fea4a878a | [] | no_license | erinmaus/autonomaus | 8a3619f8380eae451dc40ba507b46661c5bc8247 | 9653f27f6ef0bbe14371a7077744a1fd8b97ae8d | refs/heads/master | 2022-10-01T01:24:23.028210 | 2018-05-09T21:59:26 | 2020-06-10T21:08:09 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 386 | hpp | // This file is a part of PRINCIPLE.
//
// Look, but don't touch.
//
// Copyright 2017 [bk]door.maus
#ifndef PLATO_IMPORT_SHO_IMPORTER_HPP
#define PLATO_IMPORT_SHO_IMPORTER_HPP
#include "plato/import/importer.hpp"
namespace plato
{
class ShopImporter : public Importer
{
public:
int import(
const Json::Value& value,
twoflower::Brochure& brochure) override;
};
}
#endif
| [
"squeak@erinmaus.com"
] | squeak@erinmaus.com |
f0a3dba789bdd4eb828bca8a2597f2e2f440cb31 | c861202141e29f79e9a358bb072cf7fd64fcc66e | /ClassOJ-2019Spring/class_3_6.cpp | 9aa4c63f26e0a529f5fae07cb6da0ae65d96c386 | [] | no_license | fanleehao/Algorithm | 363aaecaf722d6c0d49703bc93745db83849f8b4 | 7b6b8514850bd746100ea58d777bf3e81f26e827 | refs/heads/master | 2020-04-25T16:16:52.515036 | 2019-08-15T12:17:40 | 2019-08-15T12:17:40 | 172,905,375 | 2 | 0 | null | null | null | null | GB18030 | C++ | false | false | 1,535 | cpp | #include<iostream>
#include<math.h>
#include<algorithm>
#include<string.h>
#include<string>
#include<stdlib.h>
#include<stdio.h>
#include<vector>
#include<sstream>
#include<iomanip>
#include<stack>
#include<map>
#include<cstdlib>
#include<bits/stdc++.h>
#define LL long long //9223372036854775807(19位) 2的63次方
#define debug cout<<"******"<<endl;
#define INF 0x3fffffff
#define MAX 101000
using namespace std;
//序列成环问题
int main()
{
int T;
scanf("%d", &T);
while(T--)
{
int N;
scanf("%d", &N);
map<int,pair<int,int> > mp;
map<int,int> visit;
string str;
for(int i = 0; i < N; i++)
{
cin>>str;
if(str[0]==str[str.length()-1])
visit[str[0]-'a']++;
else
{
mp[str[0]-'a'].first++;
mp[str[str.length()-1]-'a'].second++;
}
}
int flag=1;
for(int it = 0; it < 26; it++)
{
if(visit[it]!=0)
{
if(visit[it]!=mp[it].first || visit[it]!=mp[it].second)
{
if(visit[it]==N)
continue;
flag=0;
break;
}
}
else
{
if(mp[it].first!=mp[it].second)
{
flag=0;
break;
}
}
}
cout<<flag<<endl;
}
return 0;
}
| [
"fanleehao@gmail.com"
] | fanleehao@gmail.com |
8a42526c264a74b701301f313048e691a21366b7 | ef927955ec4904a79f11be34038af7f6f75bd31f | /grxsdk/inc/ModelDocObj/DbViewRepStandard.h | 38ed29bdb415a26806c2a168e34331e25d88b971 | [] | no_license | 15831944/arxloader | 610842b913b1fea16133564ff532a4207daf076a | b9d2888953b04ab53743ddae6751d871d2a23dae | refs/heads/master | 2023-04-13T14:54:28.462797 | 2021-04-27T12:37:05 | 2021-04-27T12:37:05 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,766 | h | ///////////////////////////////////////////////////////////////////////////////
// Copyright (C) 2002-2021, Open Design Alliance (the "Alliance").
// All rights reserved.
//
// This software and its documentation and related materials are owned by
// the Alliance. The software may only be incorporated into application
// programs owned by members of the Alliance, subject to a signed
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable
// trade secrets of the Alliance and its suppliers. The software is also
// protected by copyright law and international treaty provisions. Application
// programs incorporating this software must include the following statement
// with their copyright notices:
//
// This application incorporates Open Design Alliance software pursuant to a license
// agreement with Open Design Alliance.
// Open Design Alliance Copyright (C) 2002-2021 by Open Design Alliance.
// All rights reserved.
//
// By use of this software, its documentation or related materials, you
// acknowledge and accept the above terms.
///////////////////////////////////////////////////////////////////////////////
#ifndef OD_VIEWREPSTANDARD_H
#define OD_VIEWREPSTANDARD_H
#include "DbObject.h"
#include "ModelDocObjExports.h"
#include "TD_PackPush.h"
/** \details
Corresponding C++ library: AcModelDocObj
<group OdModelDocObj_Classes>
*/
class MODELDOCOBJ_EXPORT OdDbViewRepStandard : public OdDbObject
{
public:
//enum DpiResolutionType {};
//enum ProjectionType {};
//enum SectionThreadEndDisplayType {};
//enum CircularThreadEdgeDisplayType {};
//enum PreviewDisplayType {};
//enum SynergyVersion {};
ODDB_DECLARE_MEMBERS(OdDbViewRepStandard);
//OdDbViewRepStandard(enum OdDbViewRepStandard::DpiResolutionType,
// enum OdDbViewRepStandard::ProjectionType,
// enum OdDbViewRepStandard::SectionThreadEndDisplayType,
// enum OdDbViewRepStandard::CircularThreadEdgeDisplayType,
// enum OdDbViewRepStandard::PreviewDisplayType,
// enum OdDbViewRepStandard::SynergyVersion);
OdDbViewRepStandard();
virtual ~OdDbViewRepStandard();
//enum OdDbViewRepStandard::SynergyVersion synergyVersion() const;
//enum OdDbViewRepStandard::PreviewDisplayType previewDisplayType() const;
//enum OdDbViewRepStandard::CircularThreadEdgeDisplayType circularThreadEdgeDisplayType() const;
//enum OdDbViewRepStandard::SectionThreadEndDisplayType sectionThreadEndDisplayType() const;
//enum OdDbViewRepStandard::ProjectionType projectionType() const;
//enum OdDbViewRepStandard::DpiResolutionType dpiResolutionType() const;
protected:
// OdDbObject methods :
virtual OdResult dwgInFields(OdDbDwgFiler* pFiler);
virtual OdResult dwgOutFields(OdDbDwgFiler* pFiler) const;
virtual OdResult dxfInFields(OdDbDxfFiler* pFiler);
virtual OdResult dxfOutFields(OdDbDxfFiler* pFiler) const;
//private:
// OdResult initialize();
// void setPreviewDisplayType(enum OdDbViewRepStandard::PreviewDisplayType);
// void setCircularThreadEdgeDisplayType(enum OdDbViewRepStandard::CircularThreadEdgeDisplayType);
// void setSectionThreadEndDisplayType(enum OdDbViewRepStandard::SectionThreadEndDisplayType);
// void setProjectionType(enum OdDbViewRepStandard::ProjectionType);
// void setDpiResolutionType(enum OdDbViewRepStandard::DpiResolutionType);
};
/** \details
This template class is a specialization of the OdSmartPtr class for OdDbViewRepStandard object pointers.
*/
typedef OdSmartPtr<OdDbViewRepStandard> OdDbViewRepStandardPtr;
#include "TD_PackPop.h"
#endif // OD_VIEWREPSTANDARD_H
| [
"dengtao@gstarcad.com"
] | dengtao@gstarcad.com |
1413a823e060c04fb3b601a97fc3824e7faa6d26 | b0dd7779c225971e71ae12c1093dc75ed9889921 | /libs/wave/test/testwave/testfiles/t_4_002.cpp | 3a303bd83421f6302f9997a15d58b2db2292f0b2 | [
"LicenseRef-scancode-warranty-disclaimer",
"BSL-1.0"
] | permissive | blackberry/Boost | 6e653cd91a7806855a162347a5aeebd2a8c055a2 | fc90c3fde129c62565c023f091eddc4a7ed9902b | refs/heads/1_48_0-gnu | 2021-01-15T14:31:33.706351 | 2013-06-25T16:02:41 | 2013-06-25T16:02:41 | 2,599,411 | 244 | 154 | BSL-1.0 | 2018-10-13T18:35:09 | 2011-10-18T14:25:18 | C++ | UTF-8 | C++ | false | false | 859 | cpp | /*=============================================================================
Boost.Wave: A Standard compliant C++ preprocessor library
http://www.boost.org/
Copyright (c) 2001-2012 Hartmut Kaiser. Distributed under the Boost
Software License, Version 1.0. (See accompanying file
LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
// Tests, whether ecursively defined macros get expanded correctly in the
// context of an #if expression
#define C C
//R #line 18 "t_4_002.cpp"
//R true
#if !C
true
#endif
//H 10: t_4_002.cpp(13): #define
//H 08: t_4_002.cpp(13): C=C
//H 10: t_4_002.cpp(17): #if
//H 01: t_4_002.cpp(13): C
//H 02: C
//H 03: C
//H 11: t_4_002.cpp(17): #if !C: 1
//H 10: t_4_002.cpp(19): #endif
| [
"tvaneerd@rim.com"
] | tvaneerd@rim.com |
2aabbd67e0ed8106c28c01c4d1f9d4d6f367566f | d233b426ee3462457a35bcb97d54d418fba25e6c | /Source/Services/Tournaments/WinRT/TournamentRequest_WinRT.h | c3eb1860737b7fc4a142d85a062ccdee1df2ca93 | [
"MIT"
] | permissive | tunip3/xbox-live-api | 28f133108bcb704ac7e17c815512b7e95abde8f7 | b383a6e2655ad1a2e83f26130b729b5c3365ad4b | refs/heads/master | 2020-04-14T08:35:51.520297 | 2018-10-11T00:04:38 | 2018-10-11T00:04:38 | 163,739,047 | 1 | 0 | MIT | 2019-01-01T13:33:43 | 2019-01-01T13:33:43 | null | UTF-8 | C++ | false | false | 2,275 | h | // Copyright (c) Microsoft Corporation
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
#pragma once
#include "xsapi/tournaments.h"
#include "TournamentState_WinRT.h"
#include "TournamentOrderBy_WinRT.h"
#include "TournamentSortOrder_WinRT.h"
#include "TournamentState_WinRT.h"
NAMESPACE_MICROSOFT_XBOX_SERVICES_TOURNAMENTS_BEGIN
/// <summary>
/// Gets tournaments based on the configuration of this request.
/// </summary>
public ref class TournamentRequest sealed
{
public:
/// <summary>Creates a tournament_request object.</summary>
/// <param name="filterResultsForUser">Filter results to only tournaments where this user is participating.</param>
TournamentRequest(
_In_ bool filterResultsForUser
);
/// <summary>
/// The maximum number of items to return.
/// </summary>
DEFINE_PROP_GETSET_OBJ(MaxItems, max_items, uint32);
/// <summary>
/// Filter results based on the multiple states of the tournament.
/// </summary>
property Windows::Foundation::Collections::IVectorView<TournamentState>^ StateFilter
{
Windows::Foundation::Collections::IVectorView<TournamentState>^ get();
void set(_In_ Windows::Foundation::Collections::IVectorView<TournamentState>^ states);
}
/// <summary>
/// The property used to order results.
/// </summary>
DEFINE_PROP_GETSET_ENUM_OBJ(OrderBy, order_by, TournamentOrderBy, xbox::services::tournaments::tournament_order_by);
/// <summary>
///The order in which to sort the results.
/// </summary>
DEFINE_PROP_GETSET_ENUM_OBJ(SortOrder, sort_order, TournamentSortOrder, xbox::services::tournaments::tournament_sort_order);
/// <summary>
/// The organizer of the tournament.
/// </summary>
DEFINE_PROP_GETSET_STR_OBJ(OrganizerId, organizer_id);
internal:
TournamentRequest(
_In_ xbox::services::tournaments::tournament_request cppObj
);
const xbox::services::tournaments::tournament_request& GetCppObj() const;
private:
xbox::services::tournaments::tournament_request m_cppObj;
Windows::Foundation::Collections::IVectorView<TournamentState>^ m_tournamentStates;
};
NAMESPACE_MICROSOFT_XBOX_SERVICES_TOURNAMENTS_END
| [
"noreply@github.com"
] | tunip3.noreply@github.com |
586f866e6bb8b0345d12a465e14543cd391503fe | af46a6ce4f2cd93f767ee4a7f5fb3b2cf35bcf13 | /sfc_ItemRank_single/similarity.cpp | dcf72b76f8134ce762eba7083ebaee7bef0fb48a | [] | no_license | Yorwxue/Recommender-System | f29a92429d83fe8c128ea790492d744851107edd | 6e7b7df5602ffc7b99b400e593b1471039a98c04 | refs/heads/master | 2020-12-02T11:11:09.981262 | 2017-07-08T10:41:33 | 2017-07-08T10:41:33 | 96,612,623 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,554 | cpp | #include"Header.h"
float Similarity(float A[], float B[], int Length, int kind)
{
//for case 1
float variation = 0, innerProduct = 0;
//for case 2
float NormA = 0;
float NormB = 0;
float AB = 0;
float Similarity;
//
switch (kind)
{
case 1:
/*Euclidean distance*/
for (int i = 0; i < Length; i++)
{
innerProduct += pow(A[i], 2);
variation += pow(A[i] - B[i], 2);
}
Similarity = sqrt(variation) / sqrt(innerProduct);
break;
case 2:
/*Cosine similarity*/
//for (int i = 0; i < Length; i++)
//{
// cout << fixed << setprecision(5) << A[i] << ", ";
//}
//cout << endl;
//for (int i = 0; i < Length; i++)
//{
// cout << fixed << setprecision(5) << B[i] << ", ";
//}
//cout << endl;
for (int i = 0; i < Length; i++)
{
AB += A[i] * B[i];
NormA += pow(A[i], 2);
NormB += pow(B[i], 2);
}
Similarity = AB / (sqrt(NormA)*sqrt(NormB));
if (Similarity > 1)
{
Similarity = 1;
//system("pause");
}
break;
default:
Similarity = 0;
}
//cout <<"variation:"<< fixed << setprecision(5) << Similarity << ", ";
return Similarity;
}
float sfc_Similarity(float* A, float* B, int Length)
{
float NormA = 0;
float NormB = 0;
float AB = 0;
float Similarity;
for (int i = 0; i < Length; i++)
{
AB += A[i] * B[i];
NormA += pow(A[i], 2);
NormB += pow(B[i], 2);
}
Similarity = AB / (sqrt(NormA)*sqrt(NormB));
if (Similarity > 1)
{
Similarity = 1;
//system("pause");
}
return Similarity;
} | [
"noreply@github.com"
] | Yorwxue.noreply@github.com |
13386a00e3dd56500f1f21764854d5cf9b2e27fc | f411a52183dce35b12b64431d07720c01a37cd45 | /复习——指针作为函数参数.cpp | e871b0c5604a136093094ff5a01f94991744bd0e | [] | no_license | BackTo2012/C-Plus-Plus-Review | 283c824af5c134550f16f75cc9ecd4f9fed9ad2d | 9afaf758857f00b3436f36dd88ef56c08eb978c6 | refs/heads/main | 2023-06-04T11:48:13.447514 | 2021-06-30T03:56:27 | 2021-06-30T03:56:27 | 378,797,528 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 273 | cpp | //StudybarCommentBegin
#include <iostream>
using namespace std;
void swap(int *, int *);
int main( )
{
int i, j;
cin >> i >> j ;
swap(&i, &j);
cout << i << " " << j << endl;
return 0;
}
//StudybarCommentEnd
void swap(int *a, int *b)
{
int p = *a;
*a = *b;
*b = p;
} | [
"1742331636@qq.com"
] | 1742331636@qq.com |
6128e824edfbfe9979d43bc1f5bfef2babf31279 | 8d81f8a15efd9a4d0f11ac3fe64d822eb98bd37d | /1_leetcode/pascalTri2.cpp | cc10a7520b21e9ff5e217691c84530b0bfe7833f | [] | no_license | wyxmails/MyCode | b32a14d3b3a63dd9b3049d266231728419ed60d1 | 641abffc65b52b6f4a279432a8c4037a3b6a900c | refs/heads/master | 2020-12-25T17:24:03.304677 | 2016-08-28T14:05:10 | 2016-08-28T14:05:10 | 18,900,363 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 466 | cpp | /*
Given an index k, return the kth row of the Pascal's triangle.
For example, given k = 3,
Return [1,3,3,1].
Note:
Could you optimize your algorithm to use only O(k) extra space?
*/
class Solution {
public:
vector<int> getRow(int rowIndex) {
vector<int> vec(1,1);
for(int i=1;i<=rowIndex;++i){
for(int j=vec.size()-1;j>0;--j)
vec[j] += vec[j-1];
vec.push_back(1);
}
return vec;
}
};
| [
"wyxmails@gmail.com"
] | wyxmails@gmail.com |
66e311e662fbb312ca4bf5ce565d39beedef5b0e | 6fd0e447cea20bf83aaaa36a3ecd5ee08f7e19ab | /include/Imath/ImathForward.h | 8741652173b99613516945b45fe5fb2cad75328b | [
"BSD-3-Clause",
"LicenseRef-scancode-generic-cla"
] | permissive | betajippity/Nuparu | 86bf69b9b15fda96d727640582fc76b396ccde11 | 04e8812a2599585213afa782e42eeb42d00f6626 | refs/heads/main | 2023-04-03T22:33:24.095187 | 2023-03-22T19:02:19 | 2023-03-22T19:02:19 | 12,554,728 | 16 | 4 | null | null | null | null | UTF-8 | C++ | false | false | 2,291 | h | //
// SPDX-License-Identifier: BSD-3-Clause
// Copyright Contributors to the OpenEXR Project.
//
#ifndef INCLUDED_IMATHFORWARD_H
#define INCLUDED_IMATHFORWARD_H
#include "ImathNamespace.h"
#include "ImathExport.h"
IMATH_INTERNAL_NAMESPACE_HEADER_ENTER
/// @cond Doxygen_Suppress
//
// Basic template type declarations.
//
//
// Note: declarations with attributes generate warnings with
// -Wattributes or -Wall if the type is already defined, i.e. the
// header is already included. To avoid the warning, only make the
// forward declaration if the header has not yet been included.
//
#ifndef INCLUDED_IMATHBOX_H
template <class T> class IMATH_EXPORT_TEMPLATE_TYPE Box;
#endif
#ifndef INCLUDED_IMATHCOLOR_H
template <class T> class IMATH_EXPORT_TEMPLATE_TYPE Color3;
template <class T> class IMATH_EXPORT_TEMPLATE_TYPE Color4;
#endif
#ifndef INCLUDED_IMATHEULER_H
template <class T> class IMATH_EXPORT_TEMPLATE_TYPE Euler;
#endif
#ifndef INCLUDED_IMATHFRUSTUM_H
template <class T> class IMATH_EXPORT_TEMPLATE_TYPE Frustum;
#endif
#ifndef INCLUDED_IMATHFRUSTUMTEST_H
template <class T> class IMATH_EXPORT_TEMPLATE_TYPE FrustumTest;
#endif
#ifndef INCLUDED_IMATHINTERVAL_H
template <class T> class IMATH_EXPORT_TEMPLATE_TYPE Interval;
#endif
#ifndef INCLUDED_IMATHLINE_H
template <class T> class IMATH_EXPORT_TEMPLATE_TYPE Line3;
#endif
#ifndef INCLUDED_IMATHMATRIX_H
template <class T> class IMATH_EXPORT_TEMPLATE_TYPE Matrix33;
template <class T> class IMATH_EXPORT_TEMPLATE_TYPE Matrix44;
#endif
#ifndef INCLUDED_IMATHPLANE_H
template <class T> class IMATH_EXPORT_TEMPLATE_TYPE Plane3;
#endif
#ifndef INCLUDED_IMATHQUAT_H
template <class T> class IMATH_EXPORT_TEMPLATE_TYPE Quat;
#endif
#ifndef INCLUDED_IMATHSHEAR_H
template <class T> class IMATH_EXPORT_TEMPLATE_TYPE Shear6;
#endif
#ifndef INCLUDED_IMATHSPHERE_H
template <class T> class IMATH_EXPORT_TEMPLATE_TYPE Sphere3;
#endif
#ifndef INCLUDED_IMATHVEC_H
template <class T> class IMATH_EXPORT_TEMPLATE_TYPE Vec2;
template <class T> class IMATH_EXPORT_TEMPLATE_TYPE Vec3;
template <class T> class IMATH_EXPORT_TEMPLATE_TYPE Vec4;
#endif
#ifndef INCLUDED_IMATHRANDOM_H
class IMATH_EXPORT_TYPE Rand32;
class IMATH_EXPORT_TYPE Rand48;
#endif
/// @endcond
IMATH_INTERNAL_NAMESPACE_HEADER_EXIT
#endif // INCLUDED_IMATHFORWARD_H
| [
"betajippity@gmail.com"
] | betajippity@gmail.com |
5c98d677cffdc95e692e913a50c367f745f8ff6d | 2a8a290eb1d0703a7c7b21429b07870c5ffa868e | /Include/NiStreamOutSettings.inl | 27ee0cac440faaee7dcfa78e2e13a82aef352512 | [] | no_license | sigmaco/gamebryo-v32 | b935d737b773497bf9e663887e326db4eca81885 | 0709c2570e21f6bb06a9382f9e1aa524070f3751 | refs/heads/master | 2023-03-31T13:56:37.844472 | 2021-04-17T02:30:46 | 2021-04-17T02:30:46 | 198,067,949 | 4 | 4 | null | 2021-04-17T02:30:47 | 2019-07-21T14:39:54 | C++ | UTF-8 | C++ | false | false | 2,389 | inl | // EMERGENT GAME TECHNOLOGIES PROPRIETARY INFORMATION
//
// This software is supplied under the terms of a license agreement or
// nondisclosure agreement with Emergent Game Technologies and may not
// be copied or disclosed except in accordance with the terms of that
// agreement.
//
// Copyright (c) 1996-2009 Emergent Game Technologies.
// All Rights Reserved.
//
// Emergent Game Technologies, Calabasas, CA 91302
// http://www.emergent.net
//--------------------------------------------------------------------------------------------------
inline void NiStreamOutSettings::SetStreamOutAppend(bool bStreamOutAppend)
{
m_bStreamOutAppend = bStreamOutAppend;
}
//--------------------------------------------------------------------------------------------------
inline bool NiStreamOutSettings::GetStreamOutAppend() const
{
return m_bStreamOutAppend;
}
//--------------------------------------------------------------------------------------------------
inline unsigned int NiStreamOutSettings::GetStreamOutTargetCount() const
{
return m_kStreamOutTargets.GetSize();
}
//--------------------------------------------------------------------------------------------------
inline const NiFixedString& NiStreamOutSettings::GetStreamOutTarget(
int uiIndex) const
{
return m_kStreamOutTargets.GetAt(uiIndex);
}
//--------------------------------------------------------------------------------------------------
inline void NiStreamOutSettings::ClearStreamOutTargets()
{
m_kStreamOutTargets.RemoveAll();
}
//--------------------------------------------------------------------------------------------------
inline void NiStreamOutSettings::AppendStreamOutTargets(
const char* pcStreamOutTarget)
{
m_kStreamOutTargets.Add(NiFixedString(pcStreamOutTarget));
}
//--------------------------------------------------------------------------------------------------
inline void NiStreamOutSettings::SetStreamOutTargets(
const NiTObjectArray<NiFixedString>& kStreamOutTargets)
{
unsigned int uiCount = kStreamOutTargets.GetSize();
m_kStreamOutTargets.RemoveAll();
for (unsigned int i = 0; i < uiCount; i++)
m_kStreamOutTargets.Add(kStreamOutTargets.GetAt(i));
}
//--------------------------------------------------------------------------------------------------
| [
"veryzon@outlook.com.br"
] | veryzon@outlook.com.br |
d61c316f985a6cc823b45f5261b9e3e6de41a003 | 3591d9986aeb633de14da54a84ef80e2958067d7 | /2A-Solutions/Problems 30-39/Problem 31.cpp | 9006341cd7f17213e3b71e267d178bf8c82f40c9 | [] | no_license | Anshul1507/a2oj-Ladder | 3fb05befce2d5b11381a09d29b8c77b968f6bfcb | 1203aad05595093ded7818d68942bc816e7d4651 | refs/heads/master | 2022-07-28T23:00:18.390815 | 2020-05-23T15:42:52 | 2020-05-23T15:42:52 | 214,992,394 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 745 | cpp | //A - Choosing Teams (C++)
#include<bits/stdc++.h>
#define ll long long int
#define HACKS std::ios::sync_with_stdio(false);cin.tie(NULL);
#define pb push_back
#define mp make_pair
#define fi first
#define se second
using namespace std;
int main()
{
HACKS
int n,k;
cin >> n >> k;
vector <int> v;
vector< pair<int, pair<int, int> > > v1;
int a;
for(int i=0;i<n;i++){
cin >> a;
v.pb(a);
}
sort(v.begin(),v.end());
int no = n/3;
int index=0;
for(int i=0;i<no;i++){
v1.pb(mp(v[index],mp(v[index+1],v[index+2])));
index += 3;
}
int ans = 0;
for(int i=0;i<no;i++){
int check = v1[i].se.se + k;
if(check <= 5){
ans++;
}
}
cout << ans << endl;
return 0;
}
| [
"noreply@github.com"
] | Anshul1507.noreply@github.com |
f500db2fcbcd22124e7d1e204851d3b1ab16da86 | ddac68a34a739146e7d006bcaf8b5af5fe16b70f | /register.h | d790fac9645e49b1daddee87e06d94b53d4d417e | [] | no_license | SahajGandhi/Airline_management | 2a7fa014f3b4b1305dea0a00dd8b5e6e5973222c | bd03cf364c745ada4642846cc6cbf22e171146a2 | refs/heads/master | 2020-12-29T00:56:05.260149 | 2016-01-14T19:09:58 | 2016-01-14T19:09:58 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,059 | h | #ifndef STRING
#define STRING
#include<string>
#endif
#ifndef IOSTREAM
#define IOSTREAM
#include<iostream>
#endif
#ifndef USER
#define USER
#include "user.h"
#endif
#ifndef DATABASE
#define DATABASE
#include "database.h"
#endif
using namespace std;
/* A driver function is called by external modules to allow a user to register. This module calls other registration modules to initialte the registration sequence.*/
User* user_register();
/* get_registration_details() obtains regestration details of a user, in accordance to the Data Flow Diagram.*/
User* get_registration_details(){
User* user=new User();
string str_name;
cout<<"\n\tEnter a username (only underscores, not spaces allowed)\n\t>";
cin.clear();
cin>>user->username;
cout<<"\n\tEnter a password (must be six letters long and must contain a number)\n\t>";
cin.clear();
cin>>user->password;
cout<<"\n\tEnter name\n\t>";
cin.clear();
cin.ignore();
getline(cin, str_name);
//we must now convert the string to a character array.
int i;
for(i=0; i<str_name.length() && i<50; i++)
user->name[i]=str_name.at(i);
cout<<"\n\tEnter age\n\t>";
cin.clear();
cin>>user->age;
cout<<"\n\tEnter email (must be of the form ___@___.___)\n\t>";
cin.clear();
cin>>user->email;
cout<<"\n\tEnter phone number\n\t>";
cin.clear();
cin>>user->phone;
while(user->gender!='M' && user->gender!='F'){
cout<<"\n\tEnter gender (M or F)\n\t>";
cin.clear();
cin>>user->gender;
if(user->gender!='M' && user->gender!='F')
cout<<"\n\tERROR: Invalid gender entry";
}
return user;
}
/* validate_registration_details(User* user) validates regestration details of a user obtained in get_registration_details(), in accordance to the Data Flow Diagram.
This module also prints the corresponding error messages.*/
bool validate_registration_details(User* user){
bool valid=true; /*this is the value returned, signalling the calling module as to whether the argument passed is valid or not.*/
//check if username already exists:
if(database.user_map.find(string(user->username)) != database.user_map.end()){
cout<<"\n\tRegistration ERROR: this username is unavailable.";
valid=false;
}
//check if the password has at least 6 characters.
bool checked;
string pass=string(user->password);
if(pass.length()<6){
cout<<"\n\tRegistration ERROR: the selected password must be at least 6 character long.";
valid=false;
}
//check if the password has a number in it.
checked=false;
for(int i=0; user->password[i]!='\0' && checked==false; i++)
if(user->password[i] >= '0' && user->password[i] <= '9'){
checked=true; //meaning there is a number in the password
break;
}
if(!checked){
cout<<"\n\tRegistration ERROR: the selected password must contain at least one number.";
valid=false;
}
//check if the user is above 18 years of age.
if(user->age < 18){
cout<<"\n\tRegistration ERROR: you must be at least 18 years of age to register.";
valid=false;
}
//check if the email contains an '@' symbol
checked=false;
for(int j=0; user->email[j]!='\0'; j++){
if(user->email[j]=='@'){
checked=true;
}
}
if(!checked){
cout<<"\n\tRegistration ERROR: an email address must contain an @ address.";
valid=false;
}
//check if the email contains a '.' symbol
checked=false;
for(int j=0; user->email[j]!='\0'; j++){
if(user->email[j]=='.'){
checked=true;
}
}
if(!checked){
cout<<"\n\tRegistration ERROR: an email address must contain an @ address.";
valid=false;
}
return valid; //return the validity status of the input arguments
}
/* save_user_details(User* user) is a module which saves the user details into the database if they have been deemed valid. */
void save_user_details(User* user){
database.user_map[string(user->username)]=(*user); //save the user in the hash table.
database.write_to_file_user(); /*Write changed user table to file. We use the database object's function to save, thus improving cohesion.*/
}
/* A driver function is called by external modules to allow a user to register. This module calls other registration modules to initialte the registration sequence.*/
User* user_register(){
User* user=new User();
int select=-1;
while(select<1 || select >3){
cout<<"\n\n\tWhich type of user are you?\n\t1.Customer\n\t2.Airline manager\n\t3.Airport Controller\n\t>";
cin.clear();
cin.ignore();
cin>>select;
if(select<1 || select >3){
cout<<"\n\tInvalid type of user. Please try again.\n";
select=-1;
}
}
user= get_registration_details();
switch(select){
case 1: user->type=CUSTOMER;
break;
case 2: user->type=AIRL_MGR;
break;
case 3: user->type=AIRP_CON;
break;
default: cout<<"\n\tERROR: invalid user type.\n";
return NULL;
}
if(validate_registration_details(user)){
save_user_details(user);
cout<<"\n\tSuccessfully saved details for user "<<string(user->name)<<endl;
}
else {
cout<<"\n\tERROR: unable to register; invalid details entered.\n";
return NULL;
}
return user;
}
| [
"abhishek.r.divekar@gmail.com"
] | abhishek.r.divekar@gmail.com |
56944e8d8f67fa0d8657ad27e1e068d11091af17 | 951618d338164be89acfb3a62f416d814de13965 | /Eshaan/Day-69.cpp | db0f7e0d513ab970e10aad7d1e3d89ac8677d4c1 | [] | no_license | eshaananand/100-Days-of-Code | ada8f45eeac283d2fb3915946f8f71b2c168611c | 7603eebf1a4b027b61d67a060dd79416b26a13a4 | refs/heads/main | 2023-08-20T06:16:37.154598 | 2021-09-21T13:17:50 | 2021-09-21T13:17:50 | 378,913,801 | 0 | 0 | null | 2021-06-21T11:53:23 | 2021-06-21T11:53:22 | null | UTF-8 | C++ | false | false | 579 | cpp | //https://www.hackerrank.com/challenges/taum-and-bday/problem
//HackerRank Day-69
#include <string>
#include <vector>
#include <cstdlib>
#include <iostream>
int main()
{
int t; std::cin >> t;
while (t-- > 0) {
unsigned long long b,w,x,y,z;
std::cin >> b >> w
>> x >> y >> z;
if (x+z < y) {
std::cout << x*b + (x+z)*w << std::endl;
} else if (y+z < x) {
std::cout << (y+z)*b + y*w << std::endl;
} else {
std::cout << x*b + y*w << std::endl;
}
}
return 0;
} | [
"eshaananand2911@gmail.com"
] | eshaananand2911@gmail.com |
485192d8f3b25931d17dd4126ed79d471afaec68 | 0966cd07ddd90d953805a4861ff109cccfab5b69 | /Summer_Training_2014/A/A_add.cpp | 2fb50cf0d6c6fc52946096cde5eae107d0e2b7e3 | [
"MIT"
] | permissive | zubie7a/Algorithms | e2a4f8a804883191e0fa46327696b34c07700ee8 | ffe317f9a984319fbb3c1811e2a438306fc4eee9 | refs/heads/master | 2022-12-09T04:50:31.953797 | 2022-12-08T08:34:52 | 2022-12-08T08:34:52 | 2,922,675 | 10 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,968 | cpp | /*Santiago Zubieta*/
#include <iostream>
#include <numeric>
#include <fstream>
#include <climits>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <queue>
#include <list>
#include <map>
#include <set>
#include <stack>
#include <deque>
#include <vector>
#include <string>
#include <cstdlib>
#include <cassert>
#include <sstream>
#include <iterator>
#include <algorithm>
#define llu unsigned long long int
using namespace std;
struct Num {
int n;
bool operator < (const Num &that) const {
// Overload < operator because this structure will be used in a priority
// queue, and in such a structure, it will always maintain the 'biggest'
// element on top of it, and we want the 'smallest' element instead.
return n > that.n;
}
};
int main() {
int T;
// Number of test cases
int N;
// Placeholder for read numbers
llu sum;
// The sum of the 2 lowest numbers available
llu total;
// The total of the costs of each pair of numbers added
int index;
while(cin >> T) {
priority_queue < Num > nums;
if(!T) {
break;
}
sum = 0;
total = 0;
index = 0;
for(int k = 0; k < T; k++) {
cin >> N;
Num num;
num.n = N;
nums.push(num);
}
while(nums.size() > 1) {
int n1 = nums.top().n;
// Take the lowest element out of the priority queue
nums.pop();
int n2 = nums.top().n;
// Take the second lowest element out of it too
nums.pop();
sum = n1 + n2;
// Add the two lowest values that were in the queue
total += sum;
// Add this to the total as a cost of adding up
Num num;
num.n = sum;
nums.push(num);
// Put back the result back into the priority queue
}
cout << total << endl;
}
} | [
"santiago.zubieta@gmail.com"
] | santiago.zubieta@gmail.com |
9c91caf63a15be4de58c0e7515a164d82b62e969 | 28ee21a8f1ef96dc929bd49562583a5a145ef158 | /Main.cpp | cc4f032443b3657889e6f8392585ab23edb5769d | [] | no_license | SeniorMalkin/MPI_Lab3 | 24deb6f84805631f1c67d828ca88c4d21c8d2d07 | 5851ce777492abd1287b97b8a71f193ceb9f7e59 | refs/heads/master | 2020-04-11T05:31:18.900569 | 2018-12-12T22:27:32 | 2018-12-12T22:27:32 | 161,552,040 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,202 | cpp |
#define _USE_MATH_DEFINES
#define STB_IMAGE_IMPLEMENTATION
#define SIGMA 2
//#include "stb_image.h"
#include <stdint.h>
#include <stdio.h>
#include <mpi.h>
#include <math.h>
#include <stdlib.h>
typedef unsigned char uint8_t;
void generateKernel(double* kernel, int sigma) {
for (int i = -1; i <= 1; i++) {
for (int j = -1; j <= 1; j++) {
kernel[i + j + 2 * (i + 2)] = (double)(exp(-(i*i + j*j) / (sigma*sigma))) / (sigma*sqrt(2 * M_PI));
}
}
}
void countElemProc(int* elem_proc, int* displs , int height ,int width, int psize) {
int port = height / psize;
port = (port < 1) ? 1 : port;
int rem = height % psize;
int elem = port*width;
int sent_rows_num = 0;
for (int i = 0; i < psize; ++i) {
elem_proc[i] = elem;
if (rem > 0) {
elem_proc[i] += width;
rem--;
}
displs[i] = sent_rows_num;
sent_rows_num += elem_proc[i];
}
}
uint8_t* imageProcess(uint8_t* recvbuf, double* kernel, int width, int elem_proc) {
uint8_t* res = new uint8_t[elem_proc];
for (int i = width; i < elem_proc - width; i++) {
if (((i % width) != (width - 1)) && ((i % width) != 0)) {
int k = 0;
for (int j = -width; j <= width; j += width) {
res[i] += static_cast<uint8_t>(recvbuf[(i - 1) + j] * kernel[k] + recvbuf[i + j] * kernel[k + 1] + recvbuf[(i + 1) + j] * kernel[k + 2]);
k += 3;
}
}
else {
res[i] = recvbuf[i];
}
}
return res;
}
int checkEquality(uint8_t* seq_image, uint8_t* par_image, int height, int width) {
for (int i = 0; i < height * width; ++i) {
if (seq_image[i] != par_image[i]) {
printf("%d\n", i);
return 0;
}
}
return 1;
}
void main(int argc, char* argv[]) {
int ProcRank;
int psize = 0;
int width = 0, height = 0;
int port = 0;
int offset = 0;
double rem = 0;
double* kernel = new double[9];
double start_par_time = 0, end_par_time = 0;
double start_seq_time = 0, end_seq_time = 0;
uint8_t* par_image = nullptr;
uint8_t* seq_image = nullptr;
if (argc < 3) {
printf("Image size not set\n");
return;
}
else {
if (atoi(argv[1]) < 100 && atoi(argv[2]) < 100)
{
printf("Invalid arguments\n");
return;
}
}
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &psize);
MPI_Comm_rank(MPI_COMM_WORLD, &ProcRank);
double* buf = new double[11];
if (ProcRank == 0) {
//rgb_image = stbi_load("file.png", &width, &height, &bpp, STBI_grey);
width = atoi(argv[1]);
height = atoi(argv[2]);
generateKernel(kernel, SIGMA);
par_image = new uint8_t[width*height];
for (int i = 0; i < width*height; i++) {
par_image[i] = rand() % 255;
}
buf[0] = width;
buf[1] = height;
for (int i = 2; i < 11; i++) {
buf[i] = kernel[i - 2];
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Sequential algorithm
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
start_seq_time = MPI_Wtime();
if (ProcRank == 0)
seq_image = imageProcess(par_image, kernel, width, height*width);
end_seq_time = MPI_Wtime();
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Prepare additional date
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
start_par_time = MPI_Wtime();
MPI_Bcast(buf, 11, MPI_DOUBLE, 0, MPI_COMM_WORLD);
if (ProcRank != 0) {
width = buf[0];
height = buf[1];
for (int i = 2; i < 11; i++) {
kernel[i - 2] = buf[i];
}
offset = width;
}
port = height / psize;
port = (port < 1) ? 1 : port;
rem = height - port * psize; //remainder
int* elem_proc = new int[psize]; // count elements for one proc
int* displs = new int[psize]; // displ for each portion
int* sizerec = new int[psize]; // size recv buf
countElemProc(elem_proc, displs, height, width, psize);
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Image division
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
uint8_t* recvbuf = nullptr;
if ((ProcRank == 0) || (ProcRank == psize - 1)) {
sizerec[ProcRank] = elem_proc[ProcRank] + width;
recvbuf = new uint8_t[sizerec[ProcRank]];
}
else {
sizerec[ProcRank] = elem_proc[ProcRank] + 2*width;
recvbuf = new uint8_t[sizerec[ProcRank]];
}
for (int i = 0; i < elem_proc[ProcRank]; i++)
{
recvbuf[i] = 0;
}
MPI_Scatterv(par_image, elem_proc, displs, MPI_UINT8_T, recvbuf + offset, elem_proc[ProcRank], MPI_UINT8_T, 0, MPI_COMM_WORLD);
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Block edges transfer
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
MPI_Status status;
/*if (ProcRank != 0) {
MPI_Sendrecv(recvbuf + offset, width, MPI_UNSIGNED_CHAR,
ProcRank - 1, 0, recvbuf, width, MPI_UNSIGNED_CHAR,
ProcRank - 1, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
}
if (ProcRank != psize - 1) {
MPI_Sendrecv(recvbuf + offset + elem_proc[ProcRank] - width, width,
MPI_UNSIGNED_CHAR, ProcRank + 1, 0,
recvbuf + offset + elem_proc[ProcRank], width, MPI_UNSIGNED_CHAR,
ProcRank + 1, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
}
*/
if (ProcRank != psize - 1) {
MPI_Recv(recvbuf + elem_proc[ProcRank] + offset, width, MPI_UINT8_T, ProcRank + 1, 0, MPI_COMM_WORLD, &status);
}
if (ProcRank != 0) {
MPI_Send(recvbuf + offset, width, MPI_UINT8_T, ProcRank - 1, 0, MPI_COMM_WORLD);
}
if (ProcRank != 0) {
MPI_Recv(recvbuf, width, MPI_UINT8_T, ProcRank - 1, 0, MPI_COMM_WORLD, &status);
}
if (ProcRank != psize - 1) {
MPI_Send(recvbuf + elem_proc[ProcRank] - width + offset, width, MPI_UINT8_T, ProcRank + 1, 0, MPI_COMM_WORLD);
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Image processing and build new image
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
recvbuf = imageProcess(recvbuf, kernel, width, sizerec[ProcRank]);
MPI_Gatherv((void*)(recvbuf + offset), elem_proc[ProcRank], MPI_UINT8_T, par_image, elem_proc, displs, MPI_UINT8_T, 0, MPI_COMM_WORLD);
end_par_time = MPI_Wtime();
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Correctness
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int res = 0;
if (ProcRank == 0) {
res = checkEquality(seq_image, par_image, height, width);
}
if (ProcRank == 0) {
delete[] par_image;
delete[] seq_image;
printf("time_par = %f\n", end_par_time - start_par_time);
printf("time_seq = %f\n", end_seq_time - start_seq_time);
if (res)
printf("The algorithm is correct.\n");
}
delete[] kernel;
delete[] buf;
MPI_Finalize();
} | [
"senior.malkin2014@yandex.ru"
] | senior.malkin2014@yandex.ru |
9b2eea4363a9fb87faf47e9e45d656946bce3f3c | 72e08c020541364f00f2f2e1858a41b1d3e25c56 | /11101.cpp | b73eb68552cbea341efa011c14252d373f8c1550 | [] | no_license | shreyan-jaiswal/UVa-solutions | 51e8ab017723ae37c18823e4766b804ac7e2ca35 | 2263a4059045b3a93f7e598c5f18f25a973164ea | refs/heads/master | 2020-06-18T09:16:21.496199 | 2019-07-10T17:31:01 | 2019-07-10T17:31:01 | 196,248,673 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,189 | cpp | #include <bits/stdc++.h>
using namespace std;
#define watch(x) #x << "=" << x << ", "
typedef pair<int, int> ii;
typedef pair<int, ii> iii;
int p1, p2, dest[2001][2001], vis[2001][2001],x,y;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int main(){
while(cin >> p1, p1){
queue<iii> q; memset(vis, 0, sizeof vis);
for(int i = 0; i < p1; i++){
cin >> x >> y;
q.push(iii(0,ii(x,y)));
vis[x][y] = 1;
}
cin >> p2;
memset(dest, 0, sizeof dest);
for(int i = 0;i < p2; i++){
cin >> x >> y;
dest[x][y] = 1;
}
while(!q.empty()){
iii fr = q.front(); q.pop();
int d = fr.first, x = fr.second.first, y = fr.second.second;
if(dest[x][y]){
cout << d << '\n';
break;
}
for(int dir = 0; dir < 4; dir++){
int nx = x+dx[dir], ny = y+dy[dir];
if(0 <= nx && nx <= 2000 && 0 <= ny && ny <= 2000 && !vis[nx][ny]){
vis[nx][ny] = 1;
q.push(iii(d+1, ii(nx, ny)));
}
}
}
}
} | [
"sjaiswa2@andrew.cmu.edu"
] | sjaiswa2@andrew.cmu.edu |
f0257a1606c0cccef3294e83c980f826559e3a48 | 5838cf8f133a62df151ed12a5f928a43c11772ed | /NT/sdktools/custcon/aboutdlg.cpp | fcd18a76240f1eaacd34d319649c6090cc492eaa | [] | no_license | proaholic/Win2K3 | e5e17b2262f8a2e9590d3fd7a201da19771eb132 | 572f0250d5825e7b80920b6610c22c5b9baaa3aa | refs/heads/master | 2023-07-09T06:15:54.474432 | 2021-08-11T09:09:14 | 2021-08-11T09:09:14 | null | 0 | 0 | null | null | null | null | SHIFT_JIS | C++ | false | false | 1,956 | cpp | //////////////////////////////////////////////////////////////////////
//
// AboutDlg.cpp
//
// 1998 Jun, Hiro Yamamoto
//
#include "stdafx.h"
#include "custcon.h"
#include "AboutDlg.h"
#include <malloc.h>
/////////////////////////////////////////////////////////////////////////////
// アプリケーションのバージョン情報で使われている CAboutDlg ダイアログ
CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
{
//{{AFX_DATA_INIT(CAboutDlg)
//}}AFX_DATA_INIT
}
void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CAboutDlg)
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
//{{AFX_MSG_MAP(CAboutDlg)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
struct FullVersion {
public:
DWORD m_ms;
DWORD m_ls;
public:
FullVersion(DWORD ms, DWORD ls) : m_ms(ms), m_ls(ls) { }
};
FullVersion GetVersionInfo()
{
TCHAR path[MAX_PATH+1];
path[::GetModuleFileName(AfxGetInstanceHandle(), path, (sizeof path / sizeof path[0])-1 )] = 0;
DWORD dummy;
DWORD size = GetFileVersionInfoSize(path, &dummy);
ASSERT(size != 0); // 0 means error
LPVOID lpData = malloc(size);
LPVOID lpBuffer = NULL;
UINT vSize;
if (!lpData) {
return FullVersion(0,0);
}
VERIFY( GetFileVersionInfo(path, 0, size, lpData) );
VERIFY( VerQueryValue(lpData, _T("\\"), &lpBuffer, &vSize) );
if (lpBuffer) {
VS_FIXEDFILEINFO* info = (VS_FIXEDFILEINFO*)lpBuffer;
return FullVersion(info->dwProductVersionMS, info->dwProductVersionLS);
} else {
return FullVersion(0, 0);
}
}
BOOL CAboutDlg::OnInitDialog()
{
CDialog::OnInitDialog();
FullVersion version = GetVersionInfo();
CString format;
format.LoadString(IDS_VERSION_TEMPLATE);
CString buf;
buf.Format(format, HIWORD(version.m_ms), LOWORD(version.m_ms), HIWORD(version.m_ls), LOWORD(version.m_ls));
SetDlgItemText(IDC_MAIN_TITLE, buf);
return TRUE;
}
| [
"blindtiger@foxmail.com"
] | blindtiger@foxmail.com |
6cdd61a9b6b077baeee61f4a8dc2510c13ccea75 | 1013ae3eec15ece0c05d0307d79a511021205173 | /Microsoft.WindowsAzure.Storage/src/stdafx.cpp | bd6f3c2b72114ab49bad891e1ba04d56f026673b | [
"Apache-2.0"
] | permissive | Azure/azure-storage-cpp | 25548ce8ef000ed6d07ee4cbbf8661f9c817c30b | a94f027b498471865d515b9fb719d0c4c40696f7 | refs/heads/master | 2023-05-17T01:46:01.161703 | 2023-03-28T16:48:43 | 2023-03-28T16:48:43 | 13,808,985 | 145 | 164 | Apache-2.0 | 2023-03-28T16:48:45 | 2013-10-23T17:01:47 | C++ | UTF-8 | C++ | false | false | 1,188 | cpp | // -----------------------------------------------------------------------------------------
// <copyright file="stdafx.cpp" company="Microsoft">
// Copyright 2013 Microsoft Corporation
//
// 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.
// </copyright>
// -----------------------------------------------------------------------------------------
// stdafx.cpp : source file that includes just the standard includes
// Microsoft.WindowsAzure.Storage.pch will be the pre-compiled header
// stdafx.obj will contain the pre-compiled type information
#include "stdafx.h"
// TODO: reference any additional headers you need in STDAFX.H
// and not in this file
| [
"sozler@microsoft.com"
] | sozler@microsoft.com |
dce51f5bf9a303e2bf182d106f03709259f306ea | 39a063a9a81eb5d8776ca04d7824a6d2fa1ff144 | /src/libtidelog/Chunk.h | c62a5991e2a146b7656adeb399e8b6229063f805 | [] | no_license | mgoettin/libtidelog | 0f667b986f44c2868622383ea45dccb177fce9fe | 8f96059eea17a666d309aec0bd30ebf158182c11 | refs/heads/master | 2021-01-18T03:00:08.981850 | 2011-08-15T10:07:46 | 2011-08-15T10:07:46 | 2,205,037 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 906 | h | *
* File: chunk.hpp
* Author: ingo
*
* Created on 22. April 2011, 23:46
*/
#pragma once
#include "tidestruct.hpp"
#include <iosfwd>
namespace tide {
namespace log {
class ChunkEntry {
private:
const uint64_t timestamp;
const uint64_t length;
public:
ChunkEntry(const uint64_t timestamp, const Array& data);
uint64_t get_timestamp() const;
uint64_t get_length() const;
};
class Chunk {
private:
const int id;
const off_t start_filepos;
uint64_t start_timestamp, end_timestamp;
uint64_t chunk_length;
unsigned int num_entries;
public:
Chunk(const int id, const off_t start);
void update(const ChunkEntry& entry);
off_t get_start() const;
uint64_t get_size() const;
CHUNK get_header() const;
};
std::ostream& operator<<(std::ostream& out, const Chunk& c);
} //namespace log
} //namespace tide
| [
"michael.goetting@gmx.de"
] | michael.goetting@gmx.de |
d96c507cc2a01eb2b6104ff0ac76ed35775e7e5d | 136be4680aa6d8042ea5b168856993422ca2740f | /d06/ex01/Serialize.hpp | c4f43c068e705df946f6709c002848bb0b3cfc4a | [] | no_license | ivoriik/cpp_piscine | e1e76f17e1abf47f4f8ab24bae409ce9be069f7b | eb47a1c7fb2bd22a0d817b1b78e05b363d9db88e | refs/heads/master | 2022-01-21T03:45:29.884005 | 2019-07-07T09:42:05 | 2019-07-07T09:42:05 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 187 | hpp | #ifndef SERIALIZE_HPP
#define SERIALIZE_HPP
#include <string>
struct Data
{
std::string s1;
int nb;
std::string s2;
};
void *serialize(void);
Data *deserialize(void *raw);
#endif | [
"nama_om@ymail.com"
] | nama_om@ymail.com |
e1208d9f465dbb397323ea17cd6630ef9fc30aa7 | 872a2ace51c1f0e6576f8429d2b0f0324f324ef3 | /Qt/ZeroClassGenerator/fencodegenere.h | 40011aec334f5f05ae507aa57f73f14ddb43c786 | [] | no_license | asgards1990/learningCPP | 365d403057f26cf5fee481761e78326d150ba03e | e50c97d23c2cafbd4557625b05fbf080f2bdb310 | refs/heads/master | 2021-01-10T21:17:57.191262 | 2015-01-14T04:40:46 | 2015-01-14T04:40:46 | 19,703,476 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 535 | h | #ifndef FENCODEGENERE_H
#define FENCODEGENERE_H
#include <QWidget>
#include <QDialog>
#include <QVBoxLayout>
#include <QApplication>
#include <QLineEdit>
#include <QString>
#include <QTextEdit>
#include <QPushButton>
#include <QTabWidget>
class FenCodeGenere : public QDialog
{
Q_OBJECT
public:
FenCodeGenere(QString *codeGenere, QString *bodyCode, QString *nameClass, QWidget *parent=0);
signals:
public slots:
private:
QTextEdit *header;
QTextEdit *body;
QPushButton *fermer;
};
#endif // FENCODEGENERE_H
| [
"ys19901010@hotmail.fr"
] | ys19901010@hotmail.fr |
ca1858cf1168f4c95fd52471034d64497c50a4b9 | 95cc023556e96743b1b47f4459181a81bf592be7 | /drivers/bluetooth/lib/hci/link_key.h | 778c31ffbb1a76caea6e99b41b6f8f3430d45e02 | [
"BSD-3-Clause"
] | permissive | return/garnet | 5034ae8b8083455aa66da10040098c908f3de532 | f14e7e50a1b6b55eaa8013755201a25fc83bd389 | refs/heads/master | 2020-03-23T16:13:28.763852 | 2018-07-21T07:24:31 | 2018-07-21T07:24:31 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 962 | h | // Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#pragma once
#include <cstdint>
#include "garnet/drivers/bluetooth/lib/common/uint128.h"
namespace btlib {
namespace hci {
// Represents a key used to encrypt a link.
class LinkKey final {
public:
LinkKey();
LinkKey(const common::UInt128& value, uint64_t rand, uint16_t ediv);
// 128-bit BR/EDR link key, LE Long Term Key, or LE Short Term key.
const common::UInt128& value() const { return value_; }
// Encrypted diversifier and random values used to identify the LTK. These
// values are set to 0 for the LE Legacy STK, LE Secure Connections LTK, and
// BR/EDR Link Key.
uint64_t rand() const { return rand_; }
uint16_t ediv() const { return ediv_; }
private:
common::UInt128 value_;
uint64_t rand_;
uint16_t ediv_;
};
} // namespace hci
} // namespace btlib
| [
"commit-bot@chromium.org"
] | commit-bot@chromium.org |
8482bd62e601f6b6e2441331b221d728f1908d8f | cd8f24a7d33b36edf876d17da91b0175908e94fa | /GCPC11F.cpp | f30a4677a3837501dba9e7b920eb6c724d26e30d | [
"LicenseRef-scancode-warranty-disclaimer"
] | no_license | vishnujayvel/SPOJ-1 | f6f34c3cdb31d3a87c04dbedd94e1936bc63d88e | a8764d2eb9cf004dc4d405f549c07275ce1d74a0 | refs/heads/master | 2021-01-15T15:56:57.947037 | 2013-03-28T09:48:42 | 2013-03-28T09:48:42 | 11,000,711 | 0 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 730 | cpp | /*
USER: zobayer
TASK: GCPC11F
ALGO: ad-hoc
*/
#include <cstdio>
#include <cstring>
#include <cstdlib>
char str[1024];
int cnt[26];
int main() {
int test, i, mx, mc, d;
test = atoi(fgets(str, 1023, stdin));
while(test--) {
fgets(str, 1023, stdin);
memset(cnt, 0, sizeof cnt);
for(i = 0; str[i]>31; i++) if(str[i]>32) cnt[str[i]-'A']++;
for(mx = 0, mc = 1, i = 1; i < 26; i++) {
if(cnt[i] > cnt[mx]) mx = i, mc = 1;
else if(cnt[i] == cnt[mx]) mc++;
}
if(mc > 1) fputs("NOT POSSIBLE\n", stdout);
else {
if(mx >= 4) d = mx - 4;
else d = 26 - 4 + mx;
printf("%d ", d);
for(i = 0; str[i]>31; i++) if(str[i]>32) str[i] = 'A' + (str[i]-'A' - d + 26) % 26;
fputs(str, stdout);
}
}
return 0;
}
| [
"zobayer1@gmail.com"
] | zobayer1@gmail.com |
d5aa2fc497f4c6c18fa62eeff498a866bd410a8a | 48f0d1741b34757574feec3b576cc0b340c56da4 | /2 доп (вариант 2).cpp | 29069668e0ca9398d0ce8acccf6afab2636d3675 | [] | no_license | Fedorchuk-Valeria/3lab | 32f151d042676c69055698357e7024637e0e3043 | 874732dc07c7259f22812c8481d37450aadf75c0 | refs/heads/main | 2023-01-13T17:50:27.662669 | 2020-11-21T09:58:55 | 2020-11-21T09:58:55 | 314,769,950 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 338 | cpp | #include <iostream>
#include <string>
using namespace std;
int main()
{
long k, i;
cout << "Enter k:";
cin >> k;
string S;
for (i = 1; i < k; i++)
{
S += to_string(i);
}
cout << "Chlen posledovatelnosti nomer " << k << " : " << S[k-1] << endl;
return 0;
}
| [
"noreply@github.com"
] | Fedorchuk-Valeria.noreply@github.com |
b10805c3397fac1ac3b375ef14a3d47a41f71f89 | 6035fb168576b8fdbef1a3dbc871e1a06e191278 | /final_test/12/u1676_420_D_6446668.cpp | 75db691ae0e50ac770f26bd9809b1c70c23c5526 | [] | no_license | pavellevap/code_antiplagiat | 69ef3ecea5e8e88dfd3b800c0ce351fa32ee9762 | d75603e4e25519d9bb9b9720923136e324328be4 | refs/heads/master | 2021-01-10T05:30:44.560926 | 2015-04-30T14:25:34 | 2015-04-30T14:25:34 | 45,319,257 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,706 | cpp | #include <cstdio>
#include <iostream>
#include <cstring>
#include <string>
#include <algorithm>
#include <map>
#include <vector>
#include <queue>
#include <cmath>
#include <set>
#include <sstream>
#define MP make_pair
#define PB push_back
using namespace std;
typedef long long LL;
typedef vector <int> VI;
typedef vector <LL> VL;
typedef vector <string> VS;
const int MAXN = 1 << 21;
int tree[MAXN + 10];
int val[MAXN + 10];
int N, Q;
bool used[MAXN];
void update (int k, int v)
{
while (k < MAXN)
{
tree[k] += v;
k += k & -k;
}
}
int find_Kth (int k)
{
int idx = 0;
for (int i = 21; i >= 0; -- i)
{
idx |= 1 << i;
if (idx >= MAXN || tree[idx] >= k) idx ^= 1 << i;
else k -= tree[idx];
}
return idx + 1;
}
int main()
{
cin >> N >> Q;
for (int i = 0; i < N; ++ i)
{
update ((1 << 20) + i, 1);
val[(1 << 20) + i] = -1;
}
int e, p;
bool error = false;
int idx = (1 << 20);
while (Q --)
{
cin >> e >> p;
if (error) continue;
int k = find_Kth (p);
if (val[k] == -1 && !used[e]) val[k] = e, used[e] = true;
if (val[k] != e) error = true;
else
{
val[-- idx] = e;
update (idx, 1);
update (k, -1);
}
}
if (error)
{
puts ("-1");
return 0;
}
idx = 0;
for (int i = 0; i < N; ++ i)
{
int k = (1 << 20) + i;
if (val[k] == -1)
{
while (used[++ idx]);
val[k] = idx;
}
cout << val[k] << " ";
}
// while (1);
return 0;
}
| [
"prorochek@gmail.com"
] | prorochek@gmail.com |
e5fa7028cd199dd9ad913b9ede8d1efedb807828 | 6442babb4e05d6a5d58e14d29ae25a7913180bbe | /CS3A - Object Oriented Programming/Final Hunter and Prey/build-HunterPrey-Desktop_Qt_5_1_1_MinGW_32bit-Debug/debug/moc_mygui.cpp | 8a3e602c86dca89f1738f1a40c85ccd3545fbc5c | [] | no_license | SpencerYoungCS/CS-Projects | 34859b29c663c5fa255917415711e17b12b612fd | 8eaef5cc666a91be473d7c601c21bfbdb8f8fcf2 | refs/heads/master | 2020-03-07T21:55:55.227506 | 2019-10-30T00:45:36 | 2019-10-30T00:45:36 | 127,740,601 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,266 | cpp | /****************************************************************************
** Meta object code from reading C++ file 'mygui.h'
**
** Created by: The Qt Meta Object Compiler version 67 (Qt 5.1.1)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/
#include "../../HunterPrey/mygui.h"
#include <QtCore/qbytearray.h>
#include <QtCore/qmetatype.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'mygui.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 67
#error "This file was generated using the moc from 5.1.1. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif
QT_BEGIN_MOC_NAMESPACE
struct qt_meta_stringdata_MyGui_t {
QByteArrayData data[8];
char stringdata[47];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
offsetof(qt_meta_stringdata_MyGui_t, stringdata) + ofs \
- idx * sizeof(QByteArrayData) \
)
static const qt_meta_stringdata_MyGui_t qt_meta_stringdata_MyGui = {
{
QT_MOC_LITERAL(0, 0, 5),
QT_MOC_LITERAL(1, 6, 12),
QT_MOC_LITERAL(2, 19, 0),
QT_MOC_LITERAL(3, 20, 3),
QT_MOC_LITERAL(4, 24, 4),
QT_MOC_LITERAL(5, 29, 4),
QT_MOC_LITERAL(6, 34, 4),
QT_MOC_LITERAL(7, 39, 6)
},
"MyGui\0actionSignal\0\0Run\0Stop\0Load\0"
"Save\0Action\0"
};
#undef QT_MOC_LITERAL
static const uint qt_meta_data_MyGui[] = {
// content:
7, // revision
0, // classname
0, 0, // classinfo
6, 14, // methods
0, 0, // properties
0, 0, // enums/sets
0, 0, // constructors
0, // flags
1, // signalCount
// signals: name, argc, parameters, tag, flags
1, 0, 44, 2, 0x05,
// slots: name, argc, parameters, tag, flags
3, 0, 45, 2, 0x0a,
4, 0, 46, 2, 0x0a,
5, 0, 47, 2, 0x0a,
6, 0, 48, 2, 0x0a,
7, 0, 49, 2, 0x0a,
// signals: parameters
QMetaType::Void,
// slots: parameters
QMetaType::Void,
QMetaType::Void,
QMetaType::Void,
QMetaType::Void,
QMetaType::Void,
0 // eod
};
void MyGui::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
MyGui *_t = static_cast<MyGui *>(_o);
switch (_id) {
case 0: _t->actionSignal(); break;
case 1: _t->Run(); break;
case 2: _t->Stop(); break;
case 3: _t->Load(); break;
case 4: _t->Save(); break;
case 5: _t->Action(); break;
default: ;
}
} else if (_c == QMetaObject::IndexOfMethod) {
int *result = reinterpret_cast<int *>(_a[0]);
void **func = reinterpret_cast<void **>(_a[1]);
{
typedef void (MyGui::*_t)();
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&MyGui::actionSignal)) {
*result = 0;
}
}
}
Q_UNUSED(_a);
}
const QMetaObject MyGui::staticMetaObject = {
{ &QWidget::staticMetaObject, qt_meta_stringdata_MyGui.data,
qt_meta_data_MyGui, qt_static_metacall, 0, 0}
};
const QMetaObject *MyGui::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *MyGui::qt_metacast(const char *_clname)
{
if (!_clname) return 0;
if (!strcmp(_clname, qt_meta_stringdata_MyGui.stringdata))
return static_cast<void*>(const_cast< MyGui*>(this));
return QWidget::qt_metacast(_clname);
}
int MyGui::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QWidget::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 6)
qt_static_metacall(this, _c, _id, _a);
_id -= 6;
} else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 6)
*reinterpret_cast<int*>(_a[0]) = -1;
_id -= 6;
}
return _id;
}
// SIGNAL 0
void MyGui::actionSignal()
{
QMetaObject::activate(this, &staticMetaObject, 0, 0);
}
QT_END_MOC_NAMESPACE
| [
"spenceryoungcs@gmail.com"
] | spenceryoungcs@gmail.com |
d11c62847a9ed735c356d3b5a2c5d75d6b168e35 | a3d9d781b71e67d701382840a58c1557bd62c0d2 | /overlayer/createSingleColorBg.cpp | 2c5466c8925d0c92cf7abe49538d877ff2e8f2a2 | [] | no_license | zouwen198317/meidacore | 8064a33e472d597cf6e52693b2240f3689d7d281 | c8c015d9a8e76655fc02062b4d18f1610cfea31d | refs/heads/master | 2020-05-29T11:46:23.737977 | 2016-06-06T01:44:29 | 2016-06-06T01:44:29 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 879 | cpp | #include<iostream>
#include<fstream>
#include<iterator>
#include<string>
#include<algorithm>
#include"createSingleColorBg.h"
using namespace std;
void createBg_i420(unsigned int width,unsigned int height,RGB color,unsigned char* buf)
{
YUV yuv = rgb2yuv(color);
unsigned int y_pos=0;
unsigned int u_pos=width*height;
unsigned int v_pos=u_pos + width*height/4;
for(int j = 0;j < height;++j)
{
for(int i = 0;i < width;++i)
{
buf[y_pos++]=yuv.y;
if(i%2==0&&j%2==0)
{
buf[u_pos++]=yuv.u;
buf[v_pos++]=yuv.v;
}
}
}
}
void createBg_yuyv(unsigned int width,unsigned int height,RGB color,unsigned char* buffer)
{
YUV yuv = rgb2yuv(color);
for(int j = 0;j < height;++j)
{
int pos = j*width*2;
for(int i = 0;i < width;i+=2)
{
buffer[pos++] = yuv.y;
buffer[pos++] = yuv.u;
buffer[pos++] = yuv.y;
buffer[pos++] = yuv.v;
}
}
}
| [
"846993525@qq.com"
] | 846993525@qq.com |
f89e589ba5149f19beed88f476088d360d1ccde0 | df8ed4f50a6447f88f75e11ecac449b579ead152 | /Qt_Demos/VariadicTemplatesDemo/VariadicTemplates.hpp | 3032b4cecd63da68ee3463340324467fd6f00515 | [] | no_license | cgwu/eclipse_cpp | 3de8ce4b3d835729f2fcee2cd75d80a6bd772ed2 | 35f0af271a5a6382c510fdced6405fad05aaafcf | refs/heads/master | 2021-01-21T14:11:49.116017 | 2018-09-20T05:34:36 | 2018-09-20T05:34:36 | 52,364,614 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,587 | hpp | #pragma once
#include <iostream>
#include <tuple>
#include <bitset>
using namespace std;
/********* Variadic Templates(数量不定的模板参数) **********/
/*
// 一、采用参数分解递归的方式
//1.
void print() {}
//2. 与3相比，比较特化。
template <typename T, typename... Types>
void print(const T& firstArg, const Types&... args)
{
cout << "sizeof args =(" << sizeof...(args) << "): " << firstArg << endl;
print(args...);
}
//3. 此模板函数未调用到。
template <typename T, typename... Types>
void print(const Types&... args)
{
cout << "#sizeof args =(" << sizeof...(args) << "): " << firstArg << endl;
print(args...);
}
*/
/**********************/
// 一、采用模板常量递归的方式
// boost: util/printtuple.hpp
template<int IDX, int MAX, typename... Args>
struct PRINT_TUPLE
{
static void print(ostream& os, const tuple<Args...>& t)
{
os << get<IDX>(t) << (IDX + 1 == MAX ? "" : ",");
PRINT_TUPLE<IDX + 1, MAX, Args...>::print(os, t);
}
};
// 终结条件
template<int MAX, typename... Args>
struct PRINT_TUPLE<MAX,MAX,Args...>
{
static void print(ostream& , const tuple<Args...>& ) { }
};
// output perator for tuples
template<typename... Args>
ostream& operator<<(ostream& os, const tuple<Args...>& t)
{
os << "[";
PRINT_TUPLE<0,sizeof...(Args), Args...>::print(os, t);
return os << "]";
}
void VariadicTemplates() {
//1. Variadic Templates
//print(7.5, "hello中国", bitset<16>(377), 42);
auto t1 = make_tuple(17.5, "1hello中国", bitset<16>(377), 142);
cout << t1 << endl;
cout << endl;
}
| [
"gg.wcg@qq.com"
] | gg.wcg@qq.com |
c67f74b9a91de0e42b2590648e27935ea27d1cd1 | 575d1c0b9f6bb8f6fab511b4dc913a18cbb56757 | /smalloc_2/details.hpp | 4a196a9dee9c7b53f8fc78a7fdb9d4ccc16e7008 | [] | no_license | qwertysyssec/smalloc_2 | 85051615a2c03910f83d792f5adbf92f4748932a | 1fcc0eaefdbd59e4948967370e64ca6fb54b92eb | refs/heads/master | 2022-02-19T18:47:14.942774 | 2019-09-25T19:52:35 | 2019-09-25T19:52:35 | 210,917,546 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 230 | hpp | #ifndef UUID_A1E18D1A_150E_4FA5_A6A8_0F5BF73D6AAC
#define UUID_A1E18D1A_150E_4FA5_A6A8_0F5BF73D6AAC
#include <cstddef>
namespace details{
constexpr extern inline std::size_t max_align = alignof(std::max_align_t);
}
#endif
| [
"noreply@github.com"
] | qwertysyssec.noreply@github.com |
0f6016d76beda2038cc068cbbe17142edb262a70 | 88ae8695987ada722184307301e221e1ba3cc2fa | /third_party/re2/src/re2/testing/regexp_generator.cc | 3eeda25e3ec875cf83a3ae28af6a8da59d76d255 | [
"BSD-3-Clause",
"LicenseRef-scancode-unknown-license-reference",
"Apache-2.0",
"LGPL-2.0-or-later",
"MIT",
"GPL-1.0-or-later"
] | permissive | iridium-browser/iridium-browser | 71d9c5ff76e014e6900b825f67389ab0ccd01329 | 5ee297f53dc7f8e70183031cff62f37b0f19d25f | refs/heads/master | 2023-08-03T16:44:16.844552 | 2023-07-20T15:17:00 | 2023-07-23T16:09:30 | 220,016,632 | 341 | 40 | BSD-3-Clause | 2021-08-13T13:54:45 | 2019-11-06T14:32:31 | null | UTF-8 | C++ | false | false | 8,459 | cc | // Copyright 2008 The RE2 Authors. All Rights Reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Regular expression generator: generates all possible
// regular expressions within parameters (see regexp_generator.h for details).
// The regexp generator first generates a sequence of commands in a simple
// postfix language. Each command in the language is a string,
// like "a" or "%s*" or "%s|%s".
//
// To evaluate a command, enough arguments are popped from the value stack to
// plug into the %s slots. Then the result is pushed onto the stack.
// For example, the command sequence
// a b %s%s c
// results in the stack
// ab c
//
// GeneratePostfix generates all possible command sequences.
// Then RunPostfix turns each sequence into a regular expression
// and passes the regexp to HandleRegexp.
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <memory>
#include <stack>
#include <string>
#include <vector>
#include "util/test.h"
#include "util/logging.h"
#include "util/strutil.h"
#include "util/utf.h"
#include "re2/testing/regexp_generator.h"
namespace re2 {
// Returns a vector of the egrep regexp operators.
const std::vector<std::string>& RegexpGenerator::EgrepOps() {
static const char *ops[] = {
"%s%s",
"%s|%s",
"%s*",
"%s+",
"%s?",
"%s\\C*",
};
static std::vector<std::string> v(ops, ops + arraysize(ops));
return v;
}
RegexpGenerator::RegexpGenerator(int maxatoms, int maxops,
const std::vector<std::string>& atoms,
const std::vector<std::string>& ops)
: maxatoms_(maxatoms), maxops_(maxops), atoms_(atoms), ops_(ops) {
// Degenerate case.
if (atoms_.empty())
maxatoms_ = 0;
if (ops_.empty())
maxops_ = 0;
}
// Generates all possible regular expressions (within the parameters),
// calling HandleRegexp for each one.
void RegexpGenerator::Generate() {
std::vector<std::string> postfix;
GeneratePostfix(&postfix, 0, 0, 0);
}
// Generates random regular expressions, calling HandleRegexp for each one.
void RegexpGenerator::GenerateRandom(int32_t seed, int n) {
rng_.seed(seed);
for (int i = 0; i < n; i++) {
std::vector<std::string> postfix;
GenerateRandomPostfix(&postfix, 0, 0, 0);
}
}
// Counts and returns the number of occurrences of "%s" in s.
static int CountArgs(const std::string& s) {
const char *p = s.c_str();
int n = 0;
while ((p = strstr(p, "%s")) != NULL) {
p += 2;
n++;
}
return n;
}
// Generates all possible postfix command sequences.
// Each sequence is handed off to RunPostfix to generate a regular expression.
// The arguments are:
// post: the current postfix sequence
// nstk: the number of elements that would be on the stack after executing
// the sequence
// ops: the number of operators used in the sequence
// atoms: the number of atoms used in the sequence
// For example, if post were ["a", "b", "%s%s", "c"],
// then nstk = 2, ops = 1, atoms = 3.
//
// The initial call should be GeneratePostfix([empty vector], 0, 0, 0).
//
void RegexpGenerator::GeneratePostfix(std::vector<std::string>* post,
int nstk, int ops, int atoms) {
if (nstk == 1)
RunPostfix(*post);
// Early out: if used too many operators or can't
// get back down to a single expression on the stack
// using binary operators, give up.
if (ops + nstk - 1 > maxops_)
return;
// Add atoms if there is room.
if (atoms < maxatoms_) {
for (size_t i = 0; i < atoms_.size(); i++) {
post->push_back(atoms_[i]);
GeneratePostfix(post, nstk + 1, ops, atoms + 1);
post->pop_back();
}
}
// Add operators if there are enough arguments.
if (ops < maxops_) {
for (size_t i = 0; i < ops_.size(); i++) {
const std::string& fmt = ops_[i];
int nargs = CountArgs(fmt);
if (nargs <= nstk) {
post->push_back(fmt);
GeneratePostfix(post, nstk - nargs + 1, ops + 1, atoms);
post->pop_back();
}
}
}
}
// Generates a random postfix command sequence.
// Stops and returns true once a single sequence has been generated.
bool RegexpGenerator::GenerateRandomPostfix(std::vector<std::string>* post,
int nstk, int ops, int atoms) {
std::uniform_int_distribution<int> random_stop(0, maxatoms_ - atoms);
std::uniform_int_distribution<int> random_bit(0, 1);
std::uniform_int_distribution<int> random_ops_index(
0, static_cast<int>(ops_.size()) - 1);
std::uniform_int_distribution<int> random_atoms_index(
0, static_cast<int>(atoms_.size()) - 1);
for (;;) {
// Stop if we get to a single element, but only sometimes.
if (nstk == 1 && random_stop(rng_) == 0) {
RunPostfix(*post);
return true;
}
// Early out: if used too many operators or can't
// get back down to a single expression on the stack
// using binary operators, give up.
if (ops + nstk - 1 > maxops_)
return false;
// Add operators if there are enough arguments.
if (ops < maxops_ && random_bit(rng_) == 0) {
const std::string& fmt = ops_[random_ops_index(rng_)];
int nargs = CountArgs(fmt);
if (nargs <= nstk) {
post->push_back(fmt);
bool ret = GenerateRandomPostfix(post, nstk - nargs + 1,
ops + 1, atoms);
post->pop_back();
if (ret)
return true;
}
}
// Add atoms if there is room.
if (atoms < maxatoms_ && random_bit(rng_) == 0) {
post->push_back(atoms_[random_atoms_index(rng_)]);
bool ret = GenerateRandomPostfix(post, nstk + 1, ops, atoms + 1);
post->pop_back();
if (ret)
return true;
}
}
}
// Interprets the postfix command sequence to create a regular expression
// passed to HandleRegexp. The results of operators like %s|%s are wrapped
// in (?: ) to avoid needing to maintain a precedence table.
void RegexpGenerator::RunPostfix(const std::vector<std::string>& post) {
std::stack<std::string> regexps;
for (size_t i = 0; i < post.size(); i++) {
switch (CountArgs(post[i])) {
default:
LOG(FATAL) << "Bad operator: " << post[i];
case 0:
regexps.push(post[i]);
break;
case 1: {
std::string a = regexps.top();
regexps.pop();
regexps.push("(?:" + StringPrintf(post[i].c_str(), a.c_str()) + ")");
break;
}
case 2: {
std::string b = regexps.top();
regexps.pop();
std::string a = regexps.top();
regexps.pop();
regexps.push("(?:" +
StringPrintf(post[i].c_str(), a.c_str(), b.c_str()) +
")");
break;
}
}
}
if (regexps.size() != 1) {
// Internal error - should never happen.
printf("Bad regexp program:\n");
for (size_t i = 0; i < post.size(); i++) {
printf(" %s\n", CEscape(post[i]).c_str());
}
printf("Stack after running program:\n");
while (!regexps.empty()) {
printf(" %s\n", CEscape(regexps.top()).c_str());
regexps.pop();
}
LOG(FATAL) << "Bad regexp program.";
}
HandleRegexp(regexps.top());
HandleRegexp("^(?:" + regexps.top() + ")$");
HandleRegexp("^(?:" + regexps.top() + ")");
HandleRegexp("(?:" + regexps.top() + ")$");
}
// Split s into an vector of strings, one for each UTF-8 character.
std::vector<std::string> Explode(const StringPiece& s) {
std::vector<std::string> v;
for (const char *q = s.data(); q < s.data() + s.size(); ) {
const char* p = q;
Rune r;
q += chartorune(&r, q);
v.push_back(std::string(p, q - p));
}
return v;
}
// Split string everywhere a substring is found, returning
// vector of pieces.
std::vector<std::string> Split(const StringPiece& sep, const StringPiece& s) {
std::vector<std::string> v;
if (sep.empty())
return Explode(s);
const char *p = s.data();
for (const char *q = s.data(); q + sep.size() <= s.data() + s.size(); q++) {
if (StringPiece(q, sep.size()) == sep) {
v.push_back(std::string(p, q - p));
p = q + sep.size();
q = p - 1; // -1 for ++ in loop
continue;
}
}
if (p < s.data() + s.size())
v.push_back(std::string(p, s.data() + s.size() - p));
return v;
}
} // namespace re2
| [
"jengelh@inai.de"
] | jengelh@inai.de |
99f90997b09ade33414d13329336e316c55901a5 | 4d25c9e286193db52205ce7927b2126ec666bc62 | /xx_chat_server/src/db_proxy_server/business/session.cpp | 542d89573edc5bcd0825d32e8cac76bb6c8bea00 | [] | no_license | AnonymousRookie/xx_chat | ef7410320f63667e64305efd1733d44cc39668f9 | 1a3a7e4dcf8fabd090de0d3c04af4d2a7402a69c | refs/heads/master | 2021-06-09T19:49:17.932952 | 2020-12-07T15:21:31 | 2020-12-07T15:21:31 | 139,589,005 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 455 | cpp | /**
* Copyright 2019-2020, AnonymousRookie. All rights reserved.
* https://github.com/AnonymousRookie/xx_chat
* Author: AnonymousRookie (357688981 at qq dot com)
* Description: 处理会话
*/
#include "session.h"
#include "../proxy_conn.h"
NAMESPACE_BEGIN(z)
NAMESPACE_BEGIN(business)
void ProcessSessionMsg(std::shared_ptr<ImPdu> pdu, uint32_t connUuid)
{
ProxyConn::AddResponsePdu(connUuid, pdu);
}
NAMESPACE_END(business)
NAMESPACE_END(z) | [
"357688981@qq.com"
] | 357688981@qq.com |
f512137eddbdcdd46ab7795128d90621efd3714f | 071472589b758d650de7601107c40f1570abaf97 | /stack.h | 76db56d73e5d92bdfc35d5d0ba49de256ba61f2e | [] | no_license | dev-sachin-chauhan/My-General-Codes | d1b226be5419b893580bab50abcb25d87a0f96c8 | b74b3d046d5ed3620e688c05d5481a5331329aaa | refs/heads/master | 2021-06-18T19:13:55.802514 | 2017-06-16T03:23:49 | 2017-06-16T03:23:49 | 12,079,693 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,654 | h | /*****************************************************************************************/
#include <iostream>
#include <exception>
#include <limits.h>
#include <new>
using namespace std;
#ifndef STACK_H
#define STACK_H
class StackEmpty: public exception
{
// Exception class - throw an object of this type when stack is empty
// Hint: there is no code for exception classes
virtual const char* what() const throw()
{
return "Stack is Empty Exception";
}
};
class StackFull: public exception
{
// Exception class - throw an object of this type when stack is full
virtual const char* what() const throw()
{
return "Stack is Full Exception";
}
};
class StackInvalidPeek: public exception
{
// Exception class - throw an object of this type when invalid peek position is used
virtual const char* what() const throw()
{
return "Stack Invalid Peek Excpetion";
}
};
class Stack // Models stack of integers ADT implemented as a dynamically allocated array
{
private:
int* array; // Points to the stack array
int num; // Holds max number of elements that may be stored in stack array
int top; // Holds the index of the top data value stored on the stack
void Resize(int n); // Attempts to increase size of stack array to 2*num and then push n onto stack
// If unable to resize, throw StackFull exception
public:
Stack(int n); // Parameterized constructor dynamically allocates an empty stack array
// that may hold no more than n elements and initializes other private variables
~Stack(); // Destructor deallocates all dynamically-allocated memory
// associated with the object
void Push(int n); // Pushes integer n onto top of stack. If stack is full, attempts to
// resize stack and then push n. If unable to resize, throws StackFull exception.
void Pop(); // Removes top integer from stack
// If stack is empty, throws StackEmpty exception
bool IsEmpty() const; // Returns true if stack is empty; false otherwise
bool IsFull() const; // Returns true if stack is full; false otherwise
void MakeEmpty(); // Removes all items from stack leaving an empty, but usable stack with capacity num
// If stack is already empty, MakeEmpty() does nothing
int Top() const; // Returns value of top integer on stack WITHOUT modifying the stack
// If stack is empty, throws StackEmpty exception
int Size() const; // Returns number of items on stack WITHOUT modifying the stack
int Max() const; // Returns value of largest integer on stack WITHOUT modifying the stack
// If stack is empty, throws StackEmpty
int Min() const; // Returns value of smallest integer on stack WITHOUT modifying the stack
// If stack is empty, throws StackEmpty
int Peek(unsigned int n) const; // Returns stack value n levels down from top of stack. Peek(0) = Top()
// If position n does not exist, throws StackInvalidPeek
int Capacity() const; // Returns total num of elements that maybe stored in stack array
/******* DO NOT MODIFY ANY OF THE CODE FOR PRINT() *******/
/****** DO NOT PLACE A COPY OF PRINT() CODE IN STACK.CPP!!! *******/
void Print() const // Writes stack contents to stdout, separated by a space, followed by endl
{
int index = top;
cout << "Top { ";
while (index != -1)
{
cout << array[index] << " ";
index--;
}
cout << "} Bottom" << endl;
} // End Print()
}; // End Class Stack
void Stack::Resize(int n) {
int *temp = NULL;
try {
temp = new int[2*num];
} catch (std::bad_alloc& bd) {
throw StackFull();
return;
}
for(int i=0;i<num;i++){
temp[i] = array[i];
}
temp[num] = n;
top = num;
num = 2*num;
delete [] array;
array = temp;
}
Stack::Stack(int n) {
num = n;
array = new int[n];
top = -1;
}
Stack::~Stack(void) {
delete [] array;
}
void Stack::Push(int n) {
if(IsFull()){
Resize(n);
}else{
array[++top] = n;
}
}
void Stack::Pop() {
if(IsEmpty()){
throw StackEmpty();
}else{
top--;
}
}
bool Stack::IsEmpty() const{
if(top == -1){
return true;
}else{
return false;
}
}
bool Stack::IsFull() const{
if(top == num-1){
return true;
}else{
return false;
}
}
void Stack::MakeEmpty() {
if(IsEmpty()){
return;
}
top = -1;
}
int Stack::Top() const{
if(IsEmpty()) {
throw StackEmpty();
}else{
return array[top];
}
return -1;
}
int Stack::Size() const {
return top+1;
}
int Stack::Max() const{
int max=INT_MIN;
if(IsEmpty()) {
throw StackEmpty();
}
for(int i=0;i<=top;i++){
if(array[i]>max){
max = array[i];
}
}
return max;
}
int Stack::Min() const{
int min=INT_MAX;
if(IsEmpty()) {
throw StackEmpty();
}
for(int i=0;i<=top;i++){
if(array[i]<min){
min = array[i];
}
}
return min;
}
int Stack::Peek(unsigned int n) const{
if(top+1 <= n){
throw StackInvalidPeek();
return -1;
}else{
return array[top-n];
}
}
int Stack::Capacity() const {
return num;
}
#endif
/*********************************************************************************************/
| [
"noreply@github.com"
] | dev-sachin-chauhan.noreply@github.com |
f1b5ce373a4eb650efa05d397b9c6c974706d8bb | 136ef215ae05f74d31dab2336979a94dfe960992 | /varie/IotProtoShield/test_bt_touch/test_bt_touch.ino | 75826c418eb5aa8c7a3e36b5ab2ff46f464b281d | [] | no_license | zmaker/arduino_cookbook | 5ff4791ebce916e35060f2e9a7c26a014adeb26c | a972470c10f2c283d66aad8f389acf117a25f01e | refs/heads/master | 2023-08-30T21:08:28.290973 | 2023-08-28T11:14:41 | 2023-08-28T11:14:41 | 135,202,699 | 196 | 134 | null | 2020-05-27T17:53:02 | 2018-05-28T19:46:44 | C++ | UTF-8 | C++ | false | false | 292 | ino | void setup() {
Serial.begin(9600);
pinMode(32, INPUT);
pinMode(19, OUTPUT);
pinMode(23, OUTPUT);
}
void loop() {
int bt = digitalRead(32);
if (bt) {
digitalWrite(19, HIGH);
digitalWrite(23, LOW);
} else {
digitalWrite(19, LOW);
digitalWrite(23, HIGH);
}
}
| [
"zeppelinmaker@gmail.com"
] | zeppelinmaker@gmail.com |
721ee2eb6e36e9be645ea39c94866b8635a0d31e | c56b86c0c098948a1aa7ca3b4a25c7be47af2f45 | /Qt/my_old_programm/Bluetooth/Bluetooth_6x8_matrix/src/main.cpp | ad98d5b21c15db58767ca9731cd2f930c3778378 | [] | no_license | jianglin2045/mega_GIT | 764e460282f1242be5530c8e20e498119f20f827 | 7224c3cf50bf029ff127a3e3db0bb3698af28aa4 | refs/heads/master | 2023-02-13T19:41:30.407632 | 2021-01-11T21:09:31 | 2021-01-11T21:09:31 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,889 | cpp | /*********************************************************************************
** **
** Copyright (C) 2012 **
** **
** This program is free software: you can redistribute it and/or modify **
** it under the terms of the GNU General Public License as published by **
** the Free Software Foundation, either version 3 of the License, or **
** (at your option) any later version. **
** **
** This program is distributed in the hope that it will be useful, **
** but WITHOUT ANY WARRANTY; without even the implied warranty of **
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the **
** GNU General Public License for more details. **
** **
** You should have received a copy of the GNU General Public License **
** along with this program. If not, see http://www.gnu.org/licenses/. **
** **
**********************************************************************************
** Author: Bikbao Rinat Zinorovich **
**********************************************************************************/
#ifdef HAVE_QT5
# include <QtWidgets>
#else
# include <QtGui>
#endif
//--------------------------------------------------------------------------------
#include "mysplashscreen.hpp"
#include "mainwindow.hpp"
#include "bluetooth_6x8_matrix_mainbox.hpp"
#include "defines.hpp"
#include "version.hpp"
//--------------------------------------------------------------------------------
#include "codecs.h"
//--------------------------------------------------------------------------------
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
set_codecs();
app.setOrganizationName(QObject::tr(ORGNAME));
app.setApplicationName(QObject::tr(APPNAME));
app.setWindowIcon(QIcon(ICON_PROGRAMM));
QPixmap pixmap(":/logo/logo.png");
MySplashScreen *splash = new MySplashScreen(pixmap);
splash->show();
splash->showMessage(QObject::tr("Подождите ..."));
MainWindow *main_window = new MainWindow();
MainBox *mainBox = new MainBox(main_window, splash);
main_window->setCentralWidget(mainBox);
main_window->show();
splash->finish(main_window);
return app.exec();
}
//--------------------------------------------------------------------------------
| [
"tux4096@gmail.com"
] | tux4096@gmail.com |
ef65ada731f76b47d24ca498da63ac48286f6225 | 9a064936096b16a2f56f0e4c1a6521f19e6ea69d | /testSketch/testSketch.ino | 8783b85ff5e1d22c53c93a674bf782da792f0c45 | [] | no_license | rgmuna/LED_Items | c61671ccfec00403e2c850a3de26a9426f255401 | 59720c2b2ea424c0158ac9578fa22ba0fcbe9e21 | refs/heads/master | 2020-03-26T01:03:33.426757 | 2018-08-25T19:18:54 | 2018-08-25T19:18:54 | 144,350,238 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 54,330 | ino | #define ARM_MATH_CM4
#include <EEPROM.h>
#include <Adafruit_NeoPixel.h>
#include <RunningAverage.h>
// Pattern types supported:
enum pattern { NONE, RAINBOW_CYCLE, THEATER_CHASE, COLOR_WIPE, COLOR_WIPE_SINGLE,
COLOR_WIPE_REVERSE, SCANNER,
FADE, RANDOM_PIXELS, FLASH_COLOR, SCROLL_COLOR, SCROLL_TWO_COLOR,
SCROLL_TWO_COLOR_REVERSE, SCROLL_MIDDLE, SCROLL_MIDDLE_SINGLE, SCROLL_MIDDLE_TWO_COLOR,
SCROLL_ENDS, SCROLL_ENDS_TWO_COLOR, SCROLL_COLOR_UNDERCOLOR, COLOR_RAIN,
BLOCK_DROP, COLOR_SWITCH, RANDOM_EATER, RANDOM_FILL, BLOCK_DROP_BORING, RANDOM_FILL_BORING,
SPEED_CHANGE, BLOCK_PLACER, BLOCK_PLACER_BORING, SCANNER_BORING, BREATHE_COLOR, BREATHE_COLOR_RANDOM};
// Patern directions supported:
enum direction { FORWARD, REVERSE };
bool beatOn;
const uint8_t PROGMEM Gamma[] = {
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, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2,
2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5,
5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 9, 9, 9, 10,
10, 10, 11, 11, 11, 12, 12, 13, 13, 13, 14, 14, 15, 15, 16, 16,
17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 24, 24, 25,
25, 26, 27, 27, 28, 29, 29, 30, 31, 32, 32, 33, 34, 35, 35, 36,
37, 38, 39, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 50,
51, 52, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 66, 67, 68,
69, 70, 72, 73, 74, 75, 77, 78, 79, 81, 82, 83, 85, 86, 87, 89,
90, 92, 93, 95, 96, 98, 99,101,102,104,105,107,109,110,112,114,
115,117,119,120,122,124,126,127,129,131,133,135,137,138,140,142,
144,146,148,150,152,154,156,158,160,162,164,167,169,171,173,175,
177,180,182,184,186,189,191,193,196,198,200,203,205,208,210,213,
215,218,220,223,225,228,231,233,236,239,241,244,247,249,252,255 };
// NeoPattern Class - derived from the Adafruit_NeoPixel class
class NeoPatterns : public Adafruit_NeoPixel
{
public:
// Member Variables:
pattern ActivePattern; // which pattern is running
direction Direction; // direction to run the pattern
// beat Beat;
unsigned long Interval; // milliseconds between updates
unsigned long lastUpdate; // last update of position
uint32_t Color1, Color2; // What colors are in use
uint16_t TotalSteps; // total number of steps in the pattern
uint16_t Index; // current step within the pattern
int i;
int Counter;
int Counter2;
void (*OnComplete)(); // Callback on completion of pattern
// Constructor - calls base-class constructor to initialize strip
NeoPatterns(uint16_t pixels, uint8_t pin, uint8_t type, void (*callback)())
:Adafruit_NeoPixel(pixels, pin, type)
{
OnComplete = callback;
}
// Update the pattern
void Update()
{
if((millis() - lastUpdate) > Interval) // time to update
{
lastUpdate = millis();
switch(ActivePattern)
{
case RAINBOW_CYCLE:
RainbowCycleUpdate();
break;
case THEATER_CHASE:
TheaterChaseUpdate();
break;
case COLOR_WIPE:
ColorWipeUpdate();
break;
case COLOR_WIPE_SINGLE:
ColorWipeSingleUpdate();
break;
case COLOR_WIPE_REVERSE:
ColorWipeReverseUpdate();
break;
case SCANNER:
ScannerUpdate();
break;
case SCANNER_BORING:
ScannerBoringUpdate();
break;
case FADE:
FadeUpdate();
break;
case RANDOM_PIXELS:
RandomPixelsUpdate();
break;
case SCROLL_TWO_COLOR:
ScrollTwoColorUpdate();
break;
case SCROLL_TWO_COLOR_REVERSE:
ScrollTwoColorReverseUpdate();
break;
case SCROLL_MIDDLE:
ScrollMiddleUpdate();
break;
case SCROLL_MIDDLE_SINGLE:
ScrollMiddleSingleUpdate();
break;
case SCROLL_MIDDLE_TWO_COLOR:
ScrollMiddleTwoColorUpdate();
break;
case SCROLL_ENDS:
ScrollEndsUpdate();
break;
case SCROLL_ENDS_TWO_COLOR:
ScrollEndsTwoColorUpdate();
break;
case SCROLL_COLOR_UNDERCOLOR:
ScrollColorUndercolorUpdate();
break;
case COLOR_RAIN:
ColorRainUpdate();
break;
case BLOCK_DROP:
BlockDropUpdate();
break;
case COLOR_SWITCH:
ColorSwitchUpdate();
break;
case RANDOM_EATER:
RandomEaterUpdate();
break;
case BLOCK_DROP_BORING:
BlockDropBoringUpdate();
break;
case RANDOM_FILL:
RandomFillUpdate();
break;
case RANDOM_FILL_BORING:
RandomFillBoringUpdate();
break;
case SPEED_CHANGE:
SpeedChangeUpdate();
break;
case BLOCK_PLACER:
BlockPlacerUpdate();
break;
case BLOCK_PLACER_BORING:
BlockPlacerBoringUpdate();
break;
case BREATHE_COLOR:
BreatheColorUpdate();
break;
case BREATHE_COLOR_RANDOM:
BreatheColorUpdate();
default:
break;
}
}
}
// Increment the Index and reset at the end
void Increment()
{
if (Direction == FORWARD)
{
Index++;
if (Index >= TotalSteps)
{
Index = 0;
if (OnComplete != NULL)
{
OnComplete(); // call the completion callback
}
}
}
else // Direction == REVERSE
{
--Index;
if (Index <= 0)
{
Index = TotalSteps-1;
if (OnComplete != NULL)
{
OnComplete(); // call the comlpetion callback
}
}
}
}
// Initialize for a RainbowCycle
void RainbowCycle(uint8_t interval, direction dir = FORWARD)
{
ActivePattern = RAINBOW_CYCLE;
Interval = interval;
TotalSteps = 255;
Index = 0;
// Direction = dir;
}
// Update the Rainbow Cycle Pattern
void RainbowCycleUpdate()
{
for(int i=0; i< numPixels(); i++)
{
setPixelColor(i, Wheel(((i * 256 / numPixels()) + Index) & 255));
}
show();
Increment();
}
// Initialize for a ColorWipe (only in the forward direction)
void ColorWipeSingle(uint32_t color, float interval, bool beatOn)
{
ActivePattern = COLOR_WIPE_SINGLE;
if (beatOn) {
Interval = interval/numPixels();
}
else {
Interval = interval;
}
TotalSteps = numPixels();
Color1 = color;
Index = 0;
// Direction = dir;
}
// Update the Color Wipe Pattern
void ColorWipeSingleUpdate()
{
if (Index == 0) {
CleanPixels();
}
setPixelColor(Index, Color1);
show();
Increment();
}
//-------------------- COLOR WIPE (goes down one color, returns a different color
void ColorWipe(uint32_t color1, uint32_t color2, float interval, bool beatOn)
{
ActivePattern = COLOR_WIPE;
if (beatOn) {
Interval = interval/numPixels();
}
else {
Interval = interval;
}
TotalSteps = numPixels()*2;
Color1 = color1;
Color2 = color2;
Index = 0;
//Direction = dir;
}
void ColorWipeUpdate()
{
if(Index < numPixels()){
setPixelColor(Index, Color1);
}
else{
setPixelColor(TotalSteps-Index, Color2);
}
show();
Increment();
}
// Initialize reverse color wipe
void ColorWipeReverse(int color1, float interval, bool beatOn) {
ActivePattern = COLOR_WIPE_REVERSE;
if (beatOn) {
Interval = interval/numPixels();
}
else {
Interval = interval;
}
TotalSteps = numPixels() + 1;
Color1 = color1;
Index = 0;
// Direction = dir;
}
void ColorWipeReverseUpdate() {
if (Index == 0) {
CleanPixels();
}
setPixelColor(numPixels() - Index, Color1);
show();
Increment();
}
// Initialize for a color scroll with a color underneath
void ScrollColorUndercolor(int color1, int color2, float interval, bool beatOn) {
ActivePattern = SCROLL_COLOR_UNDERCOLOR;
if (beatOn) {
Interval = interval/numPixels();
}
else {
Interval = interval;
}
TotalSteps = numPixels();
Color1 = color1;
Color2 = color2;
Index = 0;
// Direction = dir;
}
// Update the color scroll with a different undercolor
void ScrollColorUndercolorUpdate() {
if (Index == 0) {
ColorSet(Color2);
}
setPixelColor(Index, Color1);
show();
Increment();
}
// Initialize for a Theater Chase
void TheaterChase(uint32_t color1, uint32_t color2, float interval, bool beatOn)
{
ActivePattern = THEATER_CHASE;
Interval = interval;
TotalSteps = numPixels();
Color1 = color1;
Color2 = color2;
Index = 0;
// Direction = dir;
}
// Update the Theater Chase Pattern
void TheaterChaseUpdate()
{
for(int i=0; i< numPixels(); i++)
{
if ((i + Index) % 3 == 0)
{
setPixelColor(i, Color1);
}
else
{
setPixelColor(i, Color2);
}
}
show();
Increment();
}
// Initialize for a SCANNNER
void Scanner(uint32_t color1, float interval, bool beatOn)
{
ActivePattern = SCANNER;
if (beatOn) {
Interval = interval/numPixels();
}
else {
Interval = interval;
}
TotalSteps = (numPixels() - 1) * 2;
Color1 = color1;
Index = 0;
}
// Update the Scanner Pattern
void ScannerUpdate()
{
for (int i = 0; i < numPixels(); i++)
{
if (i == Index) // first half of the scan
{
// Serial.print(i);
setPixelColor(i, Wheel(((i * 256 / numPixels()) + Index) & 255));
}
else if (i == TotalSteps - Index) // The return trip.
{
// Serial.print(i);
setPixelColor(i, Wheel(((i * 256 / numPixels()) + Index) & 255));
}
else // fade to black
{
setPixelColor(i, DimColor(getPixelColor(i)));
}
}
show();
Increment();
}
void ScannerBoring(uint32_t color1, float interval, bool beatOn)
{
ActivePattern = SCANNER_BORING;
if (beatOn) {
Interval = interval/numPixels();
}
else {
Interval = interval;
}
TotalSteps = (numPixels() - 1) * 2;
Color1 = color1;
Index = 0;
}
// Update the Scanner Pattern
void ScannerBoringUpdate()
{
for (int i = 0; i < numPixels(); i++)
{
if (i == Index) // first half of the scan
{
// Serial.print(i);
setPixelColor(i, Color1);
}
else if (i == TotalSteps - Index) // The return trip.
{
// Serial.print(i);
setPixelColor(i, Color1);
}
else // fade to black
{
setPixelColor(i, DimColor(getPixelColor(i)));
}
}
show();
Increment();
}
// Initialize for a Fade
void Fade(uint32_t color1, uint32_t color2, uint16_t steps, int interval)
{
ActivePattern = FADE;
Interval = interval;
TotalSteps = steps;
Color1 = color1;
Color2 = color2;
Index = 0;
// Direction = dir;
}
// Update the Fade Pattern
void FadeUpdate()
{
uint8_t red = ((Red(Color1) * (TotalSteps - Index)) + (Red(Color2) * Index)) / TotalSteps;
uint8_t green = ((Green(Color1) * (TotalSteps - Index)) + (Green(Color2) * Index)) / TotalSteps;
uint8_t blue = ((Blue(Color1) * (TotalSteps - Index)) + (Blue(Color2) * Index)) / TotalSteps;
ColorSet(Color(red, green, blue));
show();
Increment();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
// Custom Patterns Begin
/////////////////////////////////////////////////////////////////////////////////////////////////////////
// Random Pixels
void RandomPixels(int interval, int steps) {
ActivePattern = RANDOM_PIXELS;
Interval = interval;
TotalSteps = steps;
}
// Update the Random Pixels pattern
void RandomPixelsUpdate() {
setPixelColor(random(numPixels()-1), Wheel(random(255)));
setPixelColor(random(numPixels()-1), 0);
show();
Increment();
}
// Two-color scroll (or ColorWipe)
void ScrollTwoColor(uint32_t color1, uint32_t color2, float interval, bool beatOn)
{
ActivePattern = SCROLL_TWO_COLOR;
if (beatOn) {
Interval = interval/numPixels();
}
else {
Interval = interval;
}
TotalSteps = numPixels() + 3;
Color1 = color1;
Color2 = color2;
Index = 0;
// Direction = dir;
}
// Update the Scroll Two Color Pattern
void ScrollTwoColorUpdate()
{
if (Index == 0) {
CleanPixels();
setPixelColor(Index, Color1);
}
else if (Index == 1) {
setPixelColor(Index, Color1);
setPixelColor(Index-1, Color1);
}
else if (Index == 2) {
setPixelColor(Index, Color1);
setPixelColor(Index-1, Color1);
setPixelColor(Index-2, Color1);
}
else if (Index == numPixels() - 1) { //the last pixel
setPixelColor(Index, Color1);
setPixelColor(Index-1, Color1);
setPixelColor(Index-2, Color1);
setPixelColor(Index-3, Color2);
}
else if (Index == numPixels()) {
setPixelColor(Index-1, Color1);
setPixelColor(Index-2, Color1);
setPixelColor(Index-3, Color2);
}
else if (Index == numPixels() + 1) {
setPixelColor(Index-2, Color1);
setPixelColor(Index-3, Color2);
}
else if (Index == numPixels() + 2) {
setPixelColor(Index-3, Color2);
}
else {
setPixelColor(Index, Color1);
setPixelColor(Index-1, Color1);
setPixelColor(Index-2, Color1);
setPixelColor(Index-3, Color2);
}
show();
Increment();
}
// Two color scroll in reverse
void ScrollTwoColorReverse(uint32_t color1, uint32_t color2, float interval, bool beatOn) {
ActivePattern = SCROLL_TWO_COLOR_REVERSE;
if (beatOn) {
Interval = interval/numPixels();
}
else {
Interval = interval;
}
TotalSteps = numPixels() + 4;
Color1 = color1;
Color2 = color2;
Index = 0;
// Direction = dir;
}
// Update the reverse two-color scroll
void ScrollTwoColorReverseUpdate() {
if (Index == 0) {
CleanPixels();
}
setPixelColor(numPixels()-Index, Color1);
setPixelColor(numPixels()-Index+1, Color1);
setPixelColor(numPixels()-Index+2, Color1);
setPixelColor(numPixels()-Index+3, Color2);
show();
Increment();
}
//-------------------- SCROLL MIDDLE ---------------------------------------------------------
void ScrollMiddle(uint32_t color1, uint32_t color2, float interval, bool beatOn) {
ActivePattern = SCROLL_MIDDLE;
if (beatOn) {
Interval = interval/(numPixels()/2);
}
else {
Interval = interval;
}
TotalSteps = numPixels();
Color1 = color1;
Color2 = color2;
Index = 0;
//Direction = dir;
}
// Update the scroll middle pattern
void ScrollMiddleUpdate() {
if (Index == 0) {
CleanPixels();
}
else if(Index < numPixels()/2){
setPixelColor((numPixels()/2)+Index, Color1);
setPixelColor((numPixels()/2)-Index, Color1);
}
else{
setPixelColor(Index-(numPixels()/2), Color2);
setPixelColor(TotalSteps-(Index-(numPixels()/2)), Color2);
}
show();
Increment();
}
// Scroll out from middle to ends
void ScrollMiddleSingle(uint32_t color1, float interval, bool beatOn) {
ActivePattern = SCROLL_MIDDLE_SINGLE;
if (beatOn) {
Interval = (interval)/(numPixels()/2);
}
else {
Interval = interval;
}
TotalSteps = (numPixels()/2) + 1;
Color1 = color1;
Index = 0;
}
// Update the scroll middle pattern
void ScrollMiddleSingleUpdate() {
if (Index == 0) {
CleanPixels();
}
setPixelColor((numPixels()/2)+Index, Color1);
setPixelColor((numPixels()/2)-Index, Color1);
show();
Increment();
}
// Two-color scroll out from middle to ends
void ScrollMiddleTwoColor(uint32_t color1, uint32_t color2, float interval, bool beatOn) {
ActivePattern = SCROLL_MIDDLE_TWO_COLOR;
if (beatOn) {
Interval = interval/(numPixels()/2);
}
else {
Interval = interval;
}
TotalSteps = (numPixels()/2) + 1;
Color1 = color1;
Color2 = color2;
Index = 0;
// Direction = dir;
}
// Update the two-color middle scroll pattern
void ScrollMiddleTwoColorUpdate() {
if (Index == 0) {
CleanPixels();
setPixelColor(numPixels()/2, Color1);
setPixelColor((numPixels()/2)-1, Color1);
}
else {
setPixelColor((numPixels()/2)+Index, Color1);
setPixelColor((numPixels()/2)-Index, Color1);
setPixelColor((numPixels()/2)+Index-1, Color2);
setPixelColor((numPixels()/2)-Index+1, Color2);
}
show();
Increment();
}
// Scroll in from ends
void ScrollEnds(uint32_t color1, float interval, bool beatOn) {
ActivePattern = SCROLL_ENDS;
if (beatOn) {
Interval = interval/(numPixels()/2);
}
else {
Interval = interval;
}
TotalSteps = (numPixels()/2) + 1;
Color1 = color1;
Index = 0;
// Direction = dir;
}
// Update the scroll ends pattern
void ScrollEndsUpdate() {
if (Index == 0) {
CleanPixels();
}
setPixelColor(Index, Color1);
setPixelColor(numPixels()-Index, Color1);
show();
Increment();
}
// Two-color scroll in from the ends
void ScrollEndsTwoColor(int color1, int color2, float interval, bool beatOn) {
ActivePattern = SCROLL_ENDS_TWO_COLOR;
if (beatOn) {
Interval = interval/(numPixels()/2);
}
else {
Interval = interval;
}
TotalSteps = (numPixels()/2) + 1;
Color1 = color1;
Color2 = color2;
Index = 0;
// Direction = dir;
}
// Update the two-color scroll ends pattern
void ScrollEndsTwoColorUpdate() {
if (Index == 0) {
CleanPixels();
setPixelColor(Index, Color1);
setPixelColor(numPixels(), Color1);
}
else {
setPixelColor(Index, Color1);
setPixelColor(Index-1, Color2);
setPixelColor(numPixels() - 1 - Index, Color2);
setPixelColor(numPixels() - 1 - Index - 1, Color1);
}
show();
Increment();
}
//-------------------- Random Pixels ------------------------------------------------------
void RandomEater(uint32_t color1, uint32_t color2, float interval, direction dir = FORWARD){
ActivePattern = RANDOM_EATER;
Interval = interval;
TotalSteps = numPixels();
Color1 = color1;
Color2 = color2;
Index = 0;
Direction = dir;
}
void RandomEaterUpdate(){
if(Index==0){
CleanPixels();
}
else{
//setPixelColor(random(TotalSteps-Index), Wheel(random(255)));
setPixelColor(random(TotalSteps-Index), Color2);
setPixelColor(TotalSteps-Index, Color1);
setPixelColor(TotalSteps-Index+1, DimControl(Color1, 2));
setPixelColor(TotalSteps-Index+2, DimControl(Color1, 4));
setPixelColor(TotalSteps-Index+3, DimControl(Color1, 8));
setPixelColor(TotalSteps-Index+4, DimControl(Color1, 15));
setPixelColor(TotalSteps-Index+5, DimControl(Color1, 20));
setPixelColor(TotalSteps-Index+6, DimControl(Color1, 30));
setPixelColor(TotalSteps-Index+7, 0);
}
show();
Increment();
}
//-------------------- COLOR RAIN---------------------------------------------------------
void ColorRain(uint32_t color1, uint32_t color2, uint8_t interval) {
ActivePattern = COLOR_RAIN;
Interval = interval;
TotalSteps = numPixels()+5;
Color1 = color1;
Color2 = color2;
Index = 0;
//Direction = dir;
}
void ColorRainUpdate(){
int rainSize = 5;
for(i=0; i<=rainSize; i++){
setPixelColor(Index+i-30, Color1);
setPixelColor(Index+i-rainSize-30, DimControl(Color2, 10));
setPixelColor(Index+i-rainSize, Color1);
setPixelColor(Index+i-rainSize-rainSize, DimControl(Color2, 10));
setPixelColor(Index+i+27, Color1); //change to 27 for roque
setPixelColor(Index+i-rainSize+27, DimControl(Color2, 10)); //change to 27 for roque
}
show();
Increment();
}
//-------------------- Block Drop --------------------------------------------------
void BlockDrop(uint32_t color1, uint8_t interval){
ActivePattern = BLOCK_DROP;
Interval = interval;
TotalSteps = (numPixels()*(numPixels()+1))/2;
//TotalSteps = 1431;
Color1 = color1;
Index = 0;
//Direction = dir;
i = 0; //keeps track of number which LEDs to light up
Counter = 0; //keeps track of which particular LED is going to the bottom
Counter2 = 0;
}
void BlockDropUpdate(){
if(Index==0){
//CleanPixels();
Counter=0;
Counter2=0;
}
i = Index - Counter;
setPixelColor(i, Wheel(((i * 256 / numPixels()) + Index) & 255));
setPixelColor(i-1, 0);
if(i>numPixels()-2-Counter2){
Counter = Index;
Counter2++;
}
show();
Increment();
}
void BlockDropBoring(uint32_t color1, uint8_t interval){
ActivePattern = BLOCK_DROP_BORING;
Interval = interval;
TotalSteps = (numPixels()*(numPixels()+1))/2;
//TotalSteps = 1431;
Color1 = color1;
Index = 0;
//Direction = dir;
i = 0; //keeps track of number which LEDs to light up
Counter = 0; //keeps track of which particular LED is going to the bottom
Counter2 = 0;
}
void BlockDropBoringUpdate(){
if(Index==0){
//CleanPixels();
Counter=0;
Counter2=0;
}
i = Index - Counter;
setPixelColor(i, Color1);
setPixelColor(i-1, 0);
if(i>numPixels()-2-Counter2){
Counter = Index;
Counter2++;
}
show();
Increment();
}
//------------ Breathe Color ----------------------//
void BreatheColor(int color1, float interval) {
ActivePattern = BREATHE_COLOR;
Interval = interval;
TotalSteps = 512;
Index = 0;
Color1 = color1;
}
// Update the Breathe Color pattern
void BreatheColorUpdate() {
if(Index <= 255) {
for(int i=0; i < numPixels(); i++) {
setPixelColor(i, DimControl(Color1, Index));
}
}
else {
for(int i=0; i < numPixels(); i++) {
setPixelColor(i, DimControl(Color1, 512-Index));
}
}
show();
Increment();
}
//------------ Breathe Color ----------------------//
void BreatheColorRandom(int color1, int color2, float interval) {
ActivePattern = BREATHE_COLOR_RANDOM;
Interval = interval;
TotalSteps = 512;
Index = 0;
Color1 = color1;
Color2 = color2;
}
// Update the Breathe Color pattern
void BreatheColorRandomUpdate() {
uint8_t red = ((Red(Color1) * (TotalSteps - Index)) + (Red(Color2) * Index)) / TotalSteps;
uint8_t green = ((Green(Color1) * (TotalSteps - Index)) + (Green(Color2) * Index)) / TotalSteps;
uint8_t blue = ((Blue(Color1) * (TotalSteps - Index)) + (Blue(Color2) * Index)) / TotalSteps;
if(Index <= 255) {
for(int i=0; i < numPixels(); i++) {
setPixelColor(i, DimControl(Color(red, green, blue), Index));
}
}
else {
for(int i=0; i < numPixels(); i++) {
setPixelColor(i, DimControl(Color(red, green, blue), 512-Index));
}
}
show();
Increment();
}
//-------------- COLOR SWITCH --------------------------
void ColorSwitch(uint32_t color1, uint32_t color2, uint8_t interval, bool beatOn){
ActivePattern = COLOR_SWITCH;
if (beatOn) {
Interval = interval/(numPixels()/2);
}
else {
Interval = interval;
}
TotalSteps = numPixels();
Color1 = color1;
Color2 = color2;
Index = 0;
//Direction = dir;
}
void ColorSwitchUpdate(){
if(Index == 0){
}
else if(Index < TotalSteps/2){
setPixelColor(Index, Color1);
setPixelColor(TotalSteps-Index, Color1);
}
else{
setPixelColor(Index, Color2);
setPixelColor(TotalSteps-Index, Color2);
}
show();
Increment();
}
//-------------------- Random Fill -----------------------------------------
void RandomFill(uint32_t color1, int interval) {
TotalSteps = numPixels();
Index = 0;
ActivePattern = RANDOM_FILL;
Interval = interval;
Color1 = color1;
i = 0; // A random pixel to update
}
// Update the Random Pixels pattern
void RandomFillUpdate() {
if (Index == 0) {
CleanPixels();
}
else {
while (true) {
i = random(numPixels()-1);
if (getPixelColor(i) == 0) {
setPixelColor(i, Wheel(((i * 256 / numPixels()) + Index) & 255));
break;
}
}
}
show();
Increment();
}
//-------------------- Random Fill Boring -----------------------------------------
void RandomFillBoring(uint32_t color1, int interval) {
TotalSteps = numPixels();
Index = 0;
ActivePattern = RANDOM_FILL_BORING;
Interval = interval;
Color1 = color1;
i = 0; // A random pixel to update
}
// Update the Random Pixels pattern
void RandomFillBoringUpdate() {
if (Index == 0) {
CleanPixels();
}
else {
while (true) {
i = random(numPixels()-1);
if (getPixelColor(i) == 0) {
setPixelColor(i, Color1);
break;
}
}
}
show();
Increment();
}
//-------------------- BlockPlacer Boring-----------------------------------------
void BlockPlacerBoring(uint32_t color1, uint32_t color2, int interval){
TotalSteps = numPixels()+1;
Index = 0;
ActivePattern = BLOCK_PLACER_BORING;
Interval = interval;
Color1 = color1;
Color2 = color2;
Counter2 = numPixels(); //keeps track of how many pixels on bottom
Counter = 0; //keeps track of how many pixels on top
i = 0; //keeps track of whether blocks are going up or down
}
void BlockPlacerBoringUpdate(){
if(Counter2 == numPixels()/2){
CleanPixels();
Counter2 = numPixels(); //keeps track of how many pixels on bottom
Counter = 0; //keeps track of how many pixels on top
i = 0; //keeps track of whether blocks are going up or down
Index = TotalSteps-1;
}
else{
if(i==0){ //blocks going down
if(Index+Counter != Counter2){
setPixelColor(Counter+Index, Color1);
setPixelColor(Counter+Index-1, 0);
for(int j=0; j<Counter; j++){
setPixelColor(j, Color1);
}
}
else{
i = 1;
Counter2--;
Index=0;
}
}
if(i==1){ //blocks going up
if(Counter2-Index != Counter){
setPixelColor(Counter2-Index, Color1);
setPixelColor(Counter2-Index+1, 0);
for(int j=Counter2; j<numPixels(); j++){
setPixelColor(j, Color1);
}
}
else{
i = 0;
Counter++;
Index=0;
}
}
}
show();
Increment();
}
//-------------------- BlockPlacer -----------------------------------------
void BlockPlacer(uint32_t color1, uint32_t color2, int interval){
TotalSteps = numPixels()+1;
Index = 0;
ActivePattern = BLOCK_PLACER;
Interval = interval;
Color1 = color1;
Color2 = color2;
Counter2 = numPixels(); //keeps track of how many pixels on bottom
Counter = 0; //keeps track of how many pixels on top
i = 0; //keeps track of whether blocks are going up or down
}
void BlockPlacerUpdate(){
if(Counter2 == numPixels()/2){
CleanPixels();
Counter2 = numPixels(); //keeps track of how many pixels on bottom
Counter = 0; //keeps track of how many pixels on top
i = 0; //keeps track of whether blocks are going up or down
Index = TotalSteps-1;
}
else{
if(i==0){ //blocks going down
if(Index+Counter != Counter2){
setPixelColor(Counter+Index, Wheel(((i * 256 / numPixels()) + Index) & 255));
setPixelColor(Counter+Index-1, 0);
for(int j=0; j<Counter; j++){
setPixelColor(j, Wheel(((i * 256 / numPixels()) + Index) & 255));
}
}
else{
i = 1;
Counter2--;
Index=0;
}
}
if(i==1){ //blocks going up
if(Counter2-Index != Counter){
setPixelColor(Counter2-Index, Wheel(((i * 256 / numPixels()) + Index) & 255));
setPixelColor(Counter2-Index+1, 0);
for(int j=Counter2; j<numPixels(); j++){
setPixelColor(j, Wheel(((i * 256 / numPixels()) + Index) & 255));
}
}
else{
i = 0;
Counter++;
Index=0;
}
}
}
show();
Increment();
}
//-------------------- SpeedChange -----------------------------------------
void SpeedChange(uint32_t color1, uint32_t color2, int interval){
TotalSteps = numPixels()+1;
Index = 0;
ActivePattern = SPEED_CHANGE;
Interval = interval;
Color1 = color1;
Color2 = color2;
Counter = numPixels();
Counter2 = 0;
}
void SpeedChangeUpdate(){
// setPixelColor(1, Color1);
if(Index == Counter){
for(int j = 0; j < Counter2; j++){
setPixelColor(j, Color1);
}
Counter2++;
Index = 0;
Counter--;
}
show();
Increment();
}
//-------------------- ------------------------
// Returns the Red component of a 32-bit color
uint8_t Red(uint32_t color)
{
return (color >> 16) & 0xFF;
}
// Returns the Green component of a 32-bit color
uint8_t Green(uint32_t color)
{
return (color >> 8) & 0xFF;
}
// Returns the Blue component of a 32-bit color
uint8_t Blue(uint32_t color)
{
return color & 0xFF;
}
// Return color, dimmed by 75% (used by scanner)
uint32_t DimColor(uint32_t color)
{
uint32_t dimColor = Color(Red(color) >> 1, Green(color) >> 1, Blue(color) >> 1);
return dimColor;
}
uint32_t DimColorMore(uint32_t color)
{
uint32_t dimColor = Color(Red(color)/4, Green(color)/4, Blue(color)/4);
return dimColor;
}
uint32_t DimColorMost(uint32_t color)
{
uint32_t dimColor = Color(Red(color)/9, Green(color)/9, Blue(color)/9);
return dimColor;
}
// uint32_t DimControl(uint32_t color, int i) //MIGHT NEED THIS?------------------------------------------
// {
// uint32_t dimColor = Color(Red(color)/i, Green(color)/i, Blue(color)/i);
// return dimColor;
// }
uint32_t DimControl(uint32_t color, int dimBright)
{
uint32_t dimColor;
// uint32_t redColor = Red(color);
// uint32_t greenColor = Green(color);
// uint32_t blueColor = Blue(color);
// if(i==0) {
// dimColor = Color(0, 0, 0);
// }
// else {
// redColor = redColor - i; //(255-i);
// greenColor = greenColor - i; //(255-i);
// blueColor = blueColor - i; //(255-i);
// if (redColor < 0) redColor = 0;
// if (greenColor < 0) greenColor = 0;
// if (blueColor < 0) blueColor = 0;
// Serial.print("dimBright: ");
// Serial.println(dimBright);
//dimColor = Color(Red(color)/i, Green(color)/i, Blue(color)/i);
// dimColor = Color(pgm_read_byte(&Gamma[dimBright*(Red(color))/255]), pgm_read_byte(&Gamma[dimBright*(Green(color))/255]), pgm_read_byte(&Gamma[dimBright*(Blue(color))/255]));
dimColor = Color(dimBright*(Red(color))/255, dimBright*(Green(color))/255, dimBright*(Blue(color))/255);
// }
return dimColor;
}
// Input a value 0 to 255 to get a color value.
// The colours are a transition r - g - b - back to r.
uint32_t Wheel(byte WheelPos)
{
WheelPos = 255 - WheelPos;
if(WheelPos < 85)
{
return Color(pgm_read_byte(&Gamma[255 - WheelPos * 3]), 0, pgm_read_byte(&Gamma[WheelPos * 3]));
}
else if(WheelPos < 170)
{
WheelPos -= 85;
return Color(0, pgm_read_byte(&Gamma[WheelPos * 3]), pgm_read_byte(&Gamma[255 - WheelPos * 3]));
}
else
{
WheelPos -= 170;
return Color(pgm_read_byte(&Gamma[WheelPos * 3]), pgm_read_byte(&Gamma[255 - WheelPos * 3]), 0);
}
}
// Reverse direction of the pattern
void Reverse()
{
if (Direction == FORWARD)
{
Direction = REVERSE;
Index = TotalSteps-1;
}
else
{
Direction = FORWARD;
Index = 0;
}
}
// Set all pixels to a color (synchronously)
void ColorSet(uint32_t color)
{
for (int i = 0; i < numPixels(); i++)
{
setPixelColor(i, color);
}
show();
}
void CleanPixels()
{
for (int i = 0; i < numPixels(); i++)
{
setPixelColor(i, 0);
}
show();
}
};
///////////////////// end of NeoPattern class ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int buttonPattern = 7; //button #1 for pattern cycling
int buttonBrightness = 8; //button #2 for brightness
int buttonBank = 9; //button #3 for changing pattern bank
int SAMPLE_RATE_HZ = 5000; // Sample rate of the audio in hertz.
int FREQUENCY_HIGH = 2000; // upper frequency bound for FFT analysis; set to focus on just bass
float windowSize = 50; //frequency window size in Hz (to divide the spectrum up)
float SPECTRUM_MIN_DB = 60.0; // Audio intensity (in decibels) that maps to low LED brightness.
float SPECTRUM_MAX_DB = 100.0; // Audio intensity (in decibels) that maps to high LED brightness.
volatile int patternNumber = 1; // keeps track of pattern
volatile int bankNumber = 1; //keeps track of both buttons being pressed
//volatile int brightnessNumber = 0; //keeps track of brightness level
volatile int brightnessNumber = 255;
volatile int colorLock = 0;
//variables to keep track of the timing of recent interrupts
unsigned long button_time_pattern = 0;
unsigned long last_button_time_pattern = 0;
unsigned long button_time_brightness = 0;
unsigned long last_button_time_brightness = 0;
unsigned long button_time_bank = 0;
unsigned long last_button_time_bank = 0;
int debounceTime = 250; //in milliseconds
const int FFT_SIZE = 256; // Size of the FFT. Realistically can only be at most 256
// without running out of memory for buffers and other state.
const int AUDIO_INPUT_PIN = 14; // Input ADC pin for audio data.
const int ANALOG_READ_RESOLUTION = 10; // Bits of resolution for the ADC.
const int ANALOG_READ_AVERAGING = 16; // Number of samples to average with each ADC reading.
const int POWER_LED_PIN = 13; // Output pin for power LED (pin 13 to use Teensy 3.0's onboard LED).
const int NEO_PIXEL_PIN = 3; // Output pin for neo pixels.
const int NEO_PIXEL_COUNT = 53; // Number of neo pixels. You should be able to increase this without
const int MAX_CHARS = 65; // Max size of the input command buffer
const int FREQ_WINDOW_LEN = (FREQUENCY_HIGH/2) / windowSize;
void pixelsComplete();
IntervalTimer samplingTimer;
float samples[FFT_SIZE*2];
float magnitudes[FFT_SIZE];
int sampleCounter = 0;
char commandBuffer[MAX_CHARS];
//float frequencyWindow[NEO_PIXEL_COUNT+1];
float frequencyWindow[21];
float hues[NEO_PIXEL_COUNT];
//StackArray <int> stack;
int beatHistory[100];
int beatPointer = 0;
//float calcIntervalHistory[64]; // create an array for recorded intervals
float calcInterval = 0;
float calcIntervalTimer = 0;
RunningAverage myRA(8);
RunningAverage beatRA(2);
float averageRA = 0;
float averageBeatRA = 0;
float beatInterval = 400;
NeoPatterns pixels(NEO_PIXEL_COUNT, NEO_PIXEL_PIN, NEO_GRB + NEO_KHZ800, &pixelsComplete);
//Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NEO_PIXEL_COUNT, NEO_PIXEL_PIN, NEO_GRB + NEO_KHZ800);
#define push(d) beatHistory[beatPointer++] = d
#define pop beatHistory[--beatPointer]
#define topofstack beatHistory[beatPointer - 1]
int wait = 80;
////////////// Change these accordingly //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int numberBanks = 3; //set this to the number of banks
int numberBrightnessLevels = 5; //set this to number of bightness levels
int numberPatterns1 = 9;
int numberPatterns2 = 13;
int numberPatterns3 = 15;
int brightnessLevels[] = {255, 127, 64, 5, 2, 0}; //Set to maximum brightness
bool randomPattern = false;
int numPatterns[] = {numberPatterns1, numberPatterns2, numberPatterns3 };
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void setup() {
// Serial.begin(38400); //turn on serial communication
myRA.clear(); // start with a clean average array
beatRA.clear();
//pin setups
pinMode(7, INPUT_PULLUP); //define pin 7 as input
pinMode(8, INPUT_PULLUP); //define pin 8 as input
pinMode(9, INPUT_PULLUP); //define pin 9 as input
// Set up ADC and audio input.
pinMode(AUDIO_INPUT_PIN, INPUT);
analogReadResolution(ANALOG_READ_RESOLUTION);
analogReadAveraging(ANALOG_READ_AVERAGING);
// Turn on the power indicator LED.
pinMode(POWER_LED_PIN, OUTPUT);
digitalWrite(POWER_LED_PIN, HIGH);
pixels.begin(); //start NeoPattern class
pixels.setBrightness(brightnessNumber);
pixels.show();
pixels.RandomPixels(30, 500);
// Clear the input command buffer
memset(commandBuffer, 0, sizeof(commandBuffer));
// Initialize spectrum display
spectrumSetup();
// Begin sampling audio
samplingBegin();
}
void loop() {
pixels.Update();
if (bankNumber == 3) {
// Calculate FFT if a full sample is available.
if (samplingIsDone()) {
// Run FFT on sample data.
arm_cfft_radix4_instance_f32 fft_inst;
arm_cfft_radix4_init_f32(&fft_inst, FFT_SIZE, 0, 1);
arm_cfft_radix4_f32(&fft_inst, samples);
// Calculate magnitude of complex numbers output by the FFT.
arm_cmplx_mag_f32(samples, magnitudes, FFT_SIZE);
// check the spectrum and write to the pixels if necessary
spectrumLoop();
// Restart audio sampling.
samplingBegin();
}
}
if (digitalRead(7) == LOW) {
randomPattern = false;
patternControl();
bankChoice();
}
if (digitalRead(8) == LOW) {
brightnessControl();
pixels.setBrightness(brightnessLevels[brightnessNumber]);
}
if (digitalRead(9) == LOW) {
bankControl();
patternControl();
bankChoice();
}
}
void pixelsComplete() {
// if (bankNumber == 3) {
// if (patternNumber == 4 || patternNumber == 7 || patternNumber == 8 || patternNumber == 13 || patternNumber == 14) {
// pixels.Interval = beatInterval/(pixels.numPixels()/2);
// }
// else {
// pixels.Interval = beatInterval/(pixels.numPixels());
// }
// }
if (colorLock == 0) {
pixels.Color1 = pixels.Wheel(random(255));
pixels.Color2 = pixels.Wheel(random(255));
pixels.Update();
}
if (randomPattern) {
patternNumber = random(1, numPatterns[bankNumber-1]);
// Serial.println(patternNumber);
bankChoice();
}
else {
pixels.Update();
}
}
////////////////////////////////////////////////////////////////////////////////
// UTILITY FUNCTIONS
////////////////////////////////////////////////////////////////////////////////
// Compute the average magnitude of a target frequency window vs. all other frequencies.
void windowMean(float* magnitudes, int lowBin, int highBin, float* windowMean, float* otherMean) {
*windowMean = 0;
*otherMean = 0;
// Notice the first magnitude bin is skipped because it represents the
// average power of the signal.
for (int i = 1; i < FFT_SIZE/2; ++i) {
if (i >= lowBin && i <= highBin) {
*windowMean += magnitudes[i];
}
else {
*otherMean += magnitudes[i];
}
}
*windowMean /= (highBin - lowBin) + 1;
*otherMean /= (FFT_SIZE / 2 - (highBin - lowBin));
}
// Convert a frequency to the appropriate FFT bin it will fall within.
int frequencyToBin(float frequency) {
float binFrequency = float(SAMPLE_RATE_HZ) / float(FFT_SIZE);
return int(frequency / binFrequency);
}
////////////////////////////////////////////////////////////////////////////////
// SPECTRUM DISPLAY FUNCTIONS
///////////////////////////////////////////////////////////////////////////////
void spectrumSetup() {
// Set the frequency window values by evenly dividing the possible frequency
// spectrum across the number of neo pixels.
//float windowSize = (FREQUENCY_HIGH / 2.0) / float(NEO_PIXEL_COUNT);
for (int i = 0; i < ((FREQUENCY_HIGH/2.0) / windowSize)+1; ++i) {
frequencyWindow[i] = i*windowSize;
}
// Evenly spread hues across all pixels.
for (int i = 0; i < NEO_PIXEL_COUNT; ++i) {
hues[i] = 360.0*(float(i)/float(NEO_PIXEL_COUNT-1));
}
}
void spectrumLoop() {
//check the intensity and write to the pixels if a beat is detected
float intensity, otherMean;
for (int i = 0; i < ((FREQUENCY_HIGH/2.0) / windowSize)+1; ++i) {
windowMean(magnitudes,
frequencyToBin(frequencyWindow[i]),
frequencyToBin(frequencyWindow[i+1]),
&intensity,
&otherMean);
// Convert intensity to decibels.
intensity = 20.0*log10(intensity);
// Scale the intensity and clamp between 0 and 1.0.
intensity -= SPECTRUM_MIN_DB;
intensity = intensity < 0.0 ? 0.0 : intensity;
intensity /= (SPECTRUM_MAX_DB-SPECTRUM_MIN_DB);
intensity = intensity > 1.0 ? 1.0 : intensity;
if (i == 1) { // check the 50-100 Hz frequency bin
byte arrayLen = sizeof(beatHistory) / sizeof(beatHistory[0]);
for (byte i=arrayLen - 1; i > 0; i--) {
beatHistory[i] = beatHistory[i-1];
}
if (intensity > 0.3) { // if a beat was detected
beatHistory[0] = 1; //1 = beat; 0 = not beat
beatPointer++;
// check if the previous sample was also detected as a beat
if (beatHistory[1] == 1) {
}
// check if two samples ago was also detected as a beat
else if (beatHistory[2] == 1) {
}
else {
calcInterval = millis();
beatRA.addValue(calcInterval - calcIntervalTimer);
averageBeatRA = beatRA.getAverage();
if (averageBeatRA > 550) {
myRA.addValue(550);
}
else if (averageBeatRA < 400) {
myRA.addValue(400);
}
else {
// Serial.print("Average Beat RA: ");
// Serial.println(averageBeatRA);
myRA.addValue(averageBeatRA);
}
//myRA.addValue(calcInterval - calcIntervalTimer);
averageRA = myRA.getAverage();
// Serial.print("Average RA: ");
// Serial.println(averageRA);
beatInterval = averageRA;
}
calcIntervalTimer = calcInterval;
}
else {
beatHistory[0] = 0;
beatPointer++;
}
if (beatPointer == 100) {
beatPointer = 0;
}
}
}
}
////////////////////////////////////////////////////////////////////////////////
//// PATTERN CALLS
///////////////////////////////////////////////////////////////////////////////
void patternChoiceBank1() { // chill patterns, not beat responsive
int c1 = random(255);
int c2 = c1/2;
pixels.Index = 0;
pixels.CleanPixels();
switch(patternNumber) {
case 1:
pixels.RainbowCycle(40);
break;
case 2:
pixels.ColorRain(pixels.Wheel(255), pixels.Wheel(255), 40);
break;
case 3:
pixels.ColorRain(pixels.Wheel(70), pixels.Wheel(70), 40);
break;
case 4:
pixels.ColorRain(pixels.Wheel(170), pixels.Wheel(170), 40);
break;
case 5:
pixels.ColorRain(pixels.Wheel(random(255)), pixels.Wheel(random(255)), 40);
break;
case 6:
pixels.BreatheColor(pixels.Wheel(random(255)), 5);
break;
case 7:
pixels.BreatheColorRandom(pixels.Wheel(random(255)), pixels.Wheel(random(255)), 5);
break;
case 8:
pixels.Fade(pixels.Wheel(c1), pixels.Wheel(c2), 100, 100);
break;
case 9:
randomPattern = true;
pixels.Update();
break;
}
}
//
void patternChoiceBank2() {
pixels.CleanPixels();
pixels.Index = 0;
switch(patternNumber) {
case 1:
pixels.TheaterChase(pixels.Wheel(random(255)), pixels.Wheel(random(255)), 150, false);
break;
case 2:
pixels.BlockPlacerBoring(pixels.Wheel(random(255)), pixels.Wheel(random(255)), 30);
break;
case 3:
pixels.BlockPlacer(pixels.Wheel(random(255)), pixels.Wheel(random(255)), 30);
break;
case 4:
pixels.BlockDropBoring(pixels.Wheel(random(255)), 70);
break;
case 5:
pixels.BlockDrop(pixels.Wheel(random(255)), 70);
break;
case 6:
pixels.ScannerBoring(pixels.Wheel(random(255)), 40, false);
break;
case 7:
pixels.Scanner(pixels.Wheel(random(255)), 40, false);
break;
case 8:
pixels.ColorWipe(pixels.Wheel(random(255)), pixels.Wheel(random(255)), 40, false);
break;
case 9:
pixels.ColorSwitch(pixels.Wheel(random(255)), pixels.Wheel(random(255)), 40, false);
break;
case 10:
pixels.RandomFill(pixels.Wheel(random(255)), 70);
break;
case 11:
pixels.ScrollMiddleTwoColor(pixels.Wheel(random(255)), pixels.Wheel(random(255)), random(50, 70), false);
break;
case 12:
pixels.ScrollEndsTwoColor(pixels.Wheel(random(255)), pixels.Wheel(random(255)), random(50, 70), false);
break;
case 13:
randomPattern = true;
pixels.Update();
break;
}
}
void patternChoiceBank3() { // beat reactive patterns
pixels.CleanPixels();
pixels.Index = 0;
switch(patternNumber) {
case 1:
pixels.Scanner(pixels.Wheel(random(255)), 20, false);
break;
case 2:
pixels.TheaterChase(pixels.Wheel(random(255)), pixels.Wheel(random(255)), 70, false);
break;
case 3:
pixels.BlockPlacerBoring(pixels.Wheel(random(255)), pixels.Wheel(random(255)), 5);
break;
case 4:
pixels.BlockPlacer(pixels.Wheel(random(255)), pixels.Wheel(random(255)), 7);
break;
case 5:
pixels.BlockDropBoring(pixels.Wheel(random(255)), 15);
break;
case 6:
pixels.BlockDrop(pixels.Wheel(random(255)), 15);
break;
case 7:
pixels.ColorWipe(pixels.Wheel(random(255)), pixels.Wheel(random(255)), 20, false);
break;
case 8:
pixels.ColorSwitch(pixels.Wheel(random(255)), pixels.Wheel(random(255)), 20, false);
break;
case 9:
pixels.RandomFill(pixels.Wheel(random(255)), 30);
break;
case 10:
pixels.ScrollMiddleTwoColor(pixels.Wheel(random(255)), pixels.Wheel(random(255)), 30, false);
break;
case 11:
pixels.ScrollEndsTwoColor(pixels.Wheel(random(255)), pixels.Wheel(random(255)), 30, false);
break;
case 12:
randomPattern = true;
pixels.Update();
break;
}
}
void bankChoice() {
switch(bankNumber) {
case 1: colorLock = 1;
patternChoiceBank1();
break;
case 2: colorLock = 0;
patternChoiceBank2();
break;
case 3: colorLock = 0;
patternChoiceBank3();
break;
}
}
////////////////////////////////////////////////////////////////////////////////
//// INTERRUPT SERVICE ROUTINES
///////////////////////////////////////////////////////////////////////////////
////Pattern button interrupt
void patternControl() {
button_time_pattern = millis();
if (button_time_pattern - last_button_time_pattern > debounceTime) //check to see if ISR was called in the last 250 milliseconds
{
switch(bankNumber) { //add cases for each bank added
case 1:
if (patternNumber < numberPatterns1) {
patternNumber++;
}
else {
patternNumber = 1;
}
break;
case 2:
if (patternNumber < numberPatterns2) {
patternNumber++;
}
else {
patternNumber = 1;
}
break;
case 3:
if (patternNumber < numberPatterns3) {
patternNumber++;
}
else {
patternNumber = 1;
}
break;
}
last_button_time_pattern = button_time_pattern;
}
}
//brightness button interrupt
void brightnessControl() {
button_time_brightness = millis();
if (button_time_brightness - last_button_time_brightness > debounceTime)
{
if (brightnessNumber < numberBrightnessLevels) {
brightnessNumber++;
}
else {
brightnessNumber = 0;
}
EEPROM.write(0, brightnessNumber);
last_button_time_brightness = button_time_brightness;
}
}
//pattern bank button interrupt
void bankControl() {
button_time_bank = millis();
if (button_time_bank - last_button_time_bank > debounceTime)
{
if (bankNumber < numberBanks) {
bankNumber++;
}
else {
bankNumber = 1;
}
last_button_time_bank = button_time_bank;
patternNumber = 0;
}
}
////////////////////////////////////////////////////////////////////////////////
// SAMPLING FUNCTIONS
////////////////////////////////////////////////////////////////////////////////
void samplingCallback() {
// Read from the ADC and store the sample data
samples[sampleCounter] = (float32_t)analogRead(AUDIO_INPUT_PIN);
// Complex FFT functions require a coefficient for the imaginary part of the input.
// Since we only have real data, set this coefficient to zero.
samples[sampleCounter+1] = 0.0;
// Update sample buffer position and stop after the buffer is filled
sampleCounter += 2;
if (sampleCounter >= FFT_SIZE*2) {
samplingTimer.end();
}
}
void samplingBegin() {
// Reset sample buffer position and start callback at necessary rate.
sampleCounter = 0;
samplingTimer.begin(samplingCallback, 1000000/SAMPLE_RATE_HZ);
}
boolean samplingIsDone() {
return sampleCounter >= FFT_SIZE*2;
}
| [
"rgmuna@gmail.com"
] | rgmuna@gmail.com |
707e76a59b22d763d5e7ee7ebbbcf88a2476888c | be2ce08e46f936b8c7afc0dc4f0c6be8d8f72043 | /src/PolyTester.cpp | 3b46ca7e68f541642e784bac2a7ec9dc78d65c05 | [] | no_license | MarcosJLR/ArtNN | 9939d70a0435404a7b02f96d49096a4196fe37fd | 1a0cc0a5f168246bb1e3e9f77cc073dde13615be | refs/heads/master | 2022-11-17T14:57:38.476925 | 2020-07-06T12:35:24 | 2020-07-06T12:35:24 | 274,688,173 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,295 | cpp | #include <iostream>
#include "CSVReader.hpp"
#include "Interpolator.hpp"
void storeData(std::vector<std::pair<double, double>>& finalData,
std::vector<std::vector<std::string>> rawData)
{
finalData.clear();
for(auto& line : rawData)
{
finalData.push_back({std::stod(line[0]), std::stod(line[1])});
}
}
int main(int argc, char* argv[])
{
if(argc != 2)
{
std::cout << "Usage: ./PolyTester <data_csv>\n";
return 0;
}
std::string dataFilename = argv[1];
artnn::CSVReader dataReader(dataFilename);
std::vector<std::pair<double, double>> data;
std::vector<double> dataX;
std::cout << "Reading data..\n";
storeData(data, dataReader.getData());
for(auto& [x, y] : data)
{
dataX.push_back(x);
}
artnn::Interpolator<double> interpol0(3, 0.001);
artnn::Interpolator<double> interpol1(4, 0.001);
artnn::Interpolator<double> interpol2(5, 0.001);
artnn::Interpolator<double> interpol3(3, 0.0001);
artnn::Interpolator<double> interpol4(4, 0.0001);
artnn::Interpolator<double> interpol5(5, 0.0001);
artnn::Interpolator<double> interpol6(3, 0.00001);
artnn::Interpolator<double> interpol7(4, 0.00001);
artnn::Interpolator<double> interpol8(5, 0.00001);
double sqError;
// Network 0
std::cout << "\nTraining Network 0 (degree = 3, etha = 0.001)\n";
sqError = interpol0.trainFull(data, 100, 0.0);
std::cout << "Error after 100 epochs: " << sqError << std::endl;
std::cout << "Plotting points...\n";
interpol0.plotPoints(dataX, "Plots/plot0-100.csv");
sqError = interpol0.trainFull(data, 900, 0.0);
std::cout << "Error after 1000 epochs: " << sqError << std::endl;
std::cout << "Plotting points...\n";
interpol0.plotPoints(dataX, "Plots/plot0-1000.csv");
sqError = interpol0.trainFull(data, 9000, 0.0);
std::cout << "Error after 10000 epochs: " << sqError << std::endl;
std::cout << "Plotting points...\n";
interpol0.plotPoints(dataX, "Plots/plot0-10000.csv");
// Network 1
std::cout << "\nTraining Network 1 (degree = 4, etha = 0.001)\n";
sqError = interpol1.trainFull(data, 100, 0.0);
std::cout << "Error after 100 epochs: " << sqError << std::endl;
std::cout << "Plotting points...\n";
interpol1.plotPoints(dataX, "Plots/plot1-100.csv");
sqError = interpol1.trainFull(data, 900, 0.0);
std::cout << "Error after 1000 epochs: " << sqError << std::endl;
std::cout << "Plotting points...\n";
interpol1.plotPoints(dataX, "Plots/plot1-1000.csv");
sqError = interpol1.trainFull(data, 9000, 0.0);
std::cout << "Error after 10000 epochs: " << sqError << std::endl;
std::cout << "Plotting points...\n";
interpol1.plotPoints(dataX, "Plots/plot1-10000.csv");
// Network 2
std::cout << "\nTraining Network 2 (degree = 5, etha = 0.001)\n";
sqError = interpol2.trainFull(data, 100, 0.0);
std::cout << "Error after 100 epochs: " << sqError << std::endl;
std::cout << "Plotting points...\n";
interpol2.plotPoints(dataX, "Plots/plot2-100.csv");
sqError = interpol2.trainFull(data, 900, 0.0);
std::cout << "Error after 1000 epochs: " << sqError << std::endl;
std::cout << "Plotting points...\n";
interpol2.plotPoints(dataX, "Plots/plot2-1000.csv");
sqError = interpol2.trainFull(data, 9000, 0.0);
std::cout << "Error after 10000 epochs: " << sqError << std::endl;
std::cout << "Plotting points...\n";
interpol2.plotPoints(dataX, "Plots/plot2-10000.csv");
// Network 3
std::cout << "\nTraining Network 3 (degree = 3, etha = 0.0001)\n";
sqError = interpol3.trainFull(data, 100, 0.0);
std::cout << "Error after 100 epochs: " << sqError << std::endl;
std::cout << "Plotting points...\n";
interpol3.plotPoints(dataX, "Plots/plot3-100.csv");
sqError = interpol3.trainFull(data, 900, 0.0);
std::cout << "Error after 1000 epochs: " << sqError << std::endl;
std::cout << "Plotting points...\n";
interpol3.plotPoints(dataX, "Plots/plot3-1000.csv");
sqError = interpol3.trainFull(data, 9000, 0.0);
std::cout << "Error after 10000 epochs: " << sqError << std::endl;
std::cout << "Plotting points...\n";
interpol3.plotPoints(dataX, "Plots/plot3-10000.csv");
// Network 4
std::cout << "\nTraining Network 4 (degree = 4, etha = 0.0001)\n";
sqError = interpol4.trainFull(data, 100, 0.0);
std::cout << "Error after 100 epochs: " << sqError << std::endl;
std::cout << "Plotting points...\n";
interpol4.plotPoints(dataX, "Plots/plot4-100.csv");
sqError = interpol4.trainFull(data, 900, 0.0);
std::cout << "Error after 1000 epochs: " << sqError << std::endl;
std::cout << "Plotting points...\n";
interpol4.plotPoints(dataX, "Plots/plot4-1000.csv");
sqError = interpol4.trainFull(data, 9000, 0.0);
std::cout << "Error after 10000 epochs: " << sqError << std::endl;
std::cout << "Plotting points...\n";
interpol4.plotPoints(dataX, "Plots/plot4-10000.csv");
// Network 5
std::cout << "\nTraining Network 5 (degree = 5, etha = 0.0001)\n";
sqError = interpol5.trainFull(data, 100, 0.0);
std::cout << "Error after 100 epochs: " << sqError << std::endl;
std::cout << "Plotting points...\n";
interpol5.plotPoints(dataX, "Plots/plot5-100.csv");
sqError = interpol5.trainFull(data, 900, 0.0);
std::cout << "Error after 1000 epochs: " << sqError << std::endl;
std::cout << "Plotting points...\n";
interpol5.plotPoints(dataX, "Plots/plot5-1000.csv");
sqError = interpol5.trainFull(data, 9000, 0.0);
std::cout << "Error after 10000 epochs: " << sqError << std::endl;
std::cout << "Plotting points...\n";
interpol5.plotPoints(dataX, "Plots/plot5-10000.csv");
// Network 6
std::cout << "\nTraining Network 6 (degree = 3, etha = 0.00001)\n";
sqError = interpol6.trainFull(data, 100, 0.0);
std::cout << "Error after 100 epochs: " << sqError << std::endl;
std::cout << "Plotting points...\n";
interpol6.plotPoints(dataX, "Plots/plot6-100.csv");
sqError = interpol6.trainFull(data, 900, 0.0);
std::cout << "Error after 1000 epochs: " << sqError << std::endl;
std::cout << "Plotting points...\n";
interpol6.plotPoints(dataX, "Plots/plot6-1000.csv");
sqError = interpol6.trainFull(data, 9000, 0.0);
std::cout << "Error after 10000 epochs: " << sqError << std::endl;
std::cout << "Plotting points...\n";
interpol6.plotPoints(dataX, "Plots/plot6-10000.csv");
// Network 7
std::cout << "\nTraining Network 7 (degree = 4, etha = 0.00001)\n";
sqError = interpol7.trainFull(data, 100, 0.0);
std::cout << "Error after 100 epochs: " << sqError << std::endl;
std::cout << "Plotting points...\n";
interpol7.plotPoints(dataX, "Plots/plot7-100.csv");
sqError = interpol7.trainFull(data, 900, 0.0);
std::cout << "Error after 1000 epochs: " << sqError << std::endl;
std::cout << "Plotting points...\n";
interpol7.plotPoints(dataX, "Plots/plot7-1000.csv");
sqError = interpol7.trainFull(data, 9000, 0.0);
std::cout << "Error after 10000 epochs: " << sqError << std::endl;
std::cout << "Plotting points...\n";
interpol7.plotPoints(dataX, "Plots/plot7-10000.csv");
// Network 8
std::cout << "\nTraining Network 8 (degree = 5, etha = 0.00001)\n";
sqError = interpol8.trainFull(data, 100, 0.0);
std::cout << "Error after 100 epochs: " << sqError << std::endl;
std::cout << "Plotting points...\n";
interpol8.plotPoints(dataX, "Plots/plot8-100.csv");
sqError = interpol8.trainFull(data, 900, 0.0);
std::cout << "Error after 1000 epochs: " << sqError << std::endl;
std::cout << "Plotting points...\n";
interpol8.plotPoints(dataX, "Plots/plot8-1000.csv");
sqError = interpol8.trainFull(data, 9000, 0.0);
std::cout << "Error after 10000 epochs: " << sqError << std::endl;
std::cout << "Plotting points...\n";
interpol8.plotPoints(dataX, "Plots/plot8-10000.csv");
}
| [
"socram.693@gmail.com"
] | socram.693@gmail.com |
1d81d82925f1d8efe9d2e9834a1f8ad61eb1acaa | 4b573586f1d89ed1fe2e8e1cb1746134907aa510 | /lab6/CPoint.h | 714a39a0effec828b8810b647a66087fd68074d5 | [] | no_license | papkovalexei/lab | 3ba8bd8a0e2f84483261bca2952d602bab487c0a | ce67600030fae9f83f6f4a11d4e14eeeca9be545 | refs/heads/master | 2022-07-25T12:24:45.411240 | 2020-05-06T17:20:18 | 2020-05-06T17:20:18 | 248,800,565 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 226 | h | #pragma once
class CPoint
{
public:
CPoint() {}
CPoint(float x, float y) : x_(x), y_(y) {}
const float& x() const;
const float& y() const;
bool operator==(const CPoint& value) const;
private:
float x_;
float y_;
};
| [
"steam07151@gmail.com"
] | steam07151@gmail.com |
dcc728ab7c5cec469cfeb9415eced9156f329fd2 | ff79b2b0b400fbafae424ec22dc1b715e673c2e1 | /ContinuousHTMGPU/source/Main.cpp | 28101506f86328c2dfd8303a693c519315acb852 | [
"Zlib",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | plexzhang/ContinuousHTMGPU | 044c7ae828642191838fb263e055bd52df37b315 | e0f86e189e24af276e0161d18261c7a6ceb4ec0d | refs/heads/master | 2021-01-21T18:43:21.858611 | 2014-10-24T23:37:27 | 2014-10-24T23:37:27 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,736 | cpp | #include <cae/ConvAutoEncoder.h>
#include <htm/HTMRL.h>
#include <SFML/Window.hpp>
#include <SFML/Graphics.hpp>
#include <time.h>
int main() {
std::mt19937 generator(time(nullptr));
sys::ComputeSystem cs;
cs.create(sys::ComputeSystem::_gpu);
sys::ComputeProgram program;
program.loadFromFile("resources/htmrl.cl", cs);
htm::HTMRL htmrl;
std::vector<htm::HTMRL::LayerDesc> layerDescs(1);
layerDescs[0]._width = 64;
layerDescs[0]._height = 64;
//layerDescs[1]._width = 64;
//layerDescs[1]._height = 64;
//layerDescs[2]._width = 64;
//layerDescs[2]._height = 64;
htmrl.createRandom(cs, program, 64, 64, layerDescs, -0.1f, 0.1f, generator);
/*htm::HTMFeatureExtractor fExt;
std::vector<htm::HTMFeatureExtractor::LayerDesc> layerDescs(3);
layerDescs[0]._width = 128;
layerDescs[0]._height = 128;
layerDescs[0]._receptiveFieldRadius = 2;
layerDescs[1]._width = 64;
layerDescs[1]._height = 64;
layerDescs[1]._receptiveFieldRadius = 2;
layerDescs[2]._width = 32;
layerDescs[2]._height = 32;
layerDescs[2]._receptiveFieldRadius = 2;*/
float t = 0;
float dotRadius = 16.0f;
bool quit = false;
sf::Clock clock;
sf::RenderWindow window;
window.create(sf::VideoMode(512, 512), "HTM", sf::Style::Default);
//window.setFramerateLimit(60);
do {
clock.restart();
// ----------------------------- Input -----------------------------
sf::Event windowEvent;
while (window.pollEvent(windowEvent)) {
switch (windowEvent.type) {
case sf::Event::Closed:
quit = true;
break;
}
}
if (sf::Keyboard::isKeyPressed(sf::Keyboard::Escape))
quit = true;
if (sf::Keyboard::isKeyPressed(sf::Keyboard::P)) {
// Save cell data
htmrl.exportCellData(cs, "data");
}
float dotX = 32.0f;// std::cos(t * 4.0f) * 15.0f + 64.0f;
float dotY = 32.0f;
for (int x = 0; x < 64; x++)
for (int y = 0; y < 64; y++) {
//float r = inImage.getPixel(x, y).r / 255.0f;
//float g = inImage.getPixel(x, y).g / 255.0f;
//float b = inImage.getPixel(x, y).b / 255.0f;
float dist = std::sqrt(static_cast<float>(std::pow(dotX - x, 2) + std::pow(dotY - y, 2)));
float greyScale = std::max<float>(0.0f, std::min<float>(1.0f, (dotRadius - dist) / dotRadius)) * (std::cos(t) + 0.5f + 0.5f);
htmrl.setInput(x, y, greyScale);
}
if (!sf::Keyboard::isKeyPressed(sf::Keyboard::L)) {
for (int i = 0; i < 1; i++)
htmrl.step(cs, 0.05f, 0.05f);
t += 0.05f;
if (t > 6.28f)
t = 0.0f;
}
sf::Image outImage;
outImage.create(htmrl.getLayerDescs().back()._width, htmrl.getLayerDescs().back()._height);
if (sf::Keyboard::isKeyPressed(sf::Keyboard::O)) {
for (int x = 0; x < htmrl.getLayerDescs().back()._width; x++)
for (int y = 0; y < htmrl.getLayerDescs().back()._height; y++) {
float outputR = htmrl.getPrediction(x, y);
outImage.setPixel(x, y, sf::Color(outputR * 255.0f, outputR * 255.0f, outputR * 255.0f, 255));
}
}
else {
for (int x = 0; x < htmrl.getLayerDescs().back()._width; x++)
for (int y = 0; y < htmrl.getLayerDescs().back()._height; y++) {
float outputR = htmrl.getSDR(x, y);
outImage.setPixel(x, y, sf::Color(outputR * 255.0f, outputR * 255.0f, outputR * 255.0f, 255));
}
}
//outImage.saveToFile("out.png");
window.clear();
sf::Texture texture;
texture.loadFromImage(outImage);
sf::Sprite sprite;
sprite.setTexture(texture);
sprite.setScale(512.0f / htmrl.getLayerDescs().back()._width, 512.0f / htmrl.getLayerDescs().back()._height);
window.draw(sprite);
window.display();
} while (!quit);
return 0;
} | [
"eric@rocketcitystudios.com"
] | eric@rocketcitystudios.com |
aeb6869f6517a5854984b63b6c73c8be4935b2d2 | 07eb6185e024c0121d6de9fb652c60004fa334e6 | /tp1/exemple/cpp_src/main.h | 32dbb7e9b3d12a3bb10ced187efc56ca8e807f83 | [] | no_license | molamk/inf4705 | 9015badfe5376404a2b2d29e06def9ae05a028b6 | 8825f7cdffd0a928a764c7859033f84e4f04f4cf | refs/heads/master | 2020-03-28T17:51:06.589182 | 2018-11-30T18:30:22 | 2018-11-30T18:30:22 | 148,828,787 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 158 | h | #ifndef MAIN_H
#define MAIN_H
#include "conv.h"
#include "strassen.h"
#include "strassenSeuil.h"
#include "ProgramArguments.h"
using namespace std;
#endif
| [
"molamk@protonmail.com"
] | molamk@protonmail.com |
514870006bb9d627108331d974b6f7f76d447a32 | 6be960977e8e78d69b7f12fda02f60454c2b488a | /inverse.cpp | dc5a20f200d1fee0e4f03199be9cd2f539cda7f6 | [] | no_license | arul-ashri/CPP-Templates | 081b3b31cd4ef81eb0cfb13de6717f10d267bc4e | 900aa3eabf51477587eb78818737e654aaddb51d | refs/heads/master | 2023-06-11T07:50:40.130860 | 2021-07-01T04:57:29 | 2021-07-01T04:57:29 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 148 | cpp | const int MOD=1000000007;
long long int inverse(long long int i){
if(i==1) return 1;
return (MOD - ((MOD/i)*inverse(MOD%i))%MOD+MOD)%MOD;
}
| [
"noreply@github.com"
] | arul-ashri.noreply@github.com |
bdb5caeb49980ca145aca716279ba782e15b1639 | f40750f2f1aec0450af8435d8c3700f683e2b12b | /cod-up 기초 100/기초_입출력_1013.cpp | 9d0a05710331ae738f1bdb0f41196893f21c5314 | [] | no_license | kimsubin-26/Algorithm | d5d019ab7fd88dafa446b659db59349f9b4c09b5 | 817f82001a3dd48355a9abc83b0a41b7caeae9d8 | refs/heads/master | 2022-12-05T20:30:52.379497 | 2020-09-04T03:50:00 | 2020-09-04T03:50:00 | 281,414,679 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 121 | cpp | #include <iostream>
using namespace std;
int main()
{
int a, b;
cin >> a >> b;
cout << a << " " << b;
return 0;
}
| [
"noreply@github.com"
] | kimsubin-26.noreply@github.com |
718d009c669f5ab46b23827bf53576ab134ed3c1 | e6e69e8d6794f409398af2cefed7092fed4691ca | /计算机与软件学院/面向对象程序设计（荣誉）/大作业1/素材1/2018192014_1235_1.cpp | 323601bc872f518bbdaf68f67d3c47c648349d78 | [] | no_license | LKHUUU/SZU_Learning_Resource | 1faca5fcaf0431adb64da031dde4fe47abcdc6ba | 88f121f275a57fc48f395bb73377e6f6e22d7529 | refs/heads/main | 2023-08-30T06:31:24.414351 | 2021-10-22T13:53:40 | 2021-10-22T13:53:40 | null | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 1,173 | cpp | 2018192014:Problem1235:答案错误
#include<bits/stdc++.h>
using namespace std;
class Geometry{
public:
virtual double getArea()=0; //计算面积，结果保留小数点后两位
};
class Rect:virtual public Geometry{
protected:
double a,b;
public:
Rect(double a1,double b1):
a(a1),b(b1){
}
virtual double getArea(){
return a*b;
}
};
class Circle:virtual public Geometry{
protected:
double r;
public:
Circle(double r1):
r(r1){
}
virtual double getArea(){
return r*r*3.14;
}
};
class TotalArea{
public:
static void computerTotalArea(Geometry** t,int n)//t为基类二级指针，指向一个基类动态数组，数组的每个元素指向一个子类图形，n为数组的大小
{
double res;
for(int i=0;i<n;i++)
{
if(res<t[i]->getArea())
{
res=t[i]->getArea();
}
}
cout<<"最大面积="<<res<<endl;
}
};
int main ()
{
Geometry **t;
int n;
cin>>n;
t=new Geometry*[n];
for(int i=0;i<n;i++)
{
int command;
double a,b,r;
cin>>command;
if(command==1)
{
cin>>a>>b;
t[i]=new Rect(a,b);
}
else
{
cin>>r;
t[i]=new Circle(r);
}
}
TotalArea a;
a.computerTotalArea(t,n);
return 0;
}
| [
"939826879@qq.com"
] | 939826879@qq.com |
559410ffc85265bb3d5edf680f17b76ec0b51c3c | cd478fc0b137df47f80dd6f8da5300a5edec5118 | /Mars/Mars/mars.cpp | 1524d394836c206f95a62395f5df0a22c97a127c | [] | no_license | AnnyshkaF/crypt | f57a430e6810889b8e2d095f020b7246a6876e17 | 15ee63f6e32acb37dc0a9e26f8dee133f028414d | refs/heads/master | 2020-04-15T00:21:37.218528 | 2019-01-05T18:03:53 | 2019-01-05T18:03:53 | 164,237,102 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,325 | cpp | #include "mars.h"
/*
NOTE:
S0[X] and S1[X] use low 8 bits of X.
S[X] uses low 9 bits of X. S is the concatenation of S0 and S1.
// concatenation (b1 << 8) + b2
inblock/outblock is 4-bytes
initially sboxes were consists of 2 boxes with 256 values in each.
Now they are connected and 1 consists of 512 values.
That's why there is S0 and S1 in description.
*/
void Mars::Encrypt(const u4byte in_blk[4], u4byte out_blk[4])
{
u4byte a, b, c, d, l, m, r;
a = in_blk[0] + l_key[0]; b = in_blk[1] + l_key[1];
c = in_blk[2] + l_key[2]; d = in_blk[3] + l_key[3];
f_mix(a, b, c, d); a += d; //D[0] = D[0] + D[3]
f_mix(b, c, d, a); b += c; //D[0] = D[0] + D[1]
f_mix(c, d, a, b);
f_mix(d, a, b, c);
f_mix(a, b, c, d); a += d; //D[0] = D[0] + D[3]
f_mix(b, c, d, a); b += c; //D[0] = D[0] + D[1]
f_mix(c, d, a, b);
f_mix(d, a, b, c);
// f_ktr - Forward KeyTRansformation
f_ktr(a, b, c, d, 4); f_ktr(b, c, d, a, 6); f_ktr(c, d, a, b, 8); f_ktr(d, a, b, c, 10); //2*i+4 for i=0:15
f_ktr(a, b, c, d, 12); f_ktr(b, c, d, a, 14); f_ktr(c, d, a, b, 16); f_ktr(d, a, b, c, 18);
f_ktr(a, d, c, b, 20); f_ktr(b, a, d, c, 22); f_ktr(c, b, a, d, 24); f_ktr(d, c, b, a, 26);
f_ktr(a, d, c, b, 28); f_ktr(b, a, d, c, 30); f_ktr(c, b, a, d, 32); f_ktr(d, c, b, a, 34);
b_mix(a, b, c, d);
b_mix(b, c, d, a); c -= b;
b_mix(c, d, a, b); d -= a;
b_mix(d, a, b, c);
b_mix(a, b, c, d);
b_mix(b, c, d, a); c -= b;
b_mix(c, d, a, b); d -= a;
b_mix(d, a, b, c);
out_blk[0] = a - l_key[36]; out_blk[1] = b - l_key[37];
out_blk[2] = c - l_key[38]; out_blk[3] = d - l_key[39];
}
void Mars::Decrypt(const u4byte in_blk[4], u4byte out_blk[4])
{
u4byte a, b, c, d, l, m, r;
d = in_blk[0] + l_key[36]; c = in_blk[1] + l_key[37];
b = in_blk[2] + l_key[38]; a = in_blk[3] + l_key[39];
f_mix(a, b, c, d); a += d;
f_mix(b, c, d, a); b += c;
f_mix(c, d, a, b);
f_mix(d, a, b, c);
f_mix(a, b, c, d); a += d;
f_mix(b, c, d, a); b += c;
f_mix(c, d, a, b);
f_mix(d, a, b, c);
r_ktr(a, b, c, d, 34); r_ktr(b, c, d, a, 32); r_ktr(c, d, a, b, 30); r_ktr(d, a, b, c, 28);
r_ktr(a, b, c, d, 26); r_ktr(b, c, d, a, 24); r_ktr(c, d, a, b, 22); r_ktr(d, a, b, c, 20);
r_ktr(a, d, c, b, 18); r_ktr(b, a, d, c, 16); r_ktr(c, b, a, d, 14); r_ktr(d, c, b, a, 12);
r_ktr(a, d, c, b, 10); r_ktr(b, a, d, c, 8); r_ktr(c, b, a, d, 6); r_ktr(d, c, b, a, 4);
b_mix(a, b, c, d);
b_mix(b, c, d, a); c -= b;
b_mix(c, d, a, b); d -= a;
b_mix(d, a, b, c);
b_mix(a, b, c, d);
b_mix(b, c, d, a); c -= b;
b_mix(c, d, a, b); d -= a;
b_mix(d, a, b, c);
out_blk[0] = d - l_key[0]; out_blk[1] = c - l_key[1];
out_blk[2] = b - l_key[2]; out_blk[3] = a - l_key[3];
}
bool Mars::SetKey(const std::vector<u4byte>& k)
{
u4byte n = k.size();
if (n < 4 || n > 14)
{
std::cout << "Standart key is taken" << std::endl;
return false;
}
u4byte T[15] = {0};
for (size_t i = 0; i < n; i++)
{
T[i] = k[i];
}
T[n] = n;
for (int i = n + 1; i < 15; i++)
{
T[i] = 0;
}
for (size_t j = 0; j < 4; j++) // compute 10 words of K[] in each iteration
{
// Linear Key-Word Expansion
for (size_t i = 0; i < 15; i++)
{
T[i] = _rotl((T[(i + 8) % 15] ^ T[(i + 13) % 15]), 3) ^ (4 * i + j);
}
// S-box Based Stirring of Key-Words, Repeat 4 times
for (size_t k = 0; k < 4; k++)
{
for (size_t i = 0; i < 15; i++)
{
T[i] = _rotl((T[i] + S((T[(i + 14) % 15]))), 9);
}
}
// Store Next 10 Key-Words into K[]
for (size_t i = 0; i < 10; i++)
{
l_key[10 * j + i] = T[4 * i % 15];
}
}
std::cout << "User's key is taken" << std::endl;
return true;
}
void Mars::ReadFromFile(const char* filename, std::vector<u4byte>& v)
{
std::ifstream file(filename, std::ios::binary | std::ios::ate);
std::streamsize size = file.tellg();
file.seekg(0, std::ios::beg);
std::vector<char> buffer(size);
if (file.read(buffer.data(), size))
{
int i = 0;
int j = 0;
u4byte t = 0;
while (i <= buffer.size() - 4)
{
t = 0;
set4(buffer[i + 3], buffer[i + 2], buffer[i + 1], buffer[i], t);
v.push_back(t);
i += 4;
}
int padding = buffer.size() % 4;
t = 0;
int p = 0;
for (p = 0; p < padding; p++) //add left bytes
{
setByte(p, buffer[i++], t);
}
if (padding != 0) //complete not-full block //last byte of data + 10s
{
setByte(p, 80, t);
p++;
i++;
while (p < 4) //0s after 1 after data
{
setByte(p, 0, t);
p++;
}
v.push_back(t);
}
else
{ //padding == 0; complete full block
t = 0;
setByte(3, 80, t);
setByte(2, 0, t);
setByte(1, 0, t);
setByte(0, 0, t);
v.push_back(t);
}
}
else
{
std::cout << "Unable to open file.";
}
file.close();
}
void Mars::WriteToFile(const char* filename, const std::vector<u4byte>& v)
{
int i = 0, j = 0;
std::ofstream file(filename, std::ios::binary);
if (file.is_open())
{
for (i = 0; i < v.size() - 2; i++)
{
file << char(v[i] & 0xff);
file << char((v[i] >> 8) & 0xff);
file << char((v[i] >> 16) & 0xff);
file << char((v[i] >> 24) & 0xff);
}
if (((((v[i + 1] >> 24) & 0xff) == 80) //if full block was added
&& ((v[i + 1] >> 16) & 0xff) == 0) //i=size()-1
&& (((v[i + 1] >> 8) & 0xff) == 0)
&& ((v[i + 1] & 0xff) == 0))
{
file << char(v[i] & 0xff); //entire block before addition block
file << char((v[i] >> 8) & 0xff); //i=size()-2
file << char((v[i] >> 16) & 0xff);
file << char((v[i] >> 24) & 0xff);
}
else
{
file << char(v[i] & 0xff); //entire block before half-block (because reading until -2 block)
file << char((v[i] >> 8) & 0xff); //i=size()-2
file << char((v[i] >> 16) & 0xff);
file << char((v[i] >> 24) & 0xff);
i++;
for (int k = j; k < 4; k++)
{
if (v[i] >> (8 * k) == 80)
{
break;
}
file << char((v[i] >> (8 * k)) & 0xff);
}
}
}
else
{
std::cout << "Unable to open file";
}
file.close();
}
void Mars::setByte(int pos, u4byte value, u4byte& b)
{
int shift = pos * 8;
b |= value << shift;
}
void Mars::EncryptMessage(const std::vector<u4byte>& v, std::vector<u4byte>& res)
{
res.resize(v.size());
for (size_t i = 0; i < v.size(); i += 4)
{
Encrypt(&v[i], &res[i]);
}
}
void Mars::DecryptMessage(const std::vector<u4byte>& v, std::vector<u4byte>& res)
{
res.resize(v.size());
for (size_t i = 0; i < v.size(); i += 4)
{
Decrypt(&v[i], &res[i]);
}
}
| [
"AnnyshkaF@github.com"
] | AnnyshkaF@github.com |
a5687de97df43b70e1a30cd42eae20086b1d3a08 | 8be083e9fbf15606201217d6c4b87c929e418065 | /tags/release-0.1/geo/size.cpp | f41e767a4bef9aaa701a05a389fb6f6b08754e99 | [
"Apache-2.0"
] | permissive | BGCX067/faint-graphics-editor-svn-to-git | 430768d441f3e9b353fbc128e132f7406ee48c0e | dad252f820d29ab336bcfa57138625dae6dfed60 | refs/heads/master | 2021-01-13T00:56:26.685520 | 2015-12-28T14:22:44 | 2015-12-28T14:22:44 | 48,752,914 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 910 | cpp | // Copyright 2012 Lukas Kemmer
//
// Licensed under the Apache License, Version 2.0 (the "License"); you
// may not use this file except in compliance with the License. You
// may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
// implied. See the License for the specific language governing
// permissions and limitations under the License.
#include "geotypes.hh"
Size::Size( faint::coord in_w, faint::coord in_h )
: w(in_w),
h(in_h)
{}
bool Size::operator==( const Size& other ) const {
return coord_eq(w, other.w) && coord_eq(h, other.h);
}
bool Size::operator!=( const Size& other ) const {
return !((*this)==other);
}
| [
"you@example.com"
] | you@example.com |
80b0266ec077eea1430b5258a3a0f2d90e47083c | c0e0138bff95c2eac038349772e36754887a10ae | /mdk_release_18.08.10_general_purpose/mdk/common/components/kernelLib/MvCV/kernels/maxPool3x3hh/unittest/maxPool3x3hh_asm_test.cpp | ba4eafdeca300e153d6095ad9ba6b6ff407e46db | [] | no_license | elfmedy/vvdn_tofa | f24d2e1adc617db5f2b1aef85f478998aa1840c9 | ce514e0506738a50c0e3f098d8363f206503a311 | refs/heads/master | 2020-04-13T17:52:19.490921 | 2018-09-25T12:01:21 | 2018-09-25T12:01:21 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,243 | cpp | #include "TestRunner.h"
#include "FunctionInfo.h"
#include "moviDebugDll.h"
#include <cstdio>
#define EXPECTED_CC (2.017)
#define PADDING 8
TestRunner maxPool3x3hhTestRunner(APP_PATH, APP_ELFPATH, KERNEL_ASM_LABEL, DBG_INTERFACE);
unsigned int maxPool3x3hhCycleCount;
void maxPool3x3hh_asm_test(half **input, half **output, unsigned int width)
{
FunctionInfo& functionInfo = FunctionInfo::Instance();
unsigned int maxWidth = 1920 + PADDING;
maxPool3x3hhTestRunner.Init();
maxPool3x3hhTestRunner.SetInput("input", input, width + 8, maxWidth, 3, SHAVE0);
maxPool3x3hhTestRunner.SetInput("width", width, SHAVE0);
maxPool3x3hhTestRunner.GuardInsert("output", SHAVE0, width, maxWidth, 1, output);
maxPool3x3hhTestRunner.Run(SHAVE0);
if(width >= 1280)
{
maxPool3x3hhCycleCount = maxPool3x3hhTestRunner.GetVariableValue("cycleCount");
functionInfo.AddCyclePerPixelInfo((float)(maxPool3x3hhCycleCount - 14) / (float)width);
functionInfo.setExpectedCycles((float)EXPECTED_CC);
}
maxPool3x3hhTestRunner.GetOutput("output", SHAVE0, width, maxWidth, 1, output);
maxPool3x3hhTestRunner.GuardCheck("output", SHAVE0, width, maxWidth, 1, output);
}
| [
"palani.andavan@vvdntech.com"
] | palani.andavan@vvdntech.com |
fc7ad96a66151078157ad7063280481937a19496 | 69af737b8376637cc3ee12943b54c40112005732 | /OOP Lab/C++/Ex7/hNodeArray.h | 6cd561d955cb00bfbc44fd79f4d4db02cd8e7b00 | [] | no_license | g-mk/Mycode | 958ebb7ef60fc875be194dc2eaedb242ef083faa | 71b8bb52fc9d95894de0b50e6789d98531d671d2 | refs/heads/master | 2021-09-24T03:02:11.823309 | 2018-10-02T06:07:53 | 2018-10-02T06:07:53 | 103,801,348 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 779 | h | #include<iostream>
using namespace std;
/*typedef struct Infomation
{
char m_sName[30];
int m_nRollNo;
float m_fCutoff;
}Info;*/
template <typename T>
class Node
{
friend class LinkList;
private:
T Val;
Node *link;
};
template<typename T,typename T1=Node>
class LinkList
{
public:
LinkList();
~LinkList();
T1 * CreateNode();
int InsertAfterPosition(T1 *newNode, int pos);
int InsertAtFront(T1 *newNode);
int InsertAtLast(T1 *newNode);
int DeleteByElement(T Val);
int DeleteFirstNode();
T1 * FindByElement (T Val);
int FindByPosition(int pos);
void Print();
void PrintNode(T1 *);
int GetData();
private:
T1 *head;
int Length;
};
| [
"gmk3071996@gmail.com"
] | gmk3071996@gmail.com |
c784b7b91d37b34694559057766efa6c14eb95cb | 6d5cdead70e05581f9401113a5c9df29c4192f85 | /CarND-Extended-Kalman-Filter-Project/src/main.cpp | c3cc3e10ca1300d31cde3dee5dc1834e45822265 | [
"MIT"
] | permissive | faranlab/ExtendedKalmanFilter | 4b6ef8bf2b3a1ace7ec0c4d974165712d24c0544 | aa3caf5a4fac2cc17c3f86bf25463cc26478b704 | refs/heads/master | 2020-05-07T11:02:22.903596 | 2019-04-09T20:44:38 | 2019-04-09T20:44:38 | 180,443,543 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,994 | cpp | #include <math.h>
#include <uWS/uWS.h>
#include <iostream>
#include "json.hpp"
#include "FusionEKF.h"
#include "tools.h"
using Eigen::MatrixXd;
using Eigen::VectorXd;
using std::string;
using std::vector;
// for convenience
using json = nlohmann::json;
// Checks if the SocketIO event has JSON data.
// If there is data the JSON object in string format will be returned,
// else the empty string "" will be returned.
string hasData(string s) {
auto found_null = s.find("null");
auto b1 = s.find_first_of("[");
auto b2 = s.find_first_of("]");
if (found_null != string::npos) {
return "";
}
else if (b1 != string::npos && b2 != string::npos) {
return s.substr(b1, b2 - b1 + 1);
}
return "";
}
int main() {
uWS::Hub h;
// Create a Kalman Filter instance
FusionEKF fusionEKF;
// used to compute the RMSE later
Tools tools;
vector<VectorXd> estimations;
vector<VectorXd> ground_truth;
h.onMessage([&fusionEKF,&tools,&estimations,&ground_truth]
(uWS::WebSocket<uWS::SERVER> ws, char *data, size_t length,
uWS::OpCode opCode) {
// "42" at the start of the message means there's a websocket message event.
// The 4 signifies a websocket message
// The 2 signifies a websocket event
if (length && length > 2 && data[0] == '4' && data[1] == '2') {
auto s = hasData(string(data));
if (s != "") {
auto j = json::parse(s);
string event = j[0].get<string>();
if (event == "telemetry") {
// j[1] is the data JSON object
string sensor_measurement = j[1]["sensor_measurement"];
MeasurementPackage meas_package;
std::istringstream iss(sensor_measurement);
long long timestamp;
// reads first element from the current line
string sensor_type;
iss >> sensor_type;
if (sensor_type.compare("L") == 0) {
meas_package.sensor_type_ = MeasurementPackage::LASER;
meas_package.raw_measurements_ = VectorXd(2);
float px;
float py;
iss >> px;
iss >> py;
meas_package.raw_measurements_ << px, py;
iss >> timestamp;
meas_package.timestamp_ = timestamp;
} else if (sensor_type.compare("R") == 0) {
meas_package.sensor_type_ = MeasurementPackage::RADAR;
meas_package.raw_measurements_ = VectorXd(3);
float ro;
float theta;
float ro_dot;
iss >> ro;
iss >> theta;
iss >> ro_dot;
meas_package.raw_measurements_ << ro,theta, ro_dot;
iss >> timestamp;
meas_package.timestamp_ = timestamp;
}
float x_gt;
float y_gt;
float vx_gt;
float vy_gt;
iss >> x_gt;
iss >> y_gt;
iss >> vx_gt;
iss >> vy_gt;
VectorXd gt_values(4);
gt_values(0) = x_gt;
gt_values(1) = y_gt;
gt_values(2) = vx_gt;
gt_values(3) = vy_gt;
ground_truth.push_back(gt_values);
// Call ProcessMeasurement(meas_package) for Kalman filter
fusionEKF.ProcessMeasurement(meas_package);
// Push the current estimated x,y positon from the Kalman filter's
// state vector
VectorXd estimate(4);
double p_x = fusionEKF.ekf_.x_(0);
double p_y = fusionEKF.ekf_.x_(1);
double v1 = fusionEKF.ekf_.x_(2);
double v2 = fusionEKF.ekf_.x_(3);
estimate(0) = p_x;
estimate(1) = p_y;
estimate(2) = v1;
estimate(3) = v2;
estimations.push_back(estimate);
VectorXd RMSE = tools.CalculateRMSE(estimations, ground_truth);
json msgJson;
msgJson["estimate_x"] = p_x;
msgJson["estimate_y"] = p_y;
msgJson["rmse_x"] = RMSE(0);
msgJson["rmse_y"] = RMSE(1);
msgJson["rmse_vx"] = RMSE(2);
msgJson["rmse_vy"] = RMSE(3);
auto msg = "42[\"estimate_marker\"," + msgJson.dump() + "]";
std::cout << msg << std::endl;
ws.send(msg.data(), msg.length(), uWS::OpCode::TEXT);
} // end "telemetry" if
} else {
string msg = "42[\"manual\",{}]";
ws.send(msg.data(), msg.length(), uWS::OpCode::TEXT);
}
} // end websocket message if
}); // end h.onMessage
h.onConnection([&h](uWS::WebSocket<uWS::SERVER> ws, uWS::HttpRequest req) {
std::cout << "Connected!!!" << std::endl;
});
h.onDisconnection([&h](uWS::WebSocket<uWS::SERVER> ws, int code,
char *message, size_t length) {
ws.close();
std::cout << "Disconnected" << std::endl;
});
int port = 4567;
if (h.listen(port)) {
std::cout << "Listening to port " << port << std::endl;
} else {
std::cerr << "Failed to listen to port" << std::endl;
return -1;
}
h.run();
}
| [
"faran954@gmail.com"
] | faran954@gmail.com |
7a6b33b70fd8938d31c1015e60ba639661e62f3c | 51c1c5e9b8489ef8afa029b162aaf4c8f8bda7fc | /raiden/src/raiden/StageCanvas.cpp | d383497769831b91881ef2d972313c84dd7d3ad6 | [
"MIT"
] | permissive | aimoonchen/easyeditor | 3e5c77f0173a40a802fd73d7b741c064095d83e6 | 9dabdbfb8ad7b00c992d997d6662752130d5a02d | refs/heads/master | 2021-04-26T23:06:27.016240 | 2018-02-12T02:28:50 | 2018-02-12T02:28:50 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,937 | cpp | #include "StageCanvas.h"
#include "StagePanel.h"
#include "Context.h"
#include "ActorInfo.h"
static const ee::Colorf LIGHT_GRAY = ee::Colorf(0.8f, 0.8f, 0.8f);
using namespace raiden;
StageCanvas::StageCanvas(StagePanel* parent)
: ee::SpriteStageCanvas(parent, parent)
{
}
void StageCanvas::onDraw()
{
drawGuideLines();
std::vector<ee::ISprite*> sprites;
m_spritesImpl->traverseSprites(ee::FetchAllVisitor<ee::ISprite>(sprites),
ee::e_visible);
for (size_t i = 0, n = sprites.size(); i < n; ++i)
{
ee::ISprite* sprite = sprites[i];
ee::SpriteDraw::drawSprite(sprite);
ActorInfo* info = static_cast<ActorInfo*>(sprite->getUserData());
if (info->symbol)
ee::SpriteDraw::drawSprite(info->symbol, sprite->getPosition() + info->offset);
}
m_editPanel->drawEditTemp();
}
void StageCanvas::drawGuideLines()
{
Context* context = Context::Instance();
static const float EDGE = 80;
static const float WIDTH = 480 + EDGE * 2, HEIGHT = 800 * 50;
// background
glColor3f(LIGHT_GRAY.r, LIGHT_GRAY.g, LIGHT_GRAY.b);
glBegin(GL_LINE_LOOP);
glVertex2f(0, 0);
glVertex2f(WIDTH, 0);
glVertex2f(WIDTH, HEIGHT);
glVertex2f(0, HEIGHT);
glEnd();
glBegin(GL_LINES);
glVertex2f(EDGE, 0); glVertex2f(EDGE, HEIGHT);
glVertex2f(WIDTH-EDGE, 0); glVertex2f(WIDTH-EDGE, HEIGHT);
glEnd();
// calibration
glColor3f(1.0f, 0.0f, 0.0f);
glBegin(GL_LINES);
const float unit = context->speed;
const int time = HEIGHT / context->speed;
for (int i = 0; i <= time; ++i)
{
if (i % 5 == 0)
{
glVertex2f(-EDGE * 3, unit * i);
glVertex2f(0.0f, unit * i);
}
else
{
glVertex2f(-EDGE, unit * i);
glVertex2f(0.0f, unit * i);
}
}
for (int i = 0, n = time / 10; i <= n; ++i)
{
if (i % 5 == 0)
{
glVertex2f(WIDTH, unit * i * 10);
glVertex2f(WIDTH + EDGE * 3, unit * i * 10);
}
else
{
glVertex2f(WIDTH, unit * i * 10);
glVertex2f(WIDTH + EDGE, unit * i * 10);
}
}
glEnd();
} | [
"zhuguang@ejoy.com"
] | zhuguang@ejoy.com |
bed5d8e943210c83522e6e220b198c0a324f0f5f | 28d686459c2cb9f6ea358819c64415781ee5b277 | /benchmarks/UaParserBench.cpp | 6efb4209ead6a8ec84f43bc60a7563f0d424d77c | [
"MIT"
] | permissive | ua-parser/uap-cpp | 39a86e68679452e81cf33f6e39ab6e28a562d066 | 05796295949028dbd0db4e476c143fd372c68fbd | refs/heads/master | 2022-03-11T11:01:30.913327 | 2022-02-28T09:26:24 | 2022-02-28T09:26:24 | 26,384,599 | 37 | 37 | MIT | 2021-03-21T19:54:05 | 2014-11-09T04:07:30 | C++ | UTF-8 | C++ | false | false | 620 | cpp | #include "../UaParser.h"
#include <fstream>
#include <string>
#include <vector>
int main(int argc, char* argv[]) {
if (argc != 4) {
printf("Usage: %s <regexes.yaml> <input file> <times to repeat>\n", argv[0]);
return -1;
}
std::vector<std::string> input;
{
std::ifstream infile(argv[2]);
std::string line;
while (std::getline(infile, line)) {
input.push_back(line);
}
}
uap_cpp::UserAgentParser p(argv[1]);
int n = atoi(argv[3]);
for (int i = 0; i < n; i++) {
for (const auto& user_agent_string : input) {
p.parse(user_agent_string);
}
}
return 0;
}
| [
"asuhan@users.noreply.github.com"
] | asuhan@users.noreply.github.com |
1e91dbcffebb06ac30519c31631599df1a12db61 | b4dc3314ebc2e8d3ba67fd777802960b4aedd84c | /brix-tools/iab/cross_platform_prototype/common/ScreenTagDescripEditor.h | b3b4bd338915d556e0bef2be22e72501b2acda9e | [] | no_license | kamilWLca/brix | 4c3f504f647a74ba7f51b5ae083bca82f70b9340 | c3f2ad913a383bbb34ee64c0bf54980562661e2f | refs/heads/master | 2021-01-18T04:08:56.435574 | 2012-09-18T16:36:32 | 2012-09-18T16:36:32 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 750 | h | #pragma once
#include "afxwin.h"
#include "../common/LucidTypedefs.h"
//#include "Resource.h"
// CScreenTagDescripEditor dialog
class CScreenTagDescripEditor : public CDialog
{
DECLARE_DYNAMIC(CScreenTagDescripEditor)
public:
CScreenTagDescripEditor::CScreenTagDescripEditor(
TagAndDescription_t &tagAndDescrip, CWnd* pParent =NULL );
virtual ~CScreenTagDescripEditor();
// Dialog Data
//enum { IDD = IDD_EDIT_SCRNTAG_DESCRIP };
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support
DECLARE_MESSAGE_MAP()
public:
virtual BOOL OnInitDialog();
protected:
virtual void OnOK();
CEdit m_ctlTagDescrip;
CEdit m_ctlTagEdit;
TagAndDescription_t m_tTagAndDescrip;
public:
CString getTagDescription(void);
};
| [
"kamilwieczorek@hotmail.com"
] | kamilwieczorek@hotmail.com |
7f1e36299c2ba3007b432e927da11bb45a9d316c | 57d518ee92587dd07a73d4383d55e50b8db3a4a1 | /api/UserApi.h | 4365bcd536b2b68ade98f9a32adf04e172ac180b | [
"Apache-2.0"
] | permissive | iniside/openapi-generator | 45e67b4327c6224191ee7859e73be1558dcfc5da | b98e9f1c077176a4833219ad91b0cd6c7cfb359e | refs/heads/master | 2020-04-20T16:31:04.577863 | 2019-02-07T15:20:39 | 2019-02-07T15:20:39 | 168,961,021 | 2 | 0 | null | 2019-02-03T15:39:22 | 2019-02-03T15:39:22 | null | UTF-8 | C++ | false | false | 4,039 | h | /**
* Swagger Petstore
* This is a sample server Petstore server. You can find out more about Swagger at [http://swagger.io](http://swagger.io) or on [irc.freenode.net, #swagger](http://swagger.io/irc/). For this sample, you can use the api key `special-key` to test the authorization filters.
*
* OpenAPI spec version: 1.0.0
* Contact: apiteam@swagger.io
*
* NOTE: This class is auto generated by OpenAPI-Generator 4.0.0-SNAPSHOT.
* https://openapi-generator.tech
* Do not edit the class manually.
*/
/*
* UserApi.h
*
*
*/
#include "../ApiClient.h"
#include "FString.h"
#include "TArray.h"
#include "User.h"
namespace api {
class FUserApi : public IUserApi
{
public:
DECLARE_DELEGATE_OneParam(FOnCreateUser, const & )
DECLARE_DELEGATE_OneParam(FOnCreateUsersWithArrayInput, const & )
DECLARE_DELEGATE_OneParam(FOnCreateUsersWithListInput, const & )
DECLARE_DELEGATE_OneParam(FOnDeleteUser, const & )
DECLARE_DELEGATE_OneParam(FOnGetUserByName, const User& )
DECLARE_DELEGATE_OneParam(FOnLoginUser, const FString& )
DECLARE_DELEGATE_OneParam(FOnLogoutUser, const & )
DECLARE_DELEGATE_OneParam(FOnUpdateUser, const & )
bool CreateUser(
User Body
, const FOnCreateUser& SuccessDelegate = FOnCreateUser()
)
bool CreateUsersWithArrayInput(
TArray<User> Body
, const FOnCreateUsersWithArrayInput& SuccessDelegate = FOnCreateUsersWithArrayInput()
)
bool CreateUsersWithListInput(
TArray<User> Body
, const FOnCreateUsersWithListInput& SuccessDelegate = FOnCreateUsersWithListInput()
)
bool DeleteUser(
FString Username
, const FOnDeleteUser& SuccessDelegate = FOnDeleteUser()
)
bool GetUserByName(
FString Username
, const FOnGetUserByName& SuccessDelegate = FOnGetUserByName()
)
bool LoginUser(
FString Username,
FString Password
, const FOnLoginUser& SuccessDelegate = FOnLoginUser()
)
bool LogoutUser(
, const FOnLogoutUser& SuccessDelegate = FOnLogoutUser()
)
bool UpdateUser(
FString Username,
User Body
, const FOnUpdateUser& SuccessDelegate = FOnUpdateUser()
)
void OnCreateUserResult(FHttpRequestPtr HttpRequest
, FHttpResponsePtr HttpResponse
, bool bSucceeded
, FOnCreateUser SuccessDelegate
, FPlayFabErrorDelegate ErrorDelegate);
void OnCreateUsersWithArrayInputResult(FHttpRequestPtr HttpRequest
, FHttpResponsePtr HttpResponse
, bool bSucceeded
, FOnCreateUsersWithArrayInput SuccessDelegate
, FPlayFabErrorDelegate ErrorDelegate);
void OnCreateUsersWithListInputResult(FHttpRequestPtr HttpRequest
, FHttpResponsePtr HttpResponse
, bool bSucceeded
, FOnCreateUsersWithListInput SuccessDelegate
, FPlayFabErrorDelegate ErrorDelegate);
void OnDeleteUserResult(FHttpRequestPtr HttpRequest
, FHttpResponsePtr HttpResponse
, bool bSucceeded
, FOnDeleteUser SuccessDelegate
, FPlayFabErrorDelegate ErrorDelegate);
void OnGetUserByNameResult(FHttpRequestPtr HttpRequest
, FHttpResponsePtr HttpResponse
, bool bSucceeded
, FOnGetUserByName SuccessDelegate
, FPlayFabErrorDelegate ErrorDelegate);
void OnLoginUserResult(FHttpRequestPtr HttpRequest
, FHttpResponsePtr HttpResponse
, bool bSucceeded
, FOnLoginUser SuccessDelegate
, FPlayFabErrorDelegate ErrorDelegate);
void OnLogoutUserResult(FHttpRequestPtr HttpRequest
, FHttpResponsePtr HttpResponse
, bool bSucceeded
, FOnLogoutUser SuccessDelegate
, FPlayFabErrorDelegate ErrorDelegate);
void OnUpdateUserResult(FHttpRequestPtr HttpRequest
, FHttpResponsePtr HttpResponse
, bool bSucceeded
, FOnUpdateUser SuccessDelegate
, FPlayFabErrorDelegate ErrorDelegate);
protected:
std::shared_ptr<ApiClient> m_ApiClient;
};
}
| [
"xeavien@gmail.com"
] | xeavien@gmail.com |
a487dab7b6af0d3dfdc6776970985f075dd6bc4e | 23e1116a76b8a914eb40463f91b4a97a1c7f2b29 | /libs/chessx-pgn/guess/sqset.h | ead58d715258bcc0fada4ecc3a08da1236cd2846 | [
"MIT"
] | permissive | loloof64/ChessTrainingVsEngine | 6b69f16865a04095cc423319c8c31e49387d0904 | 6950b5f4adf6e6bc7745884f86f994e185c3ffb4 | refs/heads/master | 2023-02-17T12:08:29.678745 | 2021-01-15T19:49:29 | 2021-01-15T19:49:29 | 280,382,648 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,418 | h | //////////////////////////////////////////////////////////////////////
//
// FILE: sqset.h
// SquareSet class
//
// Part of: Scid (Shane's Chess Information Database)
// Version: 3.4
//
// Notice: Copyright (c) 2002 Shane Hudson. All rights reserved.
//
// Author: Shane Hudson (sgh@users.sourceforge.net)
//
//////////////////////////////////////////////////////////////////////
#ifndef SCID_SQSET_H
#define SCID_SQSET_H
#include "common.h"
namespace Guess
{
class SquareSet
{
private:
unsigned int Bits_a1h4;
unsigned int Bits_a5h8;
public:
SquareSet()
{
Bits_a1h4 = Bits_a5h8 = 0;
}
SquareSet(squareT * squares)
{
Bits_a1h4 = Bits_a5h8 = 0;
AddAll(squares);
}
~SquareSet() {}
inline void Clear(void)
{
Bits_a1h4 = Bits_a5h8 = 0;
}
inline void Add(squareT sq);
inline void AddAll(void)
{
Bits_a1h4 = Bits_a5h8 = 0xFFFFFFFFu;
}
inline void AddAll(squareT * squares);
inline bool Contains(squareT sq);
inline void Remove(squareT sq);
};
inline void
SquareSet::Add(squareT sq)
{
ASSERT(sq <= H8);
if(sq <= H4)
{
Bits_a1h4 |= (1 << sq);
}
else
{
Bits_a5h8 |= (1 << (sq & 31));
}
}
inline void
SquareSet::AddAll(squareT * squares)
{
while(true)
{
squareT sq = *squares;
if(sq == NULL_SQUARE)
{
break;
}
ASSERT(sq <= H8);
squares++;
if(sq <= H4)
{
Bits_a1h4 |= (1 << sq);
}
else
{
Bits_a5h8 |= (1 << (sq & 31));
}
}
}
inline bool
SquareSet::Contains(squareT sq)
{
ASSERT(sq <= H8);
if(sq <= H4)
{
return (Bits_a1h4 & (1 << sq)) != 0;
}
else
{
return (Bits_a5h8 & (1 << (sq & 31))) != 0;
}
}
inline void
SquareSet::Remove(squareT sq)
{
ASSERT(sq <= H8);
if(sq <= H4)
{
Bits_a1h4 &= ~(1 << sq);
}
else
{
Bits_a5h8 &= ~(1 << (sq & 31));
}
}
} // End namespace Guess
#endif // SCID_SQSET_H
//////////////////////////////////////////////////////////////////////
// EOF: sqset.h
//////////////////////////////////////////////////////////////////////
| [
"laurent.bernabe@gmail.com"
] | laurent.bernabe@gmail.com |
647b69816db9d1a73d67a84a00cc2645c91ad510 | 9a75da71229691dc3e3c38b186fdcf1ff376cc7a | /include/pbd/particle.h | cd599e7545b59ff0291fef53589f55b11093d481 | [
"MIT"
] | permissive | xzrunner/pbd | d773b7626d7eb03962f3aecc5d13e061e820a77a | ffe768c5907e9ba3f2451a0affcc091eefbcd495 | refs/heads/master | 2020-06-04T14:00:03.089276 | 2020-04-29T01:31:00 | 2020-04-29T01:31:00 | 192,052,601 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,002 | h | #pragma once
#include "pbd/config.h"
#include <glm/vec2.hpp>
#include <glm/geometric.hpp>
#include <vector>
#include <memory>
namespace pbd
{
// Phase of mass for particles
enum Phase
{
SOLID,
FLUID,
GAS,
NUM_PHASES
};
struct Body;
struct SDFData;
// Individual particle representation
struct Particle
{
glm::dvec2 p, ep, v, f; // position, guess position, and velocity
double imass, tmass, sFriction, kFriction, t; // inverse mass, temporary height-scaled mass, coeffs of friction
int bod; // body (if any) this particle belongs to, for disabling collisions
Phase ph; // phase of this particle
Particle()
: p(glm::dvec2()), v(glm::dvec2()), ph(NUM_PHASES) { Init(0); }
Particle(glm::dvec2 pos, double mass, Phase phase = SOLID)
: p(pos), v(glm::dvec2()), ph(phase) { Init(mass); }
Particle(glm::dvec2 pos, glm::dvec2 vel, double mass, Phase phase)
: p(pos), v(vel), ph(phase) { Init(mass); }
void Init(double mass) {
t = 4.;
ep = glm::dvec2();
bod = -1;
if (mass <= 0) {
imass = -mass;
} else {
imass = 1. / mass;
}
tmass = imass;
f = glm::dvec2();
sFriction = 0;
kFriction = 0; // usually smaller the coefficient of static friction
}
inline void SetStatic() { imass = 0.; }
inline glm::dvec2 Guess(double seconds) {
return imass == 0. ? p : p + seconds * v;
}
inline void ConfirmGuess() {
if (glm::length(ep - p) < EPSILON) {
v = glm::dvec2(0,0); return;
}
p = ep;
}
void ScaleMass() {
if (imass != 0.0) {
tmass = 1. / ((1. / imass) * exp(-p.y));
} else {
tmass = 0.0;
}
}
// Used for stabilization-related constraints
inline glm::dvec2 GetP(bool stabile) { return stabile ? p : ep; }
SDFData getSDFData(const std::vector<std::shared_ptr<Body>>& bodies, int idx);
};
} | [
"zhuguang@ejoy.com"
] | zhuguang@ejoy.com |
7823f2260fd63c6fa4ab83e71e4e370a35648555 | f3a9174535cd7e76d1c1e0f0fa1a3929751fb48d | /SDK/PVR_MovieScene_functions.cpp | d8070cf03605b38ef56ae987ce2c0955add2c99c | [] | no_license | hinnie123/PavlovVRSDK | 9fcdf97e7ed2ad6c5cb485af16652a4c83266a2b | 503f8d9a6770046cc23f935f2df1f1dede4022a8 | refs/heads/master | 2020-03-31T05:30:40.125042 | 2020-01-28T20:16:11 | 2020-01-28T20:16:11 | 151,949,019 | 5 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 26,547 | cpp | // PavlovVR (Dumped by Hinnie) SDK
#ifdef _MSC_VER
#pragma pack(push, 0x8)
#endif
#include "../SDK.hpp"
namespace SDK
{
//---------------------------------------------------------------------------
//Functions
//---------------------------------------------------------------------------
// Function MovieScene.MovieSceneSequencePlayer.Stop
// (Final, Native, Public, BlueprintCallable)
void UMovieSceneSequencePlayer::Stop()
{
static auto fn = UObject::FindObject<UFunction>("Function MovieScene.MovieSceneSequencePlayer.Stop");
UMovieSceneSequencePlayer_Stop_Params params;
auto flags = fn->FunctionFlags;
fn->FunctionFlags |= 0x400;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function MovieScene.MovieSceneSequencePlayer.SetTimeRange
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float StartTime (Parm, ZeroConstructor, IsPlainOldData)
// float Duration (Parm, ZeroConstructor, IsPlainOldData)
void UMovieSceneSequencePlayer::SetTimeRange(float StartTime, float Duration)
{
static auto fn = UObject::FindObject<UFunction>("Function MovieScene.MovieSceneSequencePlayer.SetTimeRange");
UMovieSceneSequencePlayer_SetTimeRange_Params params;
params.StartTime = StartTime;
params.Duration = Duration;
auto flags = fn->FunctionFlags;
fn->FunctionFlags |= 0x400;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function MovieScene.MovieSceneSequencePlayer.SetPlayRate
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float PlayRate (Parm, ZeroConstructor, IsPlainOldData)
void UMovieSceneSequencePlayer::SetPlayRate(float PlayRate)
{
static auto fn = UObject::FindObject<UFunction>("Function MovieScene.MovieSceneSequencePlayer.SetPlayRate");
UMovieSceneSequencePlayer_SetPlayRate_Params params;
params.PlayRate = PlayRate;
auto flags = fn->FunctionFlags;
fn->FunctionFlags |= 0x400;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function MovieScene.MovieSceneSequencePlayer.SetPlaybackRange
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float NewStartTime (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
// float NewEndTime (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
void UMovieSceneSequencePlayer::SetPlaybackRange(float NewStartTime, float NewEndTime)
{
static auto fn = UObject::FindObject<UFunction>("Function MovieScene.MovieSceneSequencePlayer.SetPlaybackRange");
UMovieSceneSequencePlayer_SetPlaybackRange_Params params;
params.NewStartTime = NewStartTime;
params.NewEndTime = NewEndTime;
auto flags = fn->FunctionFlags;
fn->FunctionFlags |= 0x400;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function MovieScene.MovieSceneSequencePlayer.SetPlaybackPosition
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float NewPlaybackPosition (Parm, ZeroConstructor, IsPlainOldData)
void UMovieSceneSequencePlayer::SetPlaybackPosition(float NewPlaybackPosition)
{
static auto fn = UObject::FindObject<UFunction>("Function MovieScene.MovieSceneSequencePlayer.SetPlaybackPosition");
UMovieSceneSequencePlayer_SetPlaybackPosition_Params params;
params.NewPlaybackPosition = NewPlaybackPosition;
auto flags = fn->FunctionFlags;
fn->FunctionFlags |= 0x400;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function MovieScene.MovieSceneSequencePlayer.SetFrameRate
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FFrameRate FrameRate (Parm, ZeroConstructor, IsPlainOldData)
void UMovieSceneSequencePlayer::SetFrameRate(const struct FFrameRate& FrameRate)
{
static auto fn = UObject::FindObject<UFunction>("Function MovieScene.MovieSceneSequencePlayer.SetFrameRate");
UMovieSceneSequencePlayer_SetFrameRate_Params params;
params.FrameRate = FrameRate;
auto flags = fn->FunctionFlags;
fn->FunctionFlags |= 0x400;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function MovieScene.MovieSceneSequencePlayer.SetFrameRange
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int StartFrame (Parm, ZeroConstructor, IsPlainOldData)
// int Duration (Parm, ZeroConstructor, IsPlainOldData)
void UMovieSceneSequencePlayer::SetFrameRange(int StartFrame, int Duration)
{
static auto fn = UObject::FindObject<UFunction>("Function MovieScene.MovieSceneSequencePlayer.SetFrameRange");
UMovieSceneSequencePlayer_SetFrameRange_Params params;
params.StartFrame = StartFrame;
params.Duration = Duration;
auto flags = fn->FunctionFlags;
fn->FunctionFlags |= 0x400;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function MovieScene.MovieSceneSequencePlayer.SetDisableCameraCuts
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool bInDisableCameraCuts (Parm, ZeroConstructor, IsPlainOldData)
void UMovieSceneSequencePlayer::SetDisableCameraCuts(bool bInDisableCameraCuts)
{
static auto fn = UObject::FindObject<UFunction>("Function MovieScene.MovieSceneSequencePlayer.SetDisableCameraCuts");
UMovieSceneSequencePlayer_SetDisableCameraCuts_Params params;
params.bInDisableCameraCuts = bInDisableCameraCuts;
auto flags = fn->FunctionFlags;
fn->FunctionFlags |= 0x400;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function MovieScene.MovieSceneSequencePlayer.ScrubToSeconds
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float TimeInSeconds (Parm, ZeroConstructor, IsPlainOldData)
void UMovieSceneSequencePlayer::ScrubToSeconds(float TimeInSeconds)
{
static auto fn = UObject::FindObject<UFunction>("Function MovieScene.MovieSceneSequencePlayer.ScrubToSeconds");
UMovieSceneSequencePlayer_ScrubToSeconds_Params params;
params.TimeInSeconds = TimeInSeconds;
auto flags = fn->FunctionFlags;
fn->FunctionFlags |= 0x400;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function MovieScene.MovieSceneSequencePlayer.ScrubToFrame
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FFrameTime NewPosition (Parm)
void UMovieSceneSequencePlayer::ScrubToFrame(const struct FFrameTime& NewPosition)
{
static auto fn = UObject::FindObject<UFunction>("Function MovieScene.MovieSceneSequencePlayer.ScrubToFrame");
UMovieSceneSequencePlayer_ScrubToFrame_Params params;
params.NewPosition = NewPosition;
auto flags = fn->FunctionFlags;
fn->FunctionFlags |= 0x400;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function MovieScene.MovieSceneSequencePlayer.Scrub
// (Final, Native, Public, BlueprintCallable)
void UMovieSceneSequencePlayer::Scrub()
{
static auto fn = UObject::FindObject<UFunction>("Function MovieScene.MovieSceneSequencePlayer.Scrub");
UMovieSceneSequencePlayer_Scrub_Params params;
auto flags = fn->FunctionFlags;
fn->FunctionFlags |= 0x400;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function MovieScene.MovieSceneSequencePlayer.PlayToSeconds
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float TimeInSeconds (Parm, ZeroConstructor, IsPlainOldData)
void UMovieSceneSequencePlayer::PlayToSeconds(float TimeInSeconds)
{
static auto fn = UObject::FindObject<UFunction>("Function MovieScene.MovieSceneSequencePlayer.PlayToSeconds");
UMovieSceneSequencePlayer_PlayToSeconds_Params params;
params.TimeInSeconds = TimeInSeconds;
auto flags = fn->FunctionFlags;
fn->FunctionFlags |= 0x400;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function MovieScene.MovieSceneSequencePlayer.PlayToFrame
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FFrameTime NewPosition (Parm)
void UMovieSceneSequencePlayer::PlayToFrame(const struct FFrameTime& NewPosition)
{
static auto fn = UObject::FindObject<UFunction>("Function MovieScene.MovieSceneSequencePlayer.PlayToFrame");
UMovieSceneSequencePlayer_PlayToFrame_Params params;
params.NewPosition = NewPosition;
auto flags = fn->FunctionFlags;
fn->FunctionFlags |= 0x400;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function MovieScene.MovieSceneSequencePlayer.PlayReverse
// (Final, Native, Public, BlueprintCallable)
void UMovieSceneSequencePlayer::PlayReverse()
{
static auto fn = UObject::FindObject<UFunction>("Function MovieScene.MovieSceneSequencePlayer.PlayReverse");
UMovieSceneSequencePlayer_PlayReverse_Params params;
auto flags = fn->FunctionFlags;
fn->FunctionFlags |= 0x400;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function MovieScene.MovieSceneSequencePlayer.PlayLooping
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int NumLoops (Parm, ZeroConstructor, IsPlainOldData)
void UMovieSceneSequencePlayer::PlayLooping(int NumLoops)
{
static auto fn = UObject::FindObject<UFunction>("Function MovieScene.MovieSceneSequencePlayer.PlayLooping");
UMovieSceneSequencePlayer_PlayLooping_Params params;
params.NumLoops = NumLoops;
auto flags = fn->FunctionFlags;
fn->FunctionFlags |= 0x400;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function MovieScene.MovieSceneSequencePlayer.Play
// (Final, Native, Public, BlueprintCallable)
void UMovieSceneSequencePlayer::Play()
{
static auto fn = UObject::FindObject<UFunction>("Function MovieScene.MovieSceneSequencePlayer.Play");
UMovieSceneSequencePlayer_Play_Params params;
auto flags = fn->FunctionFlags;
fn->FunctionFlags |= 0x400;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function MovieScene.MovieSceneSequencePlayer.Pause
// (Final, Native, Public, BlueprintCallable)
void UMovieSceneSequencePlayer::Pause()
{
static auto fn = UObject::FindObject<UFunction>("Function MovieScene.MovieSceneSequencePlayer.Pause");
UMovieSceneSequencePlayer_Pause_Params params;
auto flags = fn->FunctionFlags;
fn->FunctionFlags |= 0x400;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function MovieScene.MovieSceneSequencePlayer.JumpToSeconds
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float TimeInSeconds (Parm, ZeroConstructor, IsPlainOldData)
void UMovieSceneSequencePlayer::JumpToSeconds(float TimeInSeconds)
{
static auto fn = UObject::FindObject<UFunction>("Function MovieScene.MovieSceneSequencePlayer.JumpToSeconds");
UMovieSceneSequencePlayer_JumpToSeconds_Params params;
params.TimeInSeconds = TimeInSeconds;
auto flags = fn->FunctionFlags;
fn->FunctionFlags |= 0x400;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function MovieScene.MovieSceneSequencePlayer.JumpToPosition
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float NewPlaybackPosition (Parm, ZeroConstructor, IsPlainOldData)
void UMovieSceneSequencePlayer::JumpToPosition(float NewPlaybackPosition)
{
static auto fn = UObject::FindObject<UFunction>("Function MovieScene.MovieSceneSequencePlayer.JumpToPosition");
UMovieSceneSequencePlayer_JumpToPosition_Params params;
params.NewPlaybackPosition = NewPlaybackPosition;
auto flags = fn->FunctionFlags;
fn->FunctionFlags |= 0x400;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function MovieScene.MovieSceneSequencePlayer.JumpToFrame
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FFrameTime NewPosition (Parm)
void UMovieSceneSequencePlayer::JumpToFrame(const struct FFrameTime& NewPosition)
{
static auto fn = UObject::FindObject<UFunction>("Function MovieScene.MovieSceneSequencePlayer.JumpToFrame");
UMovieSceneSequencePlayer_JumpToFrame_Params params;
params.NewPosition = NewPosition;
auto flags = fn->FunctionFlags;
fn->FunctionFlags |= 0x400;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function MovieScene.MovieSceneSequencePlayer.IsReversed
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
bool UMovieSceneSequencePlayer::IsReversed()
{
static auto fn = UObject::FindObject<UFunction>("Function MovieScene.MovieSceneSequencePlayer.IsReversed");
UMovieSceneSequencePlayer_IsReversed_Params params;
auto flags = fn->FunctionFlags;
fn->FunctionFlags |= 0x400;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
return params.ReturnValue;
}
// Function MovieScene.MovieSceneSequencePlayer.IsPlaying
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
bool UMovieSceneSequencePlayer::IsPlaying()
{
static auto fn = UObject::FindObject<UFunction>("Function MovieScene.MovieSceneSequencePlayer.IsPlaying");
UMovieSceneSequencePlayer_IsPlaying_Params params;
auto flags = fn->FunctionFlags;
fn->FunctionFlags |= 0x400;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
return params.ReturnValue;
}
// Function MovieScene.MovieSceneSequencePlayer.IsPaused
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
bool UMovieSceneSequencePlayer::IsPaused()
{
static auto fn = UObject::FindObject<UFunction>("Function MovieScene.MovieSceneSequencePlayer.IsPaused");
UMovieSceneSequencePlayer_IsPaused_Params params;
auto flags = fn->FunctionFlags;
fn->FunctionFlags |= 0x400;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
return params.ReturnValue;
}
// Function MovieScene.MovieSceneSequencePlayer.GoToEndAndStop
// (Final, Native, Public, BlueprintCallable)
void UMovieSceneSequencePlayer::GoToEndAndStop()
{
static auto fn = UObject::FindObject<UFunction>("Function MovieScene.MovieSceneSequencePlayer.GoToEndAndStop");
UMovieSceneSequencePlayer_GoToEndAndStop_Params params;
auto flags = fn->FunctionFlags;
fn->FunctionFlags |= 0x400;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function MovieScene.MovieSceneSequencePlayer.GetStartTime
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FQualifiedFrameTime ReturnValue (Parm, OutParm, ReturnParm)
struct FQualifiedFrameTime UMovieSceneSequencePlayer::GetStartTime()
{
static auto fn = UObject::FindObject<UFunction>("Function MovieScene.MovieSceneSequencePlayer.GetStartTime");
UMovieSceneSequencePlayer_GetStartTime_Params params;
auto flags = fn->FunctionFlags;
fn->FunctionFlags |= 0x400;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
return params.ReturnValue;
}
// Function MovieScene.MovieSceneSequencePlayer.GetPlayRate
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
float UMovieSceneSequencePlayer::GetPlayRate()
{
static auto fn = UObject::FindObject<UFunction>("Function MovieScene.MovieSceneSequencePlayer.GetPlayRate");
UMovieSceneSequencePlayer_GetPlayRate_Params params;
auto flags = fn->FunctionFlags;
fn->FunctionFlags |= 0x400;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
return params.ReturnValue;
}
// Function MovieScene.MovieSceneSequencePlayer.GetPlaybackStart
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
float UMovieSceneSequencePlayer::GetPlaybackStart()
{
static auto fn = UObject::FindObject<UFunction>("Function MovieScene.MovieSceneSequencePlayer.GetPlaybackStart");
UMovieSceneSequencePlayer_GetPlaybackStart_Params params;
auto flags = fn->FunctionFlags;
fn->FunctionFlags |= 0x400;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
return params.ReturnValue;
}
// Function MovieScene.MovieSceneSequencePlayer.GetPlaybackPosition
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
float UMovieSceneSequencePlayer::GetPlaybackPosition()
{
static auto fn = UObject::FindObject<UFunction>("Function MovieScene.MovieSceneSequencePlayer.GetPlaybackPosition");
UMovieSceneSequencePlayer_GetPlaybackPosition_Params params;
auto flags = fn->FunctionFlags;
fn->FunctionFlags |= 0x400;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
return params.ReturnValue;
}
// Function MovieScene.MovieSceneSequencePlayer.GetPlaybackEnd
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
float UMovieSceneSequencePlayer::GetPlaybackEnd()
{
static auto fn = UObject::FindObject<UFunction>("Function MovieScene.MovieSceneSequencePlayer.GetPlaybackEnd");
UMovieSceneSequencePlayer_GetPlaybackEnd_Params params;
auto flags = fn->FunctionFlags;
fn->FunctionFlags |= 0x400;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
return params.ReturnValue;
}
// Function MovieScene.MovieSceneSequencePlayer.GetObjectBindings
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UObject* InObject (Parm, ZeroConstructor, IsPlainOldData)
// TArray<struct FMovieSceneObjectBindingID> ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
TArray<struct FMovieSceneObjectBindingID> UMovieSceneSequencePlayer::GetObjectBindings(class UObject* InObject)
{
static auto fn = UObject::FindObject<UFunction>("Function MovieScene.MovieSceneSequencePlayer.GetObjectBindings");
UMovieSceneSequencePlayer_GetObjectBindings_Params params;
params.InObject = InObject;
auto flags = fn->FunctionFlags;
fn->FunctionFlags |= 0x400;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
return params.ReturnValue;
}
// Function MovieScene.MovieSceneSequencePlayer.GetLength
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
float UMovieSceneSequencePlayer::GetLength()
{
static auto fn = UObject::FindObject<UFunction>("Function MovieScene.MovieSceneSequencePlayer.GetLength");
UMovieSceneSequencePlayer_GetLength_Params params;
auto flags = fn->FunctionFlags;
fn->FunctionFlags |= 0x400;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
return params.ReturnValue;
}
// Function MovieScene.MovieSceneSequencePlayer.GetFrameRate
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FFrameRate ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
struct FFrameRate UMovieSceneSequencePlayer::GetFrameRate()
{
static auto fn = UObject::FindObject<UFunction>("Function MovieScene.MovieSceneSequencePlayer.GetFrameRate");
UMovieSceneSequencePlayer_GetFrameRate_Params params;
auto flags = fn->FunctionFlags;
fn->FunctionFlags |= 0x400;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
return params.ReturnValue;
}
// Function MovieScene.MovieSceneSequencePlayer.GetFrameDuration
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
int UMovieSceneSequencePlayer::GetFrameDuration()
{
static auto fn = UObject::FindObject<UFunction>("Function MovieScene.MovieSceneSequencePlayer.GetFrameDuration");
UMovieSceneSequencePlayer_GetFrameDuration_Params params;
auto flags = fn->FunctionFlags;
fn->FunctionFlags |= 0x400;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
return params.ReturnValue;
}
// Function MovieScene.MovieSceneSequencePlayer.GetEndTime
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FQualifiedFrameTime ReturnValue (Parm, OutParm, ReturnParm)
struct FQualifiedFrameTime UMovieSceneSequencePlayer::GetEndTime()
{
static auto fn = UObject::FindObject<UFunction>("Function MovieScene.MovieSceneSequencePlayer.GetEndTime");
UMovieSceneSequencePlayer_GetEndTime_Params params;
auto flags = fn->FunctionFlags;
fn->FunctionFlags |= 0x400;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
return params.ReturnValue;
}
// Function MovieScene.MovieSceneSequencePlayer.GetDuration
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FQualifiedFrameTime ReturnValue (Parm, OutParm, ReturnParm)
struct FQualifiedFrameTime UMovieSceneSequencePlayer::GetDuration()
{
static auto fn = UObject::FindObject<UFunction>("Function MovieScene.MovieSceneSequencePlayer.GetDuration");
UMovieSceneSequencePlayer_GetDuration_Params params;
auto flags = fn->FunctionFlags;
fn->FunctionFlags |= 0x400;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
return params.ReturnValue;
}
// Function MovieScene.MovieSceneSequencePlayer.GetDisableCameraCuts
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
bool UMovieSceneSequencePlayer::GetDisableCameraCuts()
{
static auto fn = UObject::FindObject<UFunction>("Function MovieScene.MovieSceneSequencePlayer.GetDisableCameraCuts");
UMovieSceneSequencePlayer_GetDisableCameraCuts_Params params;
auto flags = fn->FunctionFlags;
fn->FunctionFlags |= 0x400;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
return params.ReturnValue;
}
// Function MovieScene.MovieSceneSequencePlayer.GetCurrentTime
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FQualifiedFrameTime ReturnValue (Parm, OutParm, ReturnParm)
struct FQualifiedFrameTime UMovieSceneSequencePlayer::GetCurrentTime()
{
static auto fn = UObject::FindObject<UFunction>("Function MovieScene.MovieSceneSequencePlayer.GetCurrentTime");
UMovieSceneSequencePlayer_GetCurrentTime_Params params;
auto flags = fn->FunctionFlags;
fn->FunctionFlags |= 0x400;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
return params.ReturnValue;
}
// Function MovieScene.MovieSceneSequencePlayer.GetBoundObjects
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FMovieSceneObjectBindingID ObjectBinding (Parm)
// TArray<class UObject*> ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
TArray<class UObject*> UMovieSceneSequencePlayer::GetBoundObjects(const struct FMovieSceneObjectBindingID& ObjectBinding)
{
static auto fn = UObject::FindObject<UFunction>("Function MovieScene.MovieSceneSequencePlayer.GetBoundObjects");
UMovieSceneSequencePlayer_GetBoundObjects_Params params;
params.ObjectBinding = ObjectBinding;
auto flags = fn->FunctionFlags;
fn->FunctionFlags |= 0x400;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
return params.ReturnValue;
}
// Function MovieScene.MovieSceneSequencePlayer.ChangePlaybackDirection
// (Final, Native, Public, BlueprintCallable)
void UMovieSceneSequencePlayer::ChangePlaybackDirection()
{
static auto fn = UObject::FindObject<UFunction>("Function MovieScene.MovieSceneSequencePlayer.ChangePlaybackDirection");
UMovieSceneSequencePlayer_ChangePlaybackDirection_Params params;
auto flags = fn->FunctionFlags;
fn->FunctionFlags |= 0x400;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function MovieScene.MovieSceneEasingFunction.OnEvaluate
// (Event, Protected, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// float Interp (Parm, ZeroConstructor, IsPlainOldData)
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
float UMovieSceneEasingFunction::OnEvaluate(float Interp)
{
static auto fn = UObject::FindObject<UFunction>("Function MovieScene.MovieSceneEasingFunction.OnEvaluate");
UMovieSceneEasingFunction_OnEvaluate_Params params;
params.Interp = Interp;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
return params.ReturnValue;
}
}
#ifdef _MSC_VER
#pragma pack(pop)
#endif
| [
"hsibma02@gmail.com"
] | hsibma02@gmail.com |
258668e67485770e6c35096ab5b8d0c437507e9d | 7eeb79997b3f173da998482867f26c01fb5fa0a9 | /include/clang/Basic/arm_mve_builtin_aliases.inc | bbfcd62618260721810d706b9d15ab6f7f22acfa | [] | no_license | HANA-CI-Build-Project/LiuNian-clang | f7a9d775c2506816656362fd74961690aa08fb45 | c1f1acf391027240dc5cdc0b1a5503ff7bcbfaf6 | refs/heads/master | 2020-12-14T15:21:27.344586 | 2020-01-21T04:33:06 | 2020-01-21T04:33:06 | 234,771,485 | 0 | 0 | null | 2020-01-18T17:33:36 | 2020-01-18T17:33:35 | null | UTF-8 | C++ | false | false | 186,491 | inc | case ARM::BI__builtin_arm_mve_asrl:
return AliasName == "asrl";
case ARM::BI__builtin_arm_mve_lsll:
return AliasName == "lsll";
case ARM::BI__builtin_arm_mve_sqrshr:
return AliasName == "sqrshr";
case ARM::BI__builtin_arm_mve_sqrshrl:
return AliasName == "sqrshrl";
case ARM::BI__builtin_arm_mve_sqrshrl_sat48:
return AliasName == "sqrshrl_sat48";
case ARM::BI__builtin_arm_mve_sqshl:
return AliasName == "sqshl";
case ARM::BI__builtin_arm_mve_sqshll:
return AliasName == "sqshll";
case ARM::BI__builtin_arm_mve_srshr:
return AliasName == "srshr";
case ARM::BI__builtin_arm_mve_srshrl:
return AliasName == "srshrl";
case ARM::BI__builtin_arm_mve_uqrshl:
return AliasName == "uqrshl";
case ARM::BI__builtin_arm_mve_uqrshll:
return AliasName == "uqrshll";
case ARM::BI__builtin_arm_mve_uqrshll_sat48:
return AliasName == "uqrshll_sat48";
case ARM::BI__builtin_arm_mve_uqshl:
return AliasName == "uqshl";
case ARM::BI__builtin_arm_mve_uqshll:
return AliasName == "uqshll";
case ARM::BI__builtin_arm_mve_urshr:
return AliasName == "urshr";
case ARM::BI__builtin_arm_mve_urshrl:
return AliasName == "urshrl";
case ARM::BI__builtin_arm_mve_vabavq_p_s16:
return AliasName == "vabavq_p_s16" || AliasName == "vabavq_p";
case ARM::BI__builtin_arm_mve_vabavq_p_s32:
return AliasName == "vabavq_p_s32" || AliasName == "vabavq_p";
case ARM::BI__builtin_arm_mve_vabavq_p_s8:
return AliasName == "vabavq_p_s8" || AliasName == "vabavq_p";
case ARM::BI__builtin_arm_mve_vabavq_p_u16:
return AliasName == "vabavq_p_u16" || AliasName == "vabavq_p";
case ARM::BI__builtin_arm_mve_vabavq_p_u32:
return AliasName == "vabavq_p_u32" || AliasName == "vabavq_p";
case ARM::BI__builtin_arm_mve_vabavq_p_u8:
return AliasName == "vabavq_p_u8" || AliasName == "vabavq_p";
case ARM::BI__builtin_arm_mve_vabavq_s16:
return AliasName == "vabavq_s16" || AliasName == "vabavq";
case ARM::BI__builtin_arm_mve_vabavq_s32:
return AliasName == "vabavq_s32" || AliasName == "vabavq";
case ARM::BI__builtin_arm_mve_vabavq_s8:
return AliasName == "vabavq_s8" || AliasName == "vabavq";
case ARM::BI__builtin_arm_mve_vabavq_u16:
return AliasName == "vabavq_u16" || AliasName == "vabavq";
case ARM::BI__builtin_arm_mve_vabavq_u32:
return AliasName == "vabavq_u32" || AliasName == "vabavq";
case ARM::BI__builtin_arm_mve_vabavq_u8:
return AliasName == "vabavq_u8" || AliasName == "vabavq";
case ARM::BI__builtin_arm_mve_vabdq_f16:
return AliasName == "vabdq_f16" || AliasName == "vabdq";
case ARM::BI__builtin_arm_mve_vabdq_f32:
return AliasName == "vabdq_f32" || AliasName == "vabdq";
case ARM::BI__builtin_arm_mve_vabdq_m_f16:
return AliasName == "vabdq_m_f16" || AliasName == "vabdq_m";
case ARM::BI__builtin_arm_mve_vabdq_m_f32:
return AliasName == "vabdq_m_f32" || AliasName == "vabdq_m";
case ARM::BI__builtin_arm_mve_vabdq_m_s16:
return AliasName == "vabdq_m_s16" || AliasName == "vabdq_m";
case ARM::BI__builtin_arm_mve_vabdq_m_s32:
return AliasName == "vabdq_m_s32" || AliasName == "vabdq_m";
case ARM::BI__builtin_arm_mve_vabdq_m_s8:
return AliasName == "vabdq_m_s8" || AliasName == "vabdq_m";
case ARM::BI__builtin_arm_mve_vabdq_m_u16:
return AliasName == "vabdq_m_u16" || AliasName == "vabdq_m";
case ARM::BI__builtin_arm_mve_vabdq_m_u32:
return AliasName == "vabdq_m_u32" || AliasName == "vabdq_m";
case ARM::BI__builtin_arm_mve_vabdq_m_u8:
return AliasName == "vabdq_m_u8" || AliasName == "vabdq_m";
case ARM::BI__builtin_arm_mve_vabdq_s16:
return AliasName == "vabdq_s16" || AliasName == "vabdq";
case ARM::BI__builtin_arm_mve_vabdq_s32:
return AliasName == "vabdq_s32" || AliasName == "vabdq";
case ARM::BI__builtin_arm_mve_vabdq_s8:
return AliasName == "vabdq_s8" || AliasName == "vabdq";
case ARM::BI__builtin_arm_mve_vabdq_u16:
return AliasName == "vabdq_u16" || AliasName == "vabdq";
case ARM::BI__builtin_arm_mve_vabdq_u32:
return AliasName == "vabdq_u32" || AliasName == "vabdq";
case ARM::BI__builtin_arm_mve_vabdq_u8:
return AliasName == "vabdq_u8" || AliasName == "vabdq";
case ARM::BI__builtin_arm_mve_vabdq_x_f16:
return AliasName == "vabdq_x_f16" || AliasName == "vabdq_x";
case ARM::BI__builtin_arm_mve_vabdq_x_f32:
return AliasName == "vabdq_x_f32" || AliasName == "vabdq_x";
case ARM::BI__builtin_arm_mve_vabdq_x_s16:
return AliasName == "vabdq_x_s16" || AliasName == "vabdq_x";
case ARM::BI__builtin_arm_mve_vabdq_x_s32:
return AliasName == "vabdq_x_s32" || AliasName == "vabdq_x";
case ARM::BI__builtin_arm_mve_vabdq_x_s8:
return AliasName == "vabdq_x_s8" || AliasName == "vabdq_x";
case ARM::BI__builtin_arm_mve_vabdq_x_u16:
return AliasName == "vabdq_x_u16" || AliasName == "vabdq_x";
case ARM::BI__builtin_arm_mve_vabdq_x_u32:
return AliasName == "vabdq_x_u32" || AliasName == "vabdq_x";
case ARM::BI__builtin_arm_mve_vabdq_x_u8:
return AliasName == "vabdq_x_u8" || AliasName == "vabdq_x";
case ARM::BI__builtin_arm_mve_vadciq_m_s32:
return AliasName == "vadciq_m_s32" || AliasName == "vadciq_m";
case ARM::BI__builtin_arm_mve_vadciq_m_u32:
return AliasName == "vadciq_m_u32" || AliasName == "vadciq_m";
case ARM::BI__builtin_arm_mve_vadciq_s32:
return AliasName == "vadciq_s32" || AliasName == "vadciq";
case ARM::BI__builtin_arm_mve_vadciq_u32:
return AliasName == "vadciq_u32" || AliasName == "vadciq";
case ARM::BI__builtin_arm_mve_vadcq_m_s32:
return AliasName == "vadcq_m_s32" || AliasName == "vadcq_m";
case ARM::BI__builtin_arm_mve_vadcq_m_u32:
return AliasName == "vadcq_m_u32" || AliasName == "vadcq_m";
case ARM::BI__builtin_arm_mve_vadcq_s32:
return AliasName == "vadcq_s32" || AliasName == "vadcq";
case ARM::BI__builtin_arm_mve_vadcq_u32:
return AliasName == "vadcq_u32" || AliasName == "vadcq";
case ARM::BI__builtin_arm_mve_vaddq_f16:
return AliasName == "vaddq_f16" || AliasName == "vaddq";
case ARM::BI__builtin_arm_mve_vaddq_f32:
return AliasName == "vaddq_f32" || AliasName == "vaddq";
case ARM::BI__builtin_arm_mve_vaddq_m_f16:
return AliasName == "vaddq_m_f16" || AliasName == "vaddq_m";
case ARM::BI__builtin_arm_mve_vaddq_m_f32:
return AliasName == "vaddq_m_f32" || AliasName == "vaddq_m";
case ARM::BI__builtin_arm_mve_vaddq_m_s16:
return AliasName == "vaddq_m_s16" || AliasName == "vaddq_m";
case ARM::BI__builtin_arm_mve_vaddq_m_s32:
return AliasName == "vaddq_m_s32" || AliasName == "vaddq_m";
case ARM::BI__builtin_arm_mve_vaddq_m_s8:
return AliasName == "vaddq_m_s8" || AliasName == "vaddq_m";
case ARM::BI__builtin_arm_mve_vaddq_m_u16:
return AliasName == "vaddq_m_u16" || AliasName == "vaddq_m";
case ARM::BI__builtin_arm_mve_vaddq_m_u32:
return AliasName == "vaddq_m_u32" || AliasName == "vaddq_m";
case ARM::BI__builtin_arm_mve_vaddq_m_u8:
return AliasName == "vaddq_m_u8" || AliasName == "vaddq_m";
case ARM::BI__builtin_arm_mve_vaddq_s16:
return AliasName == "vaddq_s16" || AliasName == "vaddq";
case ARM::BI__builtin_arm_mve_vaddq_s32:
return AliasName == "vaddq_s32" || AliasName == "vaddq";
case ARM::BI__builtin_arm_mve_vaddq_s8:
return AliasName == "vaddq_s8" || AliasName == "vaddq";
case ARM::BI__builtin_arm_mve_vaddq_u16:
return AliasName == "vaddq_u16" || AliasName == "vaddq";
case ARM::BI__builtin_arm_mve_vaddq_u32:
return AliasName == "vaddq_u32" || AliasName == "vaddq";
case ARM::BI__builtin_arm_mve_vaddq_u8:
return AliasName == "vaddq_u8" || AliasName == "vaddq";
case ARM::BI__builtin_arm_mve_vaddq_x_f16:
return AliasName == "vaddq_x_f16" || AliasName == "vaddq_x";
case ARM::BI__builtin_arm_mve_vaddq_x_f32:
return AliasName == "vaddq_x_f32" || AliasName == "vaddq_x";
case ARM::BI__builtin_arm_mve_vaddq_x_s16:
return AliasName == "vaddq_x_s16" || AliasName == "vaddq_x";
case ARM::BI__builtin_arm_mve_vaddq_x_s32:
return AliasName == "vaddq_x_s32" || AliasName == "vaddq_x";
case ARM::BI__builtin_arm_mve_vaddq_x_s8:
return AliasName == "vaddq_x_s8" || AliasName == "vaddq_x";
case ARM::BI__builtin_arm_mve_vaddq_x_u16:
return AliasName == "vaddq_x_u16" || AliasName == "vaddq_x";
case ARM::BI__builtin_arm_mve_vaddq_x_u32:
return AliasName == "vaddq_x_u32" || AliasName == "vaddq_x";
case ARM::BI__builtin_arm_mve_vaddq_x_u8:
return AliasName == "vaddq_x_u8" || AliasName == "vaddq_x";
case ARM::BI__builtin_arm_mve_vandq_f16:
return AliasName == "vandq_f16" || AliasName == "vandq";
case ARM::BI__builtin_arm_mve_vandq_f32:
return AliasName == "vandq_f32" || AliasName == "vandq";
case ARM::BI__builtin_arm_mve_vandq_m_f16:
return AliasName == "vandq_m_f16" || AliasName == "vandq_m";
case ARM::BI__builtin_arm_mve_vandq_m_f32:
return AliasName == "vandq_m_f32" || AliasName == "vandq_m";
case ARM::BI__builtin_arm_mve_vandq_m_s16:
return AliasName == "vandq_m_s16" || AliasName == "vandq_m";
case ARM::BI__builtin_arm_mve_vandq_m_s32:
return AliasName == "vandq_m_s32" || AliasName == "vandq_m";
case ARM::BI__builtin_arm_mve_vandq_m_s8:
return AliasName == "vandq_m_s8" || AliasName == "vandq_m";
case ARM::BI__builtin_arm_mve_vandq_m_u16:
return AliasName == "vandq_m_u16" || AliasName == "vandq_m";
case ARM::BI__builtin_arm_mve_vandq_m_u32:
return AliasName == "vandq_m_u32" || AliasName == "vandq_m";
case ARM::BI__builtin_arm_mve_vandq_m_u8:
return AliasName == "vandq_m_u8" || AliasName == "vandq_m";
case ARM::BI__builtin_arm_mve_vandq_s16:
return AliasName == "vandq_s16" || AliasName == "vandq";
case ARM::BI__builtin_arm_mve_vandq_s32:
return AliasName == "vandq_s32" || AliasName == "vandq";
case ARM::BI__builtin_arm_mve_vandq_s8:
return AliasName == "vandq_s8" || AliasName == "vandq";
case ARM::BI__builtin_arm_mve_vandq_u16:
return AliasName == "vandq_u16" || AliasName == "vandq";
case ARM::BI__builtin_arm_mve_vandq_u32:
return AliasName == "vandq_u32" || AliasName == "vandq";
case ARM::BI__builtin_arm_mve_vandq_u8:
return AliasName == "vandq_u8" || AliasName == "vandq";
case ARM::BI__builtin_arm_mve_vandq_x_f16:
return AliasName == "vandq_x_f16" || AliasName == "vandq_x";
case ARM::BI__builtin_arm_mve_vandq_x_f32:
return AliasName == "vandq_x_f32" || AliasName == "vandq_x";
case ARM::BI__builtin_arm_mve_vandq_x_s16:
return AliasName == "vandq_x_s16" || AliasName == "vandq_x";
case ARM::BI__builtin_arm_mve_vandq_x_s32:
return AliasName == "vandq_x_s32" || AliasName == "vandq_x";
case ARM::BI__builtin_arm_mve_vandq_x_s8:
return AliasName == "vandq_x_s8" || AliasName == "vandq_x";
case ARM::BI__builtin_arm_mve_vandq_x_u16:
return AliasName == "vandq_x_u16" || AliasName == "vandq_x";
case ARM::BI__builtin_arm_mve_vandq_x_u32:
return AliasName == "vandq_x_u32" || AliasName == "vandq_x";
case ARM::BI__builtin_arm_mve_vandq_x_u8:
return AliasName == "vandq_x_u8" || AliasName == "vandq_x";
case ARM::BI__builtin_arm_mve_vbicq_f16:
return AliasName == "vbicq_f16" || AliasName == "vbicq";
case ARM::BI__builtin_arm_mve_vbicq_f32:
return AliasName == "vbicq_f32" || AliasName == "vbicq";
case ARM::BI__builtin_arm_mve_vbicq_m_f16:
return AliasName == "vbicq_m_f16" || AliasName == "vbicq_m";
case ARM::BI__builtin_arm_mve_vbicq_m_f32:
return AliasName == "vbicq_m_f32" || AliasName == "vbicq_m";
case ARM::BI__builtin_arm_mve_vbicq_m_s16:
return AliasName == "vbicq_m_s16" || AliasName == "vbicq_m";
case ARM::BI__builtin_arm_mve_vbicq_m_s32:
return AliasName == "vbicq_m_s32" || AliasName == "vbicq_m";
case ARM::BI__builtin_arm_mve_vbicq_m_s8:
return AliasName == "vbicq_m_s8" || AliasName == "vbicq_m";
case ARM::BI__builtin_arm_mve_vbicq_m_u16:
return AliasName == "vbicq_m_u16" || AliasName == "vbicq_m";
case ARM::BI__builtin_arm_mve_vbicq_m_u32:
return AliasName == "vbicq_m_u32" || AliasName == "vbicq_m";
case ARM::BI__builtin_arm_mve_vbicq_m_u8:
return AliasName == "vbicq_m_u8" || AliasName == "vbicq_m";
case ARM::BI__builtin_arm_mve_vbicq_s16:
return AliasName == "vbicq_s16" || AliasName == "vbicq";
case ARM::BI__builtin_arm_mve_vbicq_s32:
return AliasName == "vbicq_s32" || AliasName == "vbicq";
case ARM::BI__builtin_arm_mve_vbicq_s8:
return AliasName == "vbicq_s8" || AliasName == "vbicq";
case ARM::BI__builtin_arm_mve_vbicq_u16:
return AliasName == "vbicq_u16" || AliasName == "vbicq";
case ARM::BI__builtin_arm_mve_vbicq_u32:
return AliasName == "vbicq_u32" || AliasName == "vbicq";
case ARM::BI__builtin_arm_mve_vbicq_u8:
return AliasName == "vbicq_u8" || AliasName == "vbicq";
case ARM::BI__builtin_arm_mve_vbicq_x_f16:
return AliasName == "vbicq_x_f16" || AliasName == "vbicq_x";
case ARM::BI__builtin_arm_mve_vbicq_x_f32:
return AliasName == "vbicq_x_f32" || AliasName == "vbicq_x";
case ARM::BI__builtin_arm_mve_vbicq_x_s16:
return AliasName == "vbicq_x_s16" || AliasName == "vbicq_x";
case ARM::BI__builtin_arm_mve_vbicq_x_s32:
return AliasName == "vbicq_x_s32" || AliasName == "vbicq_x";
case ARM::BI__builtin_arm_mve_vbicq_x_s8:
return AliasName == "vbicq_x_s8" || AliasName == "vbicq_x";
case ARM::BI__builtin_arm_mve_vbicq_x_u16:
return AliasName == "vbicq_x_u16" || AliasName == "vbicq_x";
case ARM::BI__builtin_arm_mve_vbicq_x_u32:
return AliasName == "vbicq_x_u32" || AliasName == "vbicq_x";
case ARM::BI__builtin_arm_mve_vbicq_x_u8:
return AliasName == "vbicq_x_u8" || AliasName == "vbicq_x";
case ARM::BI__builtin_arm_mve_vcaddq_rot270_f16:
return AliasName == "vcaddq_rot270_f16" || AliasName == "vcaddq_rot270";
case ARM::BI__builtin_arm_mve_vcaddq_rot270_f32:
return AliasName == "vcaddq_rot270_f32" || AliasName == "vcaddq_rot270";
case ARM::BI__builtin_arm_mve_vcaddq_rot270_m_f16:
return AliasName == "vcaddq_rot270_m_f16" || AliasName == "vcaddq_rot270_m";
case ARM::BI__builtin_arm_mve_vcaddq_rot270_m_f32:
return AliasName == "vcaddq_rot270_m_f32" || AliasName == "vcaddq_rot270_m";
case ARM::BI__builtin_arm_mve_vcaddq_rot270_m_s16:
return AliasName == "vcaddq_rot270_m_s16" || AliasName == "vcaddq_rot270_m";
case ARM::BI__builtin_arm_mve_vcaddq_rot270_m_s32:
return AliasName == "vcaddq_rot270_m_s32" || AliasName == "vcaddq_rot270_m";
case ARM::BI__builtin_arm_mve_vcaddq_rot270_m_s8:
return AliasName == "vcaddq_rot270_m_s8" || AliasName == "vcaddq_rot270_m";
case ARM::BI__builtin_arm_mve_vcaddq_rot270_m_u16:
return AliasName == "vcaddq_rot270_m_u16" || AliasName == "vcaddq_rot270_m";
case ARM::BI__builtin_arm_mve_vcaddq_rot270_m_u32:
return AliasName == "vcaddq_rot270_m_u32" || AliasName == "vcaddq_rot270_m";
case ARM::BI__builtin_arm_mve_vcaddq_rot270_m_u8:
return AliasName == "vcaddq_rot270_m_u8" || AliasName == "vcaddq_rot270_m";
case ARM::BI__builtin_arm_mve_vcaddq_rot270_s16:
return AliasName == "vcaddq_rot270_s16" || AliasName == "vcaddq_rot270";
case ARM::BI__builtin_arm_mve_vcaddq_rot270_s32:
return AliasName == "vcaddq_rot270_s32" || AliasName == "vcaddq_rot270";
case ARM::BI__builtin_arm_mve_vcaddq_rot270_s8:
return AliasName == "vcaddq_rot270_s8" || AliasName == "vcaddq_rot270";
case ARM::BI__builtin_arm_mve_vcaddq_rot270_u16:
return AliasName == "vcaddq_rot270_u16" || AliasName == "vcaddq_rot270";
case ARM::BI__builtin_arm_mve_vcaddq_rot270_u32:
return AliasName == "vcaddq_rot270_u32" || AliasName == "vcaddq_rot270";
case ARM::BI__builtin_arm_mve_vcaddq_rot270_u8:
return AliasName == "vcaddq_rot270_u8" || AliasName == "vcaddq_rot270";
case ARM::BI__builtin_arm_mve_vcaddq_rot270_x_f16:
return AliasName == "vcaddq_rot270_x_f16" || AliasName == "vcaddq_rot270_x";
case ARM::BI__builtin_arm_mve_vcaddq_rot270_x_f32:
return AliasName == "vcaddq_rot270_x_f32" || AliasName == "vcaddq_rot270_x";
case ARM::BI__builtin_arm_mve_vcaddq_rot270_x_s16:
return AliasName == "vcaddq_rot270_x_s16" || AliasName == "vcaddq_rot270_x";
case ARM::BI__builtin_arm_mve_vcaddq_rot270_x_s32:
return AliasName == "vcaddq_rot270_x_s32" || AliasName == "vcaddq_rot270_x";
case ARM::BI__builtin_arm_mve_vcaddq_rot270_x_s8:
return AliasName == "vcaddq_rot270_x_s8" || AliasName == "vcaddq_rot270_x";
case ARM::BI__builtin_arm_mve_vcaddq_rot270_x_u16:
return AliasName == "vcaddq_rot270_x_u16" || AliasName == "vcaddq_rot270_x";
case ARM::BI__builtin_arm_mve_vcaddq_rot270_x_u32:
return AliasName == "vcaddq_rot270_x_u32" || AliasName == "vcaddq_rot270_x";
case ARM::BI__builtin_arm_mve_vcaddq_rot270_x_u8:
return AliasName == "vcaddq_rot270_x_u8" || AliasName == "vcaddq_rot270_x";
case ARM::BI__builtin_arm_mve_vcaddq_rot90_f16:
return AliasName == "vcaddq_rot90_f16" || AliasName == "vcaddq_rot90";
case ARM::BI__builtin_arm_mve_vcaddq_rot90_f32:
return AliasName == "vcaddq_rot90_f32" || AliasName == "vcaddq_rot90";
case ARM::BI__builtin_arm_mve_vcaddq_rot90_m_f16:
return AliasName == "vcaddq_rot90_m_f16" || AliasName == "vcaddq_rot90_m";
case ARM::BI__builtin_arm_mve_vcaddq_rot90_m_f32:
return AliasName == "vcaddq_rot90_m_f32" || AliasName == "vcaddq_rot90_m";
case ARM::BI__builtin_arm_mve_vcaddq_rot90_m_s16:
return AliasName == "vcaddq_rot90_m_s16" || AliasName == "vcaddq_rot90_m";
case ARM::BI__builtin_arm_mve_vcaddq_rot90_m_s32:
return AliasName == "vcaddq_rot90_m_s32" || AliasName == "vcaddq_rot90_m";
case ARM::BI__builtin_arm_mve_vcaddq_rot90_m_s8:
return AliasName == "vcaddq_rot90_m_s8" || AliasName == "vcaddq_rot90_m";
case ARM::BI__builtin_arm_mve_vcaddq_rot90_m_u16:
return AliasName == "vcaddq_rot90_m_u16" || AliasName == "vcaddq_rot90_m";
case ARM::BI__builtin_arm_mve_vcaddq_rot90_m_u32:
return AliasName == "vcaddq_rot90_m_u32" || AliasName == "vcaddq_rot90_m";
case ARM::BI__builtin_arm_mve_vcaddq_rot90_m_u8:
return AliasName == "vcaddq_rot90_m_u8" || AliasName == "vcaddq_rot90_m";
case ARM::BI__builtin_arm_mve_vcaddq_rot90_s16:
return AliasName == "vcaddq_rot90_s16" || AliasName == "vcaddq_rot90";
case ARM::BI__builtin_arm_mve_vcaddq_rot90_s32:
return AliasName == "vcaddq_rot90_s32" || AliasName == "vcaddq_rot90";
case ARM::BI__builtin_arm_mve_vcaddq_rot90_s8:
return AliasName == "vcaddq_rot90_s8" || AliasName == "vcaddq_rot90";
case ARM::BI__builtin_arm_mve_vcaddq_rot90_u16:
return AliasName == "vcaddq_rot90_u16" || AliasName == "vcaddq_rot90";
case ARM::BI__builtin_arm_mve_vcaddq_rot90_u32:
return AliasName == "vcaddq_rot90_u32" || AliasName == "vcaddq_rot90";
case ARM::BI__builtin_arm_mve_vcaddq_rot90_u8:
return AliasName == "vcaddq_rot90_u8" || AliasName == "vcaddq_rot90";
case ARM::BI__builtin_arm_mve_vcaddq_rot90_x_f16:
return AliasName == "vcaddq_rot90_x_f16" || AliasName == "vcaddq_rot90_x";
case ARM::BI__builtin_arm_mve_vcaddq_rot90_x_f32:
return AliasName == "vcaddq_rot90_x_f32" || AliasName == "vcaddq_rot90_x";
case ARM::BI__builtin_arm_mve_vcaddq_rot90_x_s16:
return AliasName == "vcaddq_rot90_x_s16" || AliasName == "vcaddq_rot90_x";
case ARM::BI__builtin_arm_mve_vcaddq_rot90_x_s32:
return AliasName == "vcaddq_rot90_x_s32" || AliasName == "vcaddq_rot90_x";
case ARM::BI__builtin_arm_mve_vcaddq_rot90_x_s8:
return AliasName == "vcaddq_rot90_x_s8" || AliasName == "vcaddq_rot90_x";
case ARM::BI__builtin_arm_mve_vcaddq_rot90_x_u16:
return AliasName == "vcaddq_rot90_x_u16" || AliasName == "vcaddq_rot90_x";
case ARM::BI__builtin_arm_mve_vcaddq_rot90_x_u32:
return AliasName == "vcaddq_rot90_x_u32" || AliasName == "vcaddq_rot90_x";
case ARM::BI__builtin_arm_mve_vcaddq_rot90_x_u8:
return AliasName == "vcaddq_rot90_x_u8" || AliasName == "vcaddq_rot90_x";
case ARM::BI__builtin_arm_mve_vcmlaq_f16:
return AliasName == "vcmlaq_f16" || AliasName == "vcmlaq";
case ARM::BI__builtin_arm_mve_vcmlaq_f32:
return AliasName == "vcmlaq_f32" || AliasName == "vcmlaq";
case ARM::BI__builtin_arm_mve_vcmlaq_m_f16:
return AliasName == "vcmlaq_m_f16" || AliasName == "vcmlaq_m";
case ARM::BI__builtin_arm_mve_vcmlaq_m_f32:
return AliasName == "vcmlaq_m_f32" || AliasName == "vcmlaq_m";
case ARM::BI__builtin_arm_mve_vcmlaq_rot180_f16:
return AliasName == "vcmlaq_rot180_f16" || AliasName == "vcmlaq_rot180";
case ARM::BI__builtin_arm_mve_vcmlaq_rot180_f32:
return AliasName == "vcmlaq_rot180_f32" || AliasName == "vcmlaq_rot180";
case ARM::BI__builtin_arm_mve_vcmlaq_rot180_m_f16:
return AliasName == "vcmlaq_rot180_m_f16" || AliasName == "vcmlaq_rot180_m";
case ARM::BI__builtin_arm_mve_vcmlaq_rot180_m_f32:
return AliasName == "vcmlaq_rot180_m_f32" || AliasName == "vcmlaq_rot180_m";
case ARM::BI__builtin_arm_mve_vcmlaq_rot270_f16:
return AliasName == "vcmlaq_rot270_f16" || AliasName == "vcmlaq_rot270";
case ARM::BI__builtin_arm_mve_vcmlaq_rot270_f32:
return AliasName == "vcmlaq_rot270_f32" || AliasName == "vcmlaq_rot270";
case ARM::BI__builtin_arm_mve_vcmlaq_rot270_m_f16:
return AliasName == "vcmlaq_rot270_m_f16" || AliasName == "vcmlaq_rot270_m";
case ARM::BI__builtin_arm_mve_vcmlaq_rot270_m_f32:
return AliasName == "vcmlaq_rot270_m_f32" || AliasName == "vcmlaq_rot270_m";
case ARM::BI__builtin_arm_mve_vcmlaq_rot90_f16:
return AliasName == "vcmlaq_rot90_f16" || AliasName == "vcmlaq_rot90";
case ARM::BI__builtin_arm_mve_vcmlaq_rot90_f32:
return AliasName == "vcmlaq_rot90_f32" || AliasName == "vcmlaq_rot90";
case ARM::BI__builtin_arm_mve_vcmlaq_rot90_m_f16:
return AliasName == "vcmlaq_rot90_m_f16" || AliasName == "vcmlaq_rot90_m";
case ARM::BI__builtin_arm_mve_vcmlaq_rot90_m_f32:
return AliasName == "vcmlaq_rot90_m_f32" || AliasName == "vcmlaq_rot90_m";
case ARM::BI__builtin_arm_mve_vcmpcsq_m_n_u16:
return AliasName == "vcmpcsq_m_n_u16" || AliasName == "vcmpcsq_m";
case ARM::BI__builtin_arm_mve_vcmpcsq_m_n_u32:
return AliasName == "vcmpcsq_m_n_u32" || AliasName == "vcmpcsq_m";
case ARM::BI__builtin_arm_mve_vcmpcsq_m_n_u8:
return AliasName == "vcmpcsq_m_n_u8" || AliasName == "vcmpcsq_m";
case ARM::BI__builtin_arm_mve_vcmpcsq_m_u16:
return AliasName == "vcmpcsq_m_u16" || AliasName == "vcmpcsq_m";
case ARM::BI__builtin_arm_mve_vcmpcsq_m_u32:
return AliasName == "vcmpcsq_m_u32" || AliasName == "vcmpcsq_m";
case ARM::BI__builtin_arm_mve_vcmpcsq_m_u8:
return AliasName == "vcmpcsq_m_u8" || AliasName == "vcmpcsq_m";
case ARM::BI__builtin_arm_mve_vcmpcsq_n_u16:
return AliasName == "vcmpcsq_n_u16" || AliasName == "vcmpcsq";
case ARM::BI__builtin_arm_mve_vcmpcsq_n_u32:
return AliasName == "vcmpcsq_n_u32" || AliasName == "vcmpcsq";
case ARM::BI__builtin_arm_mve_vcmpcsq_n_u8:
return AliasName == "vcmpcsq_n_u8" || AliasName == "vcmpcsq";
case ARM::BI__builtin_arm_mve_vcmpcsq_u16:
return AliasName == "vcmpcsq_u16" || AliasName == "vcmpcsq";
case ARM::BI__builtin_arm_mve_vcmpcsq_u32:
return AliasName == "vcmpcsq_u32" || AliasName == "vcmpcsq";
case ARM::BI__builtin_arm_mve_vcmpcsq_u8:
return AliasName == "vcmpcsq_u8" || AliasName == "vcmpcsq";
case ARM::BI__builtin_arm_mve_vcmpeqq_f16:
return AliasName == "vcmpeqq_f16" || AliasName == "vcmpeqq";
case ARM::BI__builtin_arm_mve_vcmpeqq_f32:
return AliasName == "vcmpeqq_f32" || AliasName == "vcmpeqq";
case ARM::BI__builtin_arm_mve_vcmpeqq_m_f16:
return AliasName == "vcmpeqq_m_f16" || AliasName == "vcmpeqq_m";
case ARM::BI__builtin_arm_mve_vcmpeqq_m_f32:
return AliasName == "vcmpeqq_m_f32" || AliasName == "vcmpeqq_m";
case ARM::BI__builtin_arm_mve_vcmpeqq_m_n_f16:
return AliasName == "vcmpeqq_m_n_f16" || AliasName == "vcmpeqq_m";
case ARM::BI__builtin_arm_mve_vcmpeqq_m_n_f32:
return AliasName == "vcmpeqq_m_n_f32" || AliasName == "vcmpeqq_m";
case ARM::BI__builtin_arm_mve_vcmpeqq_m_n_s16:
return AliasName == "vcmpeqq_m_n_s16" || AliasName == "vcmpeqq_m";
case ARM::BI__builtin_arm_mve_vcmpeqq_m_n_s32:
return AliasName == "vcmpeqq_m_n_s32" || AliasName == "vcmpeqq_m";
case ARM::BI__builtin_arm_mve_vcmpeqq_m_n_s8:
return AliasName == "vcmpeqq_m_n_s8" || AliasName == "vcmpeqq_m";
case ARM::BI__builtin_arm_mve_vcmpeqq_m_n_u16:
return AliasName == "vcmpeqq_m_n_u16" || AliasName == "vcmpeqq_m";
case ARM::BI__builtin_arm_mve_vcmpeqq_m_n_u32:
return AliasName == "vcmpeqq_m_n_u32" || AliasName == "vcmpeqq_m";
case ARM::BI__builtin_arm_mve_vcmpeqq_m_n_u8:
return AliasName == "vcmpeqq_m_n_u8" || AliasName == "vcmpeqq_m";
case ARM::BI__builtin_arm_mve_vcmpeqq_m_s16:
return AliasName == "vcmpeqq_m_s16" || AliasName == "vcmpeqq_m";
case ARM::BI__builtin_arm_mve_vcmpeqq_m_s32:
return AliasName == "vcmpeqq_m_s32" || AliasName == "vcmpeqq_m";
case ARM::BI__builtin_arm_mve_vcmpeqq_m_s8:
return AliasName == "vcmpeqq_m_s8" || AliasName == "vcmpeqq_m";
case ARM::BI__builtin_arm_mve_vcmpeqq_m_u16:
return AliasName == "vcmpeqq_m_u16" || AliasName == "vcmpeqq_m";
case ARM::BI__builtin_arm_mve_vcmpeqq_m_u32:
return AliasName == "vcmpeqq_m_u32" || AliasName == "vcmpeqq_m";
case ARM::BI__builtin_arm_mve_vcmpeqq_m_u8:
return AliasName == "vcmpeqq_m_u8" || AliasName == "vcmpeqq_m";
case ARM::BI__builtin_arm_mve_vcmpeqq_n_f16:
return AliasName == "vcmpeqq_n_f16" || AliasName == "vcmpeqq";
case ARM::BI__builtin_arm_mve_vcmpeqq_n_f32:
return AliasName == "vcmpeqq_n_f32" || AliasName == "vcmpeqq";
case ARM::BI__builtin_arm_mve_vcmpeqq_n_s16:
return AliasName == "vcmpeqq_n_s16" || AliasName == "vcmpeqq";
case ARM::BI__builtin_arm_mve_vcmpeqq_n_s32:
return AliasName == "vcmpeqq_n_s32" || AliasName == "vcmpeqq";
case ARM::BI__builtin_arm_mve_vcmpeqq_n_s8:
return AliasName == "vcmpeqq_n_s8" || AliasName == "vcmpeqq";
case ARM::BI__builtin_arm_mve_vcmpeqq_n_u16:
return AliasName == "vcmpeqq_n_u16" || AliasName == "vcmpeqq";
case ARM::BI__builtin_arm_mve_vcmpeqq_n_u32:
return AliasName == "vcmpeqq_n_u32" || AliasName == "vcmpeqq";
case ARM::BI__builtin_arm_mve_vcmpeqq_n_u8:
return AliasName == "vcmpeqq_n_u8" || AliasName == "vcmpeqq";
case ARM::BI__builtin_arm_mve_vcmpeqq_s16:
return AliasName == "vcmpeqq_s16" || AliasName == "vcmpeqq";
case ARM::BI__builtin_arm_mve_vcmpeqq_s32:
return AliasName == "vcmpeqq_s32" || AliasName == "vcmpeqq";
case ARM::BI__builtin_arm_mve_vcmpeqq_s8:
return AliasName == "vcmpeqq_s8" || AliasName == "vcmpeqq";
case ARM::BI__builtin_arm_mve_vcmpeqq_u16:
return AliasName == "vcmpeqq_u16" || AliasName == "vcmpeqq";
case ARM::BI__builtin_arm_mve_vcmpeqq_u32:
return AliasName == "vcmpeqq_u32" || AliasName == "vcmpeqq";
case ARM::BI__builtin_arm_mve_vcmpeqq_u8:
return AliasName == "vcmpeqq_u8" || AliasName == "vcmpeqq";
case ARM::BI__builtin_arm_mve_vcmpgeq_f16:
return AliasName == "vcmpgeq_f16" || AliasName == "vcmpgeq";
case ARM::BI__builtin_arm_mve_vcmpgeq_f32:
return AliasName == "vcmpgeq_f32" || AliasName == "vcmpgeq";
case ARM::BI__builtin_arm_mve_vcmpgeq_m_f16:
return AliasName == "vcmpgeq_m_f16" || AliasName == "vcmpgeq_m";
case ARM::BI__builtin_arm_mve_vcmpgeq_m_f32:
return AliasName == "vcmpgeq_m_f32" || AliasName == "vcmpgeq_m";
case ARM::BI__builtin_arm_mve_vcmpgeq_m_n_f16:
return AliasName == "vcmpgeq_m_n_f16" || AliasName == "vcmpgeq_m";
case ARM::BI__builtin_arm_mve_vcmpgeq_m_n_f32:
return AliasName == "vcmpgeq_m_n_f32" || AliasName == "vcmpgeq_m";
case ARM::BI__builtin_arm_mve_vcmpgeq_m_n_s16:
return AliasName == "vcmpgeq_m_n_s16" || AliasName == "vcmpgeq_m";
case ARM::BI__builtin_arm_mve_vcmpgeq_m_n_s32:
return AliasName == "vcmpgeq_m_n_s32" || AliasName == "vcmpgeq_m";
case ARM::BI__builtin_arm_mve_vcmpgeq_m_n_s8:
return AliasName == "vcmpgeq_m_n_s8" || AliasName == "vcmpgeq_m";
case ARM::BI__builtin_arm_mve_vcmpgeq_m_s16:
return AliasName == "vcmpgeq_m_s16" || AliasName == "vcmpgeq_m";
case ARM::BI__builtin_arm_mve_vcmpgeq_m_s32:
return AliasName == "vcmpgeq_m_s32" || AliasName == "vcmpgeq_m";
case ARM::BI__builtin_arm_mve_vcmpgeq_m_s8:
return AliasName == "vcmpgeq_m_s8" || AliasName == "vcmpgeq_m";
case ARM::BI__builtin_arm_mve_vcmpgeq_n_f16:
return AliasName == "vcmpgeq_n_f16" || AliasName == "vcmpgeq";
case ARM::BI__builtin_arm_mve_vcmpgeq_n_f32:
return AliasName == "vcmpgeq_n_f32" || AliasName == "vcmpgeq";
case ARM::BI__builtin_arm_mve_vcmpgeq_n_s16:
return AliasName == "vcmpgeq_n_s16" || AliasName == "vcmpgeq";
case ARM::BI__builtin_arm_mve_vcmpgeq_n_s32:
return AliasName == "vcmpgeq_n_s32" || AliasName == "vcmpgeq";
case ARM::BI__builtin_arm_mve_vcmpgeq_n_s8:
return AliasName == "vcmpgeq_n_s8" || AliasName == "vcmpgeq";
case ARM::BI__builtin_arm_mve_vcmpgeq_s16:
return AliasName == "vcmpgeq_s16" || AliasName == "vcmpgeq";
case ARM::BI__builtin_arm_mve_vcmpgeq_s32:
return AliasName == "vcmpgeq_s32" || AliasName == "vcmpgeq";
case ARM::BI__builtin_arm_mve_vcmpgeq_s8:
return AliasName == "vcmpgeq_s8" || AliasName == "vcmpgeq";
case ARM::BI__builtin_arm_mve_vcmpgtq_f16:
return AliasName == "vcmpgtq_f16" || AliasName == "vcmpgtq";
case ARM::BI__builtin_arm_mve_vcmpgtq_f32:
return AliasName == "vcmpgtq_f32" || AliasName == "vcmpgtq";
case ARM::BI__builtin_arm_mve_vcmpgtq_m_f16:
return AliasName == "vcmpgtq_m_f16" || AliasName == "vcmpgtq_m";
case ARM::BI__builtin_arm_mve_vcmpgtq_m_f32:
return AliasName == "vcmpgtq_m_f32" || AliasName == "vcmpgtq_m";
case ARM::BI__builtin_arm_mve_vcmpgtq_m_n_f16:
return AliasName == "vcmpgtq_m_n_f16" || AliasName == "vcmpgtq_m";
case ARM::BI__builtin_arm_mve_vcmpgtq_m_n_f32:
return AliasName == "vcmpgtq_m_n_f32" || AliasName == "vcmpgtq_m";
case ARM::BI__builtin_arm_mve_vcmpgtq_m_n_s16:
return AliasName == "vcmpgtq_m_n_s16" || AliasName == "vcmpgtq_m";
case ARM::BI__builtin_arm_mve_vcmpgtq_m_n_s32:
return AliasName == "vcmpgtq_m_n_s32" || AliasName == "vcmpgtq_m";
case ARM::BI__builtin_arm_mve_vcmpgtq_m_n_s8:
return AliasName == "vcmpgtq_m_n_s8" || AliasName == "vcmpgtq_m";
case ARM::BI__builtin_arm_mve_vcmpgtq_m_s16:
return AliasName == "vcmpgtq_m_s16" || AliasName == "vcmpgtq_m";
case ARM::BI__builtin_arm_mve_vcmpgtq_m_s32:
return AliasName == "vcmpgtq_m_s32" || AliasName == "vcmpgtq_m";
case ARM::BI__builtin_arm_mve_vcmpgtq_m_s8:
return AliasName == "vcmpgtq_m_s8" || AliasName == "vcmpgtq_m";
case ARM::BI__builtin_arm_mve_vcmpgtq_n_f16:
return AliasName == "vcmpgtq_n_f16" || AliasName == "vcmpgtq";
case ARM::BI__builtin_arm_mve_vcmpgtq_n_f32:
return AliasName == "vcmpgtq_n_f32" || AliasName == "vcmpgtq";
case ARM::BI__builtin_arm_mve_vcmpgtq_n_s16:
return AliasName == "vcmpgtq_n_s16" || AliasName == "vcmpgtq";
case ARM::BI__builtin_arm_mve_vcmpgtq_n_s32:
return AliasName == "vcmpgtq_n_s32" || AliasName == "vcmpgtq";
case ARM::BI__builtin_arm_mve_vcmpgtq_n_s8:
return AliasName == "vcmpgtq_n_s8" || AliasName == "vcmpgtq";
case ARM::BI__builtin_arm_mve_vcmpgtq_s16:
return AliasName == "vcmpgtq_s16" || AliasName == "vcmpgtq";
case ARM::BI__builtin_arm_mve_vcmpgtq_s32:
return AliasName == "vcmpgtq_s32" || AliasName == "vcmpgtq";
case ARM::BI__builtin_arm_mve_vcmpgtq_s8:
return AliasName == "vcmpgtq_s8" || AliasName == "vcmpgtq";
case ARM::BI__builtin_arm_mve_vcmphiq_m_n_u16:
return AliasName == "vcmphiq_m_n_u16" || AliasName == "vcmphiq_m";
case ARM::BI__builtin_arm_mve_vcmphiq_m_n_u32:
return AliasName == "vcmphiq_m_n_u32" || AliasName == "vcmphiq_m";
case ARM::BI__builtin_arm_mve_vcmphiq_m_n_u8:
return AliasName == "vcmphiq_m_n_u8" || AliasName == "vcmphiq_m";
case ARM::BI__builtin_arm_mve_vcmphiq_m_u16:
return AliasName == "vcmphiq_m_u16" || AliasName == "vcmphiq_m";
case ARM::BI__builtin_arm_mve_vcmphiq_m_u32:
return AliasName == "vcmphiq_m_u32" || AliasName == "vcmphiq_m";
case ARM::BI__builtin_arm_mve_vcmphiq_m_u8:
return AliasName == "vcmphiq_m_u8" || AliasName == "vcmphiq_m";
case ARM::BI__builtin_arm_mve_vcmphiq_n_u16:
return AliasName == "vcmphiq_n_u16" || AliasName == "vcmphiq";
case ARM::BI__builtin_arm_mve_vcmphiq_n_u32:
return AliasName == "vcmphiq_n_u32" || AliasName == "vcmphiq";
case ARM::BI__builtin_arm_mve_vcmphiq_n_u8:
return AliasName == "vcmphiq_n_u8" || AliasName == "vcmphiq";
case ARM::BI__builtin_arm_mve_vcmphiq_u16:
return AliasName == "vcmphiq_u16" || AliasName == "vcmphiq";
case ARM::BI__builtin_arm_mve_vcmphiq_u32:
return AliasName == "vcmphiq_u32" || AliasName == "vcmphiq";
case ARM::BI__builtin_arm_mve_vcmphiq_u8:
return AliasName == "vcmphiq_u8" || AliasName == "vcmphiq";
case ARM::BI__builtin_arm_mve_vcmpleq_f16:
return AliasName == "vcmpleq_f16" || AliasName == "vcmpleq";
case ARM::BI__builtin_arm_mve_vcmpleq_f32:
return AliasName == "vcmpleq_f32" || AliasName == "vcmpleq";
case ARM::BI__builtin_arm_mve_vcmpleq_m_f16:
return AliasName == "vcmpleq_m_f16" || AliasName == "vcmpleq_m";
case ARM::BI__builtin_arm_mve_vcmpleq_m_f32:
return AliasName == "vcmpleq_m_f32" || AliasName == "vcmpleq_m";
case ARM::BI__builtin_arm_mve_vcmpleq_m_n_f16:
return AliasName == "vcmpleq_m_n_f16" || AliasName == "vcmpleq_m";
case ARM::BI__builtin_arm_mve_vcmpleq_m_n_f32:
return AliasName == "vcmpleq_m_n_f32" || AliasName == "vcmpleq_m";
case ARM::BI__builtin_arm_mve_vcmpleq_m_n_s16:
return AliasName == "vcmpleq_m_n_s16" || AliasName == "vcmpleq_m";
case ARM::BI__builtin_arm_mve_vcmpleq_m_n_s32:
return AliasName == "vcmpleq_m_n_s32" || AliasName == "vcmpleq_m";
case ARM::BI__builtin_arm_mve_vcmpleq_m_n_s8:
return AliasName == "vcmpleq_m_n_s8" || AliasName == "vcmpleq_m";
case ARM::BI__builtin_arm_mve_vcmpleq_m_s16:
return AliasName == "vcmpleq_m_s16" || AliasName == "vcmpleq_m";
case ARM::BI__builtin_arm_mve_vcmpleq_m_s32:
return AliasName == "vcmpleq_m_s32" || AliasName == "vcmpleq_m";
case ARM::BI__builtin_arm_mve_vcmpleq_m_s8:
return AliasName == "vcmpleq_m_s8" || AliasName == "vcmpleq_m";
case ARM::BI__builtin_arm_mve_vcmpleq_n_f16:
return AliasName == "vcmpleq_n_f16" || AliasName == "vcmpleq";
case ARM::BI__builtin_arm_mve_vcmpleq_n_f32:
return AliasName == "vcmpleq_n_f32" || AliasName == "vcmpleq";
case ARM::BI__builtin_arm_mve_vcmpleq_n_s16:
return AliasName == "vcmpleq_n_s16" || AliasName == "vcmpleq";
case ARM::BI__builtin_arm_mve_vcmpleq_n_s32:
return AliasName == "vcmpleq_n_s32" || AliasName == "vcmpleq";
case ARM::BI__builtin_arm_mve_vcmpleq_n_s8:
return AliasName == "vcmpleq_n_s8" || AliasName == "vcmpleq";
case ARM::BI__builtin_arm_mve_vcmpleq_s16:
return AliasName == "vcmpleq_s16" || AliasName == "vcmpleq";
case ARM::BI__builtin_arm_mve_vcmpleq_s32:
return AliasName == "vcmpleq_s32" || AliasName == "vcmpleq";
case ARM::BI__builtin_arm_mve_vcmpleq_s8:
return AliasName == "vcmpleq_s8" || AliasName == "vcmpleq";
case ARM::BI__builtin_arm_mve_vcmpltq_f16:
return AliasName == "vcmpltq_f16" || AliasName == "vcmpltq";
case ARM::BI__builtin_arm_mve_vcmpltq_f32:
return AliasName == "vcmpltq_f32" || AliasName == "vcmpltq";
case ARM::BI__builtin_arm_mve_vcmpltq_m_f16:
return AliasName == "vcmpltq_m_f16" || AliasName == "vcmpltq_m";
case ARM::BI__builtin_arm_mve_vcmpltq_m_f32:
return AliasName == "vcmpltq_m_f32" || AliasName == "vcmpltq_m";
case ARM::BI__builtin_arm_mve_vcmpltq_m_n_f16:
return AliasName == "vcmpltq_m_n_f16" || AliasName == "vcmpltq_m";
case ARM::BI__builtin_arm_mve_vcmpltq_m_n_f32:
return AliasName == "vcmpltq_m_n_f32" || AliasName == "vcmpltq_m";
case ARM::BI__builtin_arm_mve_vcmpltq_m_n_s16:
return AliasName == "vcmpltq_m_n_s16" || AliasName == "vcmpltq_m";
case ARM::BI__builtin_arm_mve_vcmpltq_m_n_s32:
return AliasName == "vcmpltq_m_n_s32" || AliasName == "vcmpltq_m";
case ARM::BI__builtin_arm_mve_vcmpltq_m_n_s8:
return AliasName == "vcmpltq_m_n_s8" || AliasName == "vcmpltq_m";
case ARM::BI__builtin_arm_mve_vcmpltq_m_s16:
return AliasName == "vcmpltq_m_s16" || AliasName == "vcmpltq_m";
case ARM::BI__builtin_arm_mve_vcmpltq_m_s32:
return AliasName == "vcmpltq_m_s32" || AliasName == "vcmpltq_m";
case ARM::BI__builtin_arm_mve_vcmpltq_m_s8:
return AliasName == "vcmpltq_m_s8" || AliasName == "vcmpltq_m";
case ARM::BI__builtin_arm_mve_vcmpltq_n_f16:
return AliasName == "vcmpltq_n_f16" || AliasName == "vcmpltq";
case ARM::BI__builtin_arm_mve_vcmpltq_n_f32:
return AliasName == "vcmpltq_n_f32" || AliasName == "vcmpltq";
case ARM::BI__builtin_arm_mve_vcmpltq_n_s16:
return AliasName == "vcmpltq_n_s16" || AliasName == "vcmpltq";
case ARM::BI__builtin_arm_mve_vcmpltq_n_s32:
return AliasName == "vcmpltq_n_s32" || AliasName == "vcmpltq";
case ARM::BI__builtin_arm_mve_vcmpltq_n_s8:
return AliasName == "vcmpltq_n_s8" || AliasName == "vcmpltq";
case ARM::BI__builtin_arm_mve_vcmpltq_s16:
return AliasName == "vcmpltq_s16" || AliasName == "vcmpltq";
case ARM::BI__builtin_arm_mve_vcmpltq_s32:
return AliasName == "vcmpltq_s32" || AliasName == "vcmpltq";
case ARM::BI__builtin_arm_mve_vcmpltq_s8:
return AliasName == "vcmpltq_s8" || AliasName == "vcmpltq";
case ARM::BI__builtin_arm_mve_vcmpneq_f16:
return AliasName == "vcmpneq_f16" || AliasName == "vcmpneq";
case ARM::BI__builtin_arm_mve_vcmpneq_f32:
return AliasName == "vcmpneq_f32" || AliasName == "vcmpneq";
case ARM::BI__builtin_arm_mve_vcmpneq_m_f16:
return AliasName == "vcmpneq_m_f16" || AliasName == "vcmpneq_m";
case ARM::BI__builtin_arm_mve_vcmpneq_m_f32:
return AliasName == "vcmpneq_m_f32" || AliasName == "vcmpneq_m";
case ARM::BI__builtin_arm_mve_vcmpneq_m_n_f16:
return AliasName == "vcmpneq_m_n_f16" || AliasName == "vcmpneq_m";
case ARM::BI__builtin_arm_mve_vcmpneq_m_n_f32:
return AliasName == "vcmpneq_m_n_f32" || AliasName == "vcmpneq_m";
case ARM::BI__builtin_arm_mve_vcmpneq_m_n_s16:
return AliasName == "vcmpneq_m_n_s16" || AliasName == "vcmpneq_m";
case ARM::BI__builtin_arm_mve_vcmpneq_m_n_s32:
return AliasName == "vcmpneq_m_n_s32" || AliasName == "vcmpneq_m";
case ARM::BI__builtin_arm_mve_vcmpneq_m_n_s8:
return AliasName == "vcmpneq_m_n_s8" || AliasName == "vcmpneq_m";
case ARM::BI__builtin_arm_mve_vcmpneq_m_n_u16:
return AliasName == "vcmpneq_m_n_u16" || AliasName == "vcmpneq_m";
case ARM::BI__builtin_arm_mve_vcmpneq_m_n_u32:
return AliasName == "vcmpneq_m_n_u32" || AliasName == "vcmpneq_m";
case ARM::BI__builtin_arm_mve_vcmpneq_m_n_u8:
return AliasName == "vcmpneq_m_n_u8" || AliasName == "vcmpneq_m";
case ARM::BI__builtin_arm_mve_vcmpneq_m_s16:
return AliasName == "vcmpneq_m_s16" || AliasName == "vcmpneq_m";
case ARM::BI__builtin_arm_mve_vcmpneq_m_s32:
return AliasName == "vcmpneq_m_s32" || AliasName == "vcmpneq_m";
case ARM::BI__builtin_arm_mve_vcmpneq_m_s8:
return AliasName == "vcmpneq_m_s8" || AliasName == "vcmpneq_m";
case ARM::BI__builtin_arm_mve_vcmpneq_m_u16:
return AliasName == "vcmpneq_m_u16" || AliasName == "vcmpneq_m";
case ARM::BI__builtin_arm_mve_vcmpneq_m_u32:
return AliasName == "vcmpneq_m_u32" || AliasName == "vcmpneq_m";
case ARM::BI__builtin_arm_mve_vcmpneq_m_u8:
return AliasName == "vcmpneq_m_u8" || AliasName == "vcmpneq_m";
case ARM::BI__builtin_arm_mve_vcmpneq_n_f16:
return AliasName == "vcmpneq_n_f16" || AliasName == "vcmpneq";
case ARM::BI__builtin_arm_mve_vcmpneq_n_f32:
return AliasName == "vcmpneq_n_f32" || AliasName == "vcmpneq";
case ARM::BI__builtin_arm_mve_vcmpneq_n_s16:
return AliasName == "vcmpneq_n_s16" || AliasName == "vcmpneq";
case ARM::BI__builtin_arm_mve_vcmpneq_n_s32:
return AliasName == "vcmpneq_n_s32" || AliasName == "vcmpneq";
case ARM::BI__builtin_arm_mve_vcmpneq_n_s8:
return AliasName == "vcmpneq_n_s8" || AliasName == "vcmpneq";
case ARM::BI__builtin_arm_mve_vcmpneq_n_u16:
return AliasName == "vcmpneq_n_u16" || AliasName == "vcmpneq";
case ARM::BI__builtin_arm_mve_vcmpneq_n_u32:
return AliasName == "vcmpneq_n_u32" || AliasName == "vcmpneq";
case ARM::BI__builtin_arm_mve_vcmpneq_n_u8:
return AliasName == "vcmpneq_n_u8" || AliasName == "vcmpneq";
case ARM::BI__builtin_arm_mve_vcmpneq_s16:
return AliasName == "vcmpneq_s16" || AliasName == "vcmpneq";
case ARM::BI__builtin_arm_mve_vcmpneq_s32:
return AliasName == "vcmpneq_s32" || AliasName == "vcmpneq";
case ARM::BI__builtin_arm_mve_vcmpneq_s8:
return AliasName == "vcmpneq_s8" || AliasName == "vcmpneq";
case ARM::BI__builtin_arm_mve_vcmpneq_u16:
return AliasName == "vcmpneq_u16" || AliasName == "vcmpneq";
case ARM::BI__builtin_arm_mve_vcmpneq_u32:
return AliasName == "vcmpneq_u32" || AliasName == "vcmpneq";
case ARM::BI__builtin_arm_mve_vcmpneq_u8:
return AliasName == "vcmpneq_u8" || AliasName == "vcmpneq";
case ARM::BI__builtin_arm_mve_vcmulq_f16:
return AliasName == "vcmulq_f16" || AliasName == "vcmulq";
case ARM::BI__builtin_arm_mve_vcmulq_f32:
return AliasName == "vcmulq_f32" || AliasName == "vcmulq";
case ARM::BI__builtin_arm_mve_vcmulq_m_f16:
return AliasName == "vcmulq_m_f16" || AliasName == "vcmulq_m";
case ARM::BI__builtin_arm_mve_vcmulq_m_f32:
return AliasName == "vcmulq_m_f32" || AliasName == "vcmulq_m";
case ARM::BI__builtin_arm_mve_vcmulq_rot180_f16:
return AliasName == "vcmulq_rot180_f16" || AliasName == "vcmulq_rot180";
case ARM::BI__builtin_arm_mve_vcmulq_rot180_f32:
return AliasName == "vcmulq_rot180_f32" || AliasName == "vcmulq_rot180";
case ARM::BI__builtin_arm_mve_vcmulq_rot180_m_f16:
return AliasName == "vcmulq_rot180_m_f16" || AliasName == "vcmulq_rot180_m";
case ARM::BI__builtin_arm_mve_vcmulq_rot180_m_f32:
return AliasName == "vcmulq_rot180_m_f32" || AliasName == "vcmulq_rot180_m";
case ARM::BI__builtin_arm_mve_vcmulq_rot180_x_f16:
return AliasName == "vcmulq_rot180_x_f16" || AliasName == "vcmulq_rot180_x";
case ARM::BI__builtin_arm_mve_vcmulq_rot180_x_f32:
return AliasName == "vcmulq_rot180_x_f32" || AliasName == "vcmulq_rot180_x";
case ARM::BI__builtin_arm_mve_vcmulq_rot270_f16:
return AliasName == "vcmulq_rot270_f16" || AliasName == "vcmulq_rot270";
case ARM::BI__builtin_arm_mve_vcmulq_rot270_f32:
return AliasName == "vcmulq_rot270_f32" || AliasName == "vcmulq_rot270";
case ARM::BI__builtin_arm_mve_vcmulq_rot270_m_f16:
return AliasName == "vcmulq_rot270_m_f16" || AliasName == "vcmulq_rot270_m";
case ARM::BI__builtin_arm_mve_vcmulq_rot270_m_f32:
return AliasName == "vcmulq_rot270_m_f32" || AliasName == "vcmulq_rot270_m";
case ARM::BI__builtin_arm_mve_vcmulq_rot270_x_f16:
return AliasName == "vcmulq_rot270_x_f16" || AliasName == "vcmulq_rot270_x";
case ARM::BI__builtin_arm_mve_vcmulq_rot270_x_f32:
return AliasName == "vcmulq_rot270_x_f32" || AliasName == "vcmulq_rot270_x";
case ARM::BI__builtin_arm_mve_vcmulq_rot90_f16:
return AliasName == "vcmulq_rot90_f16" || AliasName == "vcmulq_rot90";
case ARM::BI__builtin_arm_mve_vcmulq_rot90_f32:
return AliasName == "vcmulq_rot90_f32" || AliasName == "vcmulq_rot90";
case ARM::BI__builtin_arm_mve_vcmulq_rot90_m_f16:
return AliasName == "vcmulq_rot90_m_f16" || AliasName == "vcmulq_rot90_m";
case ARM::BI__builtin_arm_mve_vcmulq_rot90_m_f32:
return AliasName == "vcmulq_rot90_m_f32" || AliasName == "vcmulq_rot90_m";
case ARM::BI__builtin_arm_mve_vcmulq_rot90_x_f16:
return AliasName == "vcmulq_rot90_x_f16" || AliasName == "vcmulq_rot90_x";
case ARM::BI__builtin_arm_mve_vcmulq_rot90_x_f32:
return AliasName == "vcmulq_rot90_x_f32" || AliasName == "vcmulq_rot90_x";
case ARM::BI__builtin_arm_mve_vcmulq_x_f16:
return AliasName == "vcmulq_x_f16" || AliasName == "vcmulq_x";
case ARM::BI__builtin_arm_mve_vcmulq_x_f32:
return AliasName == "vcmulq_x_f32" || AliasName == "vcmulq_x";
case ARM::BI__builtin_arm_mve_vcreateq_f16:
return AliasName == "vcreateq_f16";
case ARM::BI__builtin_arm_mve_vcreateq_f32:
return AliasName == "vcreateq_f32";
case ARM::BI__builtin_arm_mve_vcreateq_s16:
return AliasName == "vcreateq_s16";
case ARM::BI__builtin_arm_mve_vcreateq_s32:
return AliasName == "vcreateq_s32";
case ARM::BI__builtin_arm_mve_vcreateq_s64:
return AliasName == "vcreateq_s64";
case ARM::BI__builtin_arm_mve_vcreateq_s8:
return AliasName == "vcreateq_s8";
case ARM::BI__builtin_arm_mve_vcreateq_u16:
return AliasName == "vcreateq_u16";
case ARM::BI__builtin_arm_mve_vcreateq_u32:
return AliasName == "vcreateq_u32";
case ARM::BI__builtin_arm_mve_vcreateq_u64:
return AliasName == "vcreateq_u64";
case ARM::BI__builtin_arm_mve_vcreateq_u8:
return AliasName == "vcreateq_u8";
case ARM::BI__builtin_arm_mve_vctp16q:
return AliasName == "vctp16q";
case ARM::BI__builtin_arm_mve_vctp16q_m:
return AliasName == "vctp16q_m";
case ARM::BI__builtin_arm_mve_vctp32q:
return AliasName == "vctp32q";
case ARM::BI__builtin_arm_mve_vctp32q_m:
return AliasName == "vctp32q_m";
case ARM::BI__builtin_arm_mve_vctp64q:
return AliasName == "vctp64q";
case ARM::BI__builtin_arm_mve_vctp64q_m:
return AliasName == "vctp64q_m";
case ARM::BI__builtin_arm_mve_vctp8q:
return AliasName == "vctp8q";
case ARM::BI__builtin_arm_mve_vctp8q_m:
return AliasName == "vctp8q_m";
case ARM::BI__builtin_arm_mve_vcvtbq_f16_f32:
return AliasName == "vcvtbq_f16_f32";
case ARM::BI__builtin_arm_mve_vcvtbq_m_f16_f32:
return AliasName == "vcvtbq_m_f16_f32";
case ARM::BI__builtin_arm_mve_vcvttq_f16_f32:
return AliasName == "vcvttq_f16_f32";
case ARM::BI__builtin_arm_mve_vcvttq_m_f16_f32:
return AliasName == "vcvttq_m_f16_f32";
case ARM::BI__builtin_arm_mve_veorq_f16:
return AliasName == "veorq_f16" || AliasName == "veorq";
case ARM::BI__builtin_arm_mve_veorq_f32:
return AliasName == "veorq_f32" || AliasName == "veorq";
case ARM::BI__builtin_arm_mve_veorq_m_f16:
return AliasName == "veorq_m_f16" || AliasName == "veorq_m";
case ARM::BI__builtin_arm_mve_veorq_m_f32:
return AliasName == "veorq_m_f32" || AliasName == "veorq_m";
case ARM::BI__builtin_arm_mve_veorq_m_s16:
return AliasName == "veorq_m_s16" || AliasName == "veorq_m";
case ARM::BI__builtin_arm_mve_veorq_m_s32:
return AliasName == "veorq_m_s32" || AliasName == "veorq_m";
case ARM::BI__builtin_arm_mve_veorq_m_s8:
return AliasName == "veorq_m_s8" || AliasName == "veorq_m";
case ARM::BI__builtin_arm_mve_veorq_m_u16:
return AliasName == "veorq_m_u16" || AliasName == "veorq_m";
case ARM::BI__builtin_arm_mve_veorq_m_u32:
return AliasName == "veorq_m_u32" || AliasName == "veorq_m";
case ARM::BI__builtin_arm_mve_veorq_m_u8:
return AliasName == "veorq_m_u8" || AliasName == "veorq_m";
case ARM::BI__builtin_arm_mve_veorq_s16:
return AliasName == "veorq_s16" || AliasName == "veorq";
case ARM::BI__builtin_arm_mve_veorq_s32:
return AliasName == "veorq_s32" || AliasName == "veorq";
case ARM::BI__builtin_arm_mve_veorq_s8:
return AliasName == "veorq_s8" || AliasName == "veorq";
case ARM::BI__builtin_arm_mve_veorq_u16:
return AliasName == "veorq_u16" || AliasName == "veorq";
case ARM::BI__builtin_arm_mve_veorq_u32:
return AliasName == "veorq_u32" || AliasName == "veorq";
case ARM::BI__builtin_arm_mve_veorq_u8:
return AliasName == "veorq_u8" || AliasName == "veorq";
case ARM::BI__builtin_arm_mve_veorq_x_f16:
return AliasName == "veorq_x_f16" || AliasName == "veorq_x";
case ARM::BI__builtin_arm_mve_veorq_x_f32:
return AliasName == "veorq_x_f32" || AliasName == "veorq_x";
case ARM::BI__builtin_arm_mve_veorq_x_s16:
return AliasName == "veorq_x_s16" || AliasName == "veorq_x";
case ARM::BI__builtin_arm_mve_veorq_x_s32:
return AliasName == "veorq_x_s32" || AliasName == "veorq_x";
case ARM::BI__builtin_arm_mve_veorq_x_s8:
return AliasName == "veorq_x_s8" || AliasName == "veorq_x";
case ARM::BI__builtin_arm_mve_veorq_x_u16:
return AliasName == "veorq_x_u16" || AliasName == "veorq_x";
case ARM::BI__builtin_arm_mve_veorq_x_u32:
return AliasName == "veorq_x_u32" || AliasName == "veorq_x";
case ARM::BI__builtin_arm_mve_veorq_x_u8:
return AliasName == "veorq_x_u8" || AliasName == "veorq_x";
case ARM::BI__builtin_arm_mve_vgetq_lane_f16:
return AliasName == "vgetq_lane_f16" || AliasName == "vgetq_lane";
case ARM::BI__builtin_arm_mve_vgetq_lane_f32:
return AliasName == "vgetq_lane_f32" || AliasName == "vgetq_lane";
case ARM::BI__builtin_arm_mve_vgetq_lane_s16:
return AliasName == "vgetq_lane_s16" || AliasName == "vgetq_lane";
case ARM::BI__builtin_arm_mve_vgetq_lane_s32:
return AliasName == "vgetq_lane_s32" || AliasName == "vgetq_lane";
case ARM::BI__builtin_arm_mve_vgetq_lane_s64:
return AliasName == "vgetq_lane_s64" || AliasName == "vgetq_lane";
case ARM::BI__builtin_arm_mve_vgetq_lane_s8:
return AliasName == "vgetq_lane_s8" || AliasName == "vgetq_lane";
case ARM::BI__builtin_arm_mve_vgetq_lane_u16:
return AliasName == "vgetq_lane_u16" || AliasName == "vgetq_lane";
case ARM::BI__builtin_arm_mve_vgetq_lane_u32:
return AliasName == "vgetq_lane_u32" || AliasName == "vgetq_lane";
case ARM::BI__builtin_arm_mve_vgetq_lane_u64:
return AliasName == "vgetq_lane_u64" || AliasName == "vgetq_lane";
case ARM::BI__builtin_arm_mve_vgetq_lane_u8:
return AliasName == "vgetq_lane_u8" || AliasName == "vgetq_lane";
case ARM::BI__builtin_arm_mve_vhaddq_m_s16:
return AliasName == "vhaddq_m_s16" || AliasName == "vhaddq_m";
case ARM::BI__builtin_arm_mve_vhaddq_m_s32:
return AliasName == "vhaddq_m_s32" || AliasName == "vhaddq_m";
case ARM::BI__builtin_arm_mve_vhaddq_m_s8:
return AliasName == "vhaddq_m_s8" || AliasName == "vhaddq_m";
case ARM::BI__builtin_arm_mve_vhaddq_m_u16:
return AliasName == "vhaddq_m_u16" || AliasName == "vhaddq_m";
case ARM::BI__builtin_arm_mve_vhaddq_m_u32:
return AliasName == "vhaddq_m_u32" || AliasName == "vhaddq_m";
case ARM::BI__builtin_arm_mve_vhaddq_m_u8:
return AliasName == "vhaddq_m_u8" || AliasName == "vhaddq_m";
case ARM::BI__builtin_arm_mve_vhaddq_s16:
return AliasName == "vhaddq_s16" || AliasName == "vhaddq";
case ARM::BI__builtin_arm_mve_vhaddq_s32:
return AliasName == "vhaddq_s32" || AliasName == "vhaddq";
case ARM::BI__builtin_arm_mve_vhaddq_s8:
return AliasName == "vhaddq_s8" || AliasName == "vhaddq";
case ARM::BI__builtin_arm_mve_vhaddq_u16:
return AliasName == "vhaddq_u16" || AliasName == "vhaddq";
case ARM::BI__builtin_arm_mve_vhaddq_u32:
return AliasName == "vhaddq_u32" || AliasName == "vhaddq";
case ARM::BI__builtin_arm_mve_vhaddq_u8:
return AliasName == "vhaddq_u8" || AliasName == "vhaddq";
case ARM::BI__builtin_arm_mve_vhaddq_x_s16:
return AliasName == "vhaddq_x_s16" || AliasName == "vhaddq_x";
case ARM::BI__builtin_arm_mve_vhaddq_x_s32:
return AliasName == "vhaddq_x_s32" || AliasName == "vhaddq_x";
case ARM::BI__builtin_arm_mve_vhaddq_x_s8:
return AliasName == "vhaddq_x_s8" || AliasName == "vhaddq_x";
case ARM::BI__builtin_arm_mve_vhaddq_x_u16:
return AliasName == "vhaddq_x_u16" || AliasName == "vhaddq_x";
case ARM::BI__builtin_arm_mve_vhaddq_x_u32:
return AliasName == "vhaddq_x_u32" || AliasName == "vhaddq_x";
case ARM::BI__builtin_arm_mve_vhaddq_x_u8:
return AliasName == "vhaddq_x_u8" || AliasName == "vhaddq_x";
case ARM::BI__builtin_arm_mve_vhcaddq_rot270_m_s16:
return AliasName == "vhcaddq_rot270_m_s16" || AliasName == "vhcaddq_rot270_m";
case ARM::BI__builtin_arm_mve_vhcaddq_rot270_m_s32:
return AliasName == "vhcaddq_rot270_m_s32" || AliasName == "vhcaddq_rot270_m";
case ARM::BI__builtin_arm_mve_vhcaddq_rot270_m_s8:
return AliasName == "vhcaddq_rot270_m_s8" || AliasName == "vhcaddq_rot270_m";
case ARM::BI__builtin_arm_mve_vhcaddq_rot270_s16:
return AliasName == "vhcaddq_rot270_s16" || AliasName == "vhcaddq_rot270";
case ARM::BI__builtin_arm_mve_vhcaddq_rot270_s32:
return AliasName == "vhcaddq_rot270_s32" || AliasName == "vhcaddq_rot270";
case ARM::BI__builtin_arm_mve_vhcaddq_rot270_s8:
return AliasName == "vhcaddq_rot270_s8" || AliasName == "vhcaddq_rot270";
case ARM::BI__builtin_arm_mve_vhcaddq_rot270_x_s16:
return AliasName == "vhcaddq_rot270_x_s16" || AliasName == "vhcaddq_rot270_x";
case ARM::BI__builtin_arm_mve_vhcaddq_rot270_x_s32:
return AliasName == "vhcaddq_rot270_x_s32" || AliasName == "vhcaddq_rot270_x";
case ARM::BI__builtin_arm_mve_vhcaddq_rot270_x_s8:
return AliasName == "vhcaddq_rot270_x_s8" || AliasName == "vhcaddq_rot270_x";
case ARM::BI__builtin_arm_mve_vhcaddq_rot90_m_s16:
return AliasName == "vhcaddq_rot90_m_s16" || AliasName == "vhcaddq_rot90_m";
case ARM::BI__builtin_arm_mve_vhcaddq_rot90_m_s32:
return AliasName == "vhcaddq_rot90_m_s32" || AliasName == "vhcaddq_rot90_m";
case ARM::BI__builtin_arm_mve_vhcaddq_rot90_m_s8:
return AliasName == "vhcaddq_rot90_m_s8" || AliasName == "vhcaddq_rot90_m";
case ARM::BI__builtin_arm_mve_vhcaddq_rot90_s16:
return AliasName == "vhcaddq_rot90_s16" || AliasName == "vhcaddq_rot90";
case ARM::BI__builtin_arm_mve_vhcaddq_rot90_s32:
return AliasName == "vhcaddq_rot90_s32" || AliasName == "vhcaddq_rot90";
case ARM::BI__builtin_arm_mve_vhcaddq_rot90_s8:
return AliasName == "vhcaddq_rot90_s8" || AliasName == "vhcaddq_rot90";
case ARM::BI__builtin_arm_mve_vhcaddq_rot90_x_s16:
return AliasName == "vhcaddq_rot90_x_s16" || AliasName == "vhcaddq_rot90_x";
case ARM::BI__builtin_arm_mve_vhcaddq_rot90_x_s32:
return AliasName == "vhcaddq_rot90_x_s32" || AliasName == "vhcaddq_rot90_x";
case ARM::BI__builtin_arm_mve_vhcaddq_rot90_x_s8:
return AliasName == "vhcaddq_rot90_x_s8" || AliasName == "vhcaddq_rot90_x";
case ARM::BI__builtin_arm_mve_vhsubq_m_s16:
return AliasName == "vhsubq_m_s16" || AliasName == "vhsubq_m";
case ARM::BI__builtin_arm_mve_vhsubq_m_s32:
return AliasName == "vhsubq_m_s32" || AliasName == "vhsubq_m";
case ARM::BI__builtin_arm_mve_vhsubq_m_s8:
return AliasName == "vhsubq_m_s8" || AliasName == "vhsubq_m";
case ARM::BI__builtin_arm_mve_vhsubq_m_u16:
return AliasName == "vhsubq_m_u16" || AliasName == "vhsubq_m";
case ARM::BI__builtin_arm_mve_vhsubq_m_u32:
return AliasName == "vhsubq_m_u32" || AliasName == "vhsubq_m";
case ARM::BI__builtin_arm_mve_vhsubq_m_u8:
return AliasName == "vhsubq_m_u8" || AliasName == "vhsubq_m";
case ARM::BI__builtin_arm_mve_vhsubq_s16:
return AliasName == "vhsubq_s16" || AliasName == "vhsubq";
case ARM::BI__builtin_arm_mve_vhsubq_s32:
return AliasName == "vhsubq_s32" || AliasName == "vhsubq";
case ARM::BI__builtin_arm_mve_vhsubq_s8:
return AliasName == "vhsubq_s8" || AliasName == "vhsubq";
case ARM::BI__builtin_arm_mve_vhsubq_u16:
return AliasName == "vhsubq_u16" || AliasName == "vhsubq";
case ARM::BI__builtin_arm_mve_vhsubq_u32:
return AliasName == "vhsubq_u32" || AliasName == "vhsubq";
case ARM::BI__builtin_arm_mve_vhsubq_u8:
return AliasName == "vhsubq_u8" || AliasName == "vhsubq";
case ARM::BI__builtin_arm_mve_vhsubq_x_s16:
return AliasName == "vhsubq_x_s16" || AliasName == "vhsubq_x";
case ARM::BI__builtin_arm_mve_vhsubq_x_s32:
return AliasName == "vhsubq_x_s32" || AliasName == "vhsubq_x";
case ARM::BI__builtin_arm_mve_vhsubq_x_s8:
return AliasName == "vhsubq_x_s8" || AliasName == "vhsubq_x";
case ARM::BI__builtin_arm_mve_vhsubq_x_u16:
return AliasName == "vhsubq_x_u16" || AliasName == "vhsubq_x";
case ARM::BI__builtin_arm_mve_vhsubq_x_u32:
return AliasName == "vhsubq_x_u32" || AliasName == "vhsubq_x";
case ARM::BI__builtin_arm_mve_vhsubq_x_u8:
return AliasName == "vhsubq_x_u8" || AliasName == "vhsubq_x";
case ARM::BI__builtin_arm_mve_vld1q_f16:
return AliasName == "vld1q_f16" || AliasName == "vld1q";
case ARM::BI__builtin_arm_mve_vld1q_f32:
return AliasName == "vld1q_f32" || AliasName == "vld1q";
case ARM::BI__builtin_arm_mve_vld1q_s16:
return AliasName == "vld1q_s16" || AliasName == "vld1q";
case ARM::BI__builtin_arm_mve_vld1q_s32:
return AliasName == "vld1q_s32" || AliasName == "vld1q";
case ARM::BI__builtin_arm_mve_vld1q_s8:
return AliasName == "vld1q_s8" || AliasName == "vld1q";
case ARM::BI__builtin_arm_mve_vld1q_u16:
return AliasName == "vld1q_u16" || AliasName == "vld1q";
case ARM::BI__builtin_arm_mve_vld1q_u32:
return AliasName == "vld1q_u32" || AliasName == "vld1q";
case ARM::BI__builtin_arm_mve_vld1q_u8:
return AliasName == "vld1q_u8" || AliasName == "vld1q";
case ARM::BI__builtin_arm_mve_vld1q_z_f16:
return AliasName == "vld1q_z_f16" || AliasName == "vld1q_z";
case ARM::BI__builtin_arm_mve_vld1q_z_f32:
return AliasName == "vld1q_z_f32" || AliasName == "vld1q_z";
case ARM::BI__builtin_arm_mve_vld1q_z_s16:
return AliasName == "vld1q_z_s16" || AliasName == "vld1q_z";
case ARM::BI__builtin_arm_mve_vld1q_z_s32:
return AliasName == "vld1q_z_s32" || AliasName == "vld1q_z";
case ARM::BI__builtin_arm_mve_vld1q_z_s8:
return AliasName == "vld1q_z_s8" || AliasName == "vld1q_z";
case ARM::BI__builtin_arm_mve_vld1q_z_u16:
return AliasName == "vld1q_z_u16" || AliasName == "vld1q_z";
case ARM::BI__builtin_arm_mve_vld1q_z_u32:
return AliasName == "vld1q_z_u32" || AliasName == "vld1q_z";
case ARM::BI__builtin_arm_mve_vld1q_z_u8:
return AliasName == "vld1q_z_u8" || AliasName == "vld1q_z";
case ARM::BI__builtin_arm_mve_vld2q_f16:
return AliasName == "vld2q_f16" || AliasName == "vld2q";
case ARM::BI__builtin_arm_mve_vld2q_f32:
return AliasName == "vld2q_f32" || AliasName == "vld2q";
case ARM::BI__builtin_arm_mve_vld2q_s16:
return AliasName == "vld2q_s16" || AliasName == "vld2q";
case ARM::BI__builtin_arm_mve_vld2q_s32:
return AliasName == "vld2q_s32" || AliasName == "vld2q";
case ARM::BI__builtin_arm_mve_vld2q_s8:
return AliasName == "vld2q_s8" || AliasName == "vld2q";
case ARM::BI__builtin_arm_mve_vld2q_u16:
return AliasName == "vld2q_u16" || AliasName == "vld2q";
case ARM::BI__builtin_arm_mve_vld2q_u32:
return AliasName == "vld2q_u32" || AliasName == "vld2q";
case ARM::BI__builtin_arm_mve_vld2q_u8:
return AliasName == "vld2q_u8" || AliasName == "vld2q";
case ARM::BI__builtin_arm_mve_vld4q_f16:
return AliasName == "vld4q_f16" || AliasName == "vld4q";
case ARM::BI__builtin_arm_mve_vld4q_f32:
return AliasName == "vld4q_f32" || AliasName == "vld4q";
case ARM::BI__builtin_arm_mve_vld4q_s16:
return AliasName == "vld4q_s16" || AliasName == "vld4q";
case ARM::BI__builtin_arm_mve_vld4q_s32:
return AliasName == "vld4q_s32" || AliasName == "vld4q";
case ARM::BI__builtin_arm_mve_vld4q_s8:
return AliasName == "vld4q_s8" || AliasName == "vld4q";
case ARM::BI__builtin_arm_mve_vld4q_u16:
return AliasName == "vld4q_u16" || AliasName == "vld4q";
case ARM::BI__builtin_arm_mve_vld4q_u32:
return AliasName == "vld4q_u32" || AliasName == "vld4q";
case ARM::BI__builtin_arm_mve_vld4q_u8:
return AliasName == "vld4q_u8" || AliasName == "vld4q";
case ARM::BI__builtin_arm_mve_vldrbq_gather_offset_s16:
return AliasName == "vldrbq_gather_offset_s16" || AliasName == "vldrbq_gather_offset";
case ARM::BI__builtin_arm_mve_vldrbq_gather_offset_s32:
return AliasName == "vldrbq_gather_offset_s32" || AliasName == "vldrbq_gather_offset";
case ARM::BI__builtin_arm_mve_vldrbq_gather_offset_s8:
return AliasName == "vldrbq_gather_offset_s8" || AliasName == "vldrbq_gather_offset";
case ARM::BI__builtin_arm_mve_vldrbq_gather_offset_u16:
return AliasName == "vldrbq_gather_offset_u16" || AliasName == "vldrbq_gather_offset";
case ARM::BI__builtin_arm_mve_vldrbq_gather_offset_u32:
return AliasName == "vldrbq_gather_offset_u32" || AliasName == "vldrbq_gather_offset";
case ARM::BI__builtin_arm_mve_vldrbq_gather_offset_u8:
return AliasName == "vldrbq_gather_offset_u8" || AliasName == "vldrbq_gather_offset";
case ARM::BI__builtin_arm_mve_vldrbq_gather_offset_z_s16:
return AliasName == "vldrbq_gather_offset_z_s16" || AliasName == "vldrbq_gather_offset_z";
case ARM::BI__builtin_arm_mve_vldrbq_gather_offset_z_s32:
return AliasName == "vldrbq_gather_offset_z_s32" || AliasName == "vldrbq_gather_offset_z";
case ARM::BI__builtin_arm_mve_vldrbq_gather_offset_z_s8:
return AliasName == "vldrbq_gather_offset_z_s8" || AliasName == "vldrbq_gather_offset_z";
case ARM::BI__builtin_arm_mve_vldrbq_gather_offset_z_u16:
return AliasName == "vldrbq_gather_offset_z_u16" || AliasName == "vldrbq_gather_offset_z";
case ARM::BI__builtin_arm_mve_vldrbq_gather_offset_z_u32:
return AliasName == "vldrbq_gather_offset_z_u32" || AliasName == "vldrbq_gather_offset_z";
case ARM::BI__builtin_arm_mve_vldrbq_gather_offset_z_u8:
return AliasName == "vldrbq_gather_offset_z_u8" || AliasName == "vldrbq_gather_offset_z";
case ARM::BI__builtin_arm_mve_vldrbq_s16:
return AliasName == "vldrbq_s16";
case ARM::BI__builtin_arm_mve_vldrbq_s32:
return AliasName == "vldrbq_s32";
case ARM::BI__builtin_arm_mve_vldrbq_s8:
return AliasName == "vldrbq_s8";
case ARM::BI__builtin_arm_mve_vldrbq_u16:
return AliasName == "vldrbq_u16";
case ARM::BI__builtin_arm_mve_vldrbq_u32:
return AliasName == "vldrbq_u32";
case ARM::BI__builtin_arm_mve_vldrbq_u8:
return AliasName == "vldrbq_u8";
case ARM::BI__builtin_arm_mve_vldrbq_z_s16:
return AliasName == "vldrbq_z_s16";
case ARM::BI__builtin_arm_mve_vldrbq_z_s32:
return AliasName == "vldrbq_z_s32";
case ARM::BI__builtin_arm_mve_vldrbq_z_s8:
return AliasName == "vldrbq_z_s8";
case ARM::BI__builtin_arm_mve_vldrbq_z_u16:
return AliasName == "vldrbq_z_u16";
case ARM::BI__builtin_arm_mve_vldrbq_z_u32:
return AliasName == "vldrbq_z_u32";
case ARM::BI__builtin_arm_mve_vldrbq_z_u8:
return AliasName == "vldrbq_z_u8";
case ARM::BI__builtin_arm_mve_vldrdq_gather_base_s64:
return AliasName == "vldrdq_gather_base_s64";
case ARM::BI__builtin_arm_mve_vldrdq_gather_base_u64:
return AliasName == "vldrdq_gather_base_u64";
case ARM::BI__builtin_arm_mve_vldrdq_gather_base_wb_s64:
return AliasName == "vldrdq_gather_base_wb_s64";
case ARM::BI__builtin_arm_mve_vldrdq_gather_base_wb_u64:
return AliasName == "vldrdq_gather_base_wb_u64";
case ARM::BI__builtin_arm_mve_vldrdq_gather_base_wb_z_s64:
return AliasName == "vldrdq_gather_base_wb_z_s64";
case ARM::BI__builtin_arm_mve_vldrdq_gather_base_wb_z_u64:
return AliasName == "vldrdq_gather_base_wb_z_u64";
case ARM::BI__builtin_arm_mve_vldrdq_gather_base_z_s64:
return AliasName == "vldrdq_gather_base_z_s64";
case ARM::BI__builtin_arm_mve_vldrdq_gather_base_z_u64:
return AliasName == "vldrdq_gather_base_z_u64";
case ARM::BI__builtin_arm_mve_vldrdq_gather_offset_s64:
return AliasName == "vldrdq_gather_offset_s64" || AliasName == "vldrdq_gather_offset";
case ARM::BI__builtin_arm_mve_vldrdq_gather_offset_u64:
return AliasName == "vldrdq_gather_offset_u64" || AliasName == "vldrdq_gather_offset";
case ARM::BI__builtin_arm_mve_vldrdq_gather_offset_z_s64:
return AliasName == "vldrdq_gather_offset_z_s64" || AliasName == "vldrdq_gather_offset_z";
case ARM::BI__builtin_arm_mve_vldrdq_gather_offset_z_u64:
return AliasName == "vldrdq_gather_offset_z_u64" || AliasName == "vldrdq_gather_offset_z";
case ARM::BI__builtin_arm_mve_vldrdq_gather_shifted_offset_s64:
return AliasName == "vldrdq_gather_shifted_offset_s64" || AliasName == "vldrdq_gather_shifted_offset";
case ARM::BI__builtin_arm_mve_vldrdq_gather_shifted_offset_u64:
return AliasName == "vldrdq_gather_shifted_offset_u64" || AliasName == "vldrdq_gather_shifted_offset";
case ARM::BI__builtin_arm_mve_vldrdq_gather_shifted_offset_z_s64:
return AliasName == "vldrdq_gather_shifted_offset_z_s64" || AliasName == "vldrdq_gather_shifted_offset_z";
case ARM::BI__builtin_arm_mve_vldrdq_gather_shifted_offset_z_u64:
return AliasName == "vldrdq_gather_shifted_offset_z_u64" || AliasName == "vldrdq_gather_shifted_offset_z";
case ARM::BI__builtin_arm_mve_vldrhq_f16:
return AliasName == "vldrhq_f16";
case ARM::BI__builtin_arm_mve_vldrhq_gather_offset_f16:
return AliasName == "vldrhq_gather_offset_f16" || AliasName == "vldrhq_gather_offset";
case ARM::BI__builtin_arm_mve_vldrhq_gather_offset_s16:
return AliasName == "vldrhq_gather_offset_s16" || AliasName == "vldrhq_gather_offset";
case ARM::BI__builtin_arm_mve_vldrhq_gather_offset_s32:
return AliasName == "vldrhq_gather_offset_s32" || AliasName == "vldrhq_gather_offset";
case ARM::BI__builtin_arm_mve_vldrhq_gather_offset_u16:
return AliasName == "vldrhq_gather_offset_u16" || AliasName == "vldrhq_gather_offset";
case ARM::BI__builtin_arm_mve_vldrhq_gather_offset_u32:
return AliasName == "vldrhq_gather_offset_u32" || AliasName == "vldrhq_gather_offset";
case ARM::BI__builtin_arm_mve_vldrhq_gather_offset_z_f16:
return AliasName == "vldrhq_gather_offset_z_f16" || AliasName == "vldrhq_gather_offset_z";
case ARM::BI__builtin_arm_mve_vldrhq_gather_offset_z_s16:
return AliasName == "vldrhq_gather_offset_z_s16" || AliasName == "vldrhq_gather_offset_z";
case ARM::BI__builtin_arm_mve_vldrhq_gather_offset_z_s32:
return AliasName == "vldrhq_gather_offset_z_s32" || AliasName == "vldrhq_gather_offset_z";
case ARM::BI__builtin_arm_mve_vldrhq_gather_offset_z_u16:
return AliasName == "vldrhq_gather_offset_z_u16" || AliasName == "vldrhq_gather_offset_z";
case ARM::BI__builtin_arm_mve_vldrhq_gather_offset_z_u32:
return AliasName == "vldrhq_gather_offset_z_u32" || AliasName == "vldrhq_gather_offset_z";
case ARM::BI__builtin_arm_mve_vldrhq_gather_shifted_offset_f16:
return AliasName == "vldrhq_gather_shifted_offset_f16" || AliasName == "vldrhq_gather_shifted_offset";
case ARM::BI__builtin_arm_mve_vldrhq_gather_shifted_offset_s16:
return AliasName == "vldrhq_gather_shifted_offset_s16" || AliasName == "vldrhq_gather_shifted_offset";
case ARM::BI__builtin_arm_mve_vldrhq_gather_shifted_offset_s32:
return AliasName == "vldrhq_gather_shifted_offset_s32" || AliasName == "vldrhq_gather_shifted_offset";
case ARM::BI__builtin_arm_mve_vldrhq_gather_shifted_offset_u16:
return AliasName == "vldrhq_gather_shifted_offset_u16" || AliasName == "vldrhq_gather_shifted_offset";
case ARM::BI__builtin_arm_mve_vldrhq_gather_shifted_offset_u32:
return AliasName == "vldrhq_gather_shifted_offset_u32" || AliasName == "vldrhq_gather_shifted_offset";
case ARM::BI__builtin_arm_mve_vldrhq_gather_shifted_offset_z_f16:
return AliasName == "vldrhq_gather_shifted_offset_z_f16" || AliasName == "vldrhq_gather_shifted_offset_z";
case ARM::BI__builtin_arm_mve_vldrhq_gather_shifted_offset_z_s16:
return AliasName == "vldrhq_gather_shifted_offset_z_s16" || AliasName == "vldrhq_gather_shifted_offset_z";
case ARM::BI__builtin_arm_mve_vldrhq_gather_shifted_offset_z_s32:
return AliasName == "vldrhq_gather_shifted_offset_z_s32" || AliasName == "vldrhq_gather_shifted_offset_z";
case ARM::BI__builtin_arm_mve_vldrhq_gather_shifted_offset_z_u16:
return AliasName == "vldrhq_gather_shifted_offset_z_u16" || AliasName == "vldrhq_gather_shifted_offset_z";
case ARM::BI__builtin_arm_mve_vldrhq_gather_shifted_offset_z_u32:
return AliasName == "vldrhq_gather_shifted_offset_z_u32" || AliasName == "vldrhq_gather_shifted_offset_z";
case ARM::BI__builtin_arm_mve_vldrhq_s16:
return AliasName == "vldrhq_s16";
case ARM::BI__builtin_arm_mve_vldrhq_s32:
return AliasName == "vldrhq_s32";
case ARM::BI__builtin_arm_mve_vldrhq_u16:
return AliasName == "vldrhq_u16";
case ARM::BI__builtin_arm_mve_vldrhq_u32:
return AliasName == "vldrhq_u32";
case ARM::BI__builtin_arm_mve_vldrhq_z_f16:
return AliasName == "vldrhq_z_f16";
case ARM::BI__builtin_arm_mve_vldrhq_z_s16:
return AliasName == "vldrhq_z_s16";
case ARM::BI__builtin_arm_mve_vldrhq_z_s32:
return AliasName == "vldrhq_z_s32";
case ARM::BI__builtin_arm_mve_vldrhq_z_u16:
return AliasName == "vldrhq_z_u16";
case ARM::BI__builtin_arm_mve_vldrhq_z_u32:
return AliasName == "vldrhq_z_u32";
case ARM::BI__builtin_arm_mve_vldrwq_f32:
return AliasName == "vldrwq_f32";
case ARM::BI__builtin_arm_mve_vldrwq_gather_base_f32:
return AliasName == "vldrwq_gather_base_f32";
case ARM::BI__builtin_arm_mve_vldrwq_gather_base_s32:
return AliasName == "vldrwq_gather_base_s32";
case ARM::BI__builtin_arm_mve_vldrwq_gather_base_u32:
return AliasName == "vldrwq_gather_base_u32";
case ARM::BI__builtin_arm_mve_vldrwq_gather_base_wb_f32:
return AliasName == "vldrwq_gather_base_wb_f32";
case ARM::BI__builtin_arm_mve_vldrwq_gather_base_wb_s32:
return AliasName == "vldrwq_gather_base_wb_s32";
case ARM::BI__builtin_arm_mve_vldrwq_gather_base_wb_u32:
return AliasName == "vldrwq_gather_base_wb_u32";
case ARM::BI__builtin_arm_mve_vldrwq_gather_base_wb_z_f32:
return AliasName == "vldrwq_gather_base_wb_z_f32";
case ARM::BI__builtin_arm_mve_vldrwq_gather_base_wb_z_s32:
return AliasName == "vldrwq_gather_base_wb_z_s32";
case ARM::BI__builtin_arm_mve_vldrwq_gather_base_wb_z_u32:
return AliasName == "vldrwq_gather_base_wb_z_u32";
case ARM::BI__builtin_arm_mve_vldrwq_gather_base_z_f32:
return AliasName == "vldrwq_gather_base_z_f32";
case ARM::BI__builtin_arm_mve_vldrwq_gather_base_z_s32:
return AliasName == "vldrwq_gather_base_z_s32";
case ARM::BI__builtin_arm_mve_vldrwq_gather_base_z_u32:
return AliasName == "vldrwq_gather_base_z_u32";
case ARM::BI__builtin_arm_mve_vldrwq_gather_offset_f32:
return AliasName == "vldrwq_gather_offset_f32" || AliasName == "vldrwq_gather_offset";
case ARM::BI__builtin_arm_mve_vldrwq_gather_offset_s32:
return AliasName == "vldrwq_gather_offset_s32" || AliasName == "vldrwq_gather_offset";
case ARM::BI__builtin_arm_mve_vldrwq_gather_offset_u32:
return AliasName == "vldrwq_gather_offset_u32" || AliasName == "vldrwq_gather_offset";
case ARM::BI__builtin_arm_mve_vldrwq_gather_offset_z_f32:
return AliasName == "vldrwq_gather_offset_z_f32" || AliasName == "vldrwq_gather_offset_z";
case ARM::BI__builtin_arm_mve_vldrwq_gather_offset_z_s32:
return AliasName == "vldrwq_gather_offset_z_s32" || AliasName == "vldrwq_gather_offset_z";
case ARM::BI__builtin_arm_mve_vldrwq_gather_offset_z_u32:
return AliasName == "vldrwq_gather_offset_z_u32" || AliasName == "vldrwq_gather_offset_z";
case ARM::BI__builtin_arm_mve_vldrwq_gather_shifted_offset_f32:
return AliasName == "vldrwq_gather_shifted_offset_f32" || AliasName == "vldrwq_gather_shifted_offset";
case ARM::BI__builtin_arm_mve_vldrwq_gather_shifted_offset_s32:
return AliasName == "vldrwq_gather_shifted_offset_s32" || AliasName == "vldrwq_gather_shifted_offset";
case ARM::BI__builtin_arm_mve_vldrwq_gather_shifted_offset_u32:
return AliasName == "vldrwq_gather_shifted_offset_u32" || AliasName == "vldrwq_gather_shifted_offset";
case ARM::BI__builtin_arm_mve_vldrwq_gather_shifted_offset_z_f32:
return AliasName == "vldrwq_gather_shifted_offset_z_f32" || AliasName == "vldrwq_gather_shifted_offset_z";
case ARM::BI__builtin_arm_mve_vldrwq_gather_shifted_offset_z_s32:
return AliasName == "vldrwq_gather_shifted_offset_z_s32" || AliasName == "vldrwq_gather_shifted_offset_z";
case ARM::BI__builtin_arm_mve_vldrwq_gather_shifted_offset_z_u32:
return AliasName == "vldrwq_gather_shifted_offset_z_u32" || AliasName == "vldrwq_gather_shifted_offset_z";
case ARM::BI__builtin_arm_mve_vldrwq_s32:
return AliasName == "vldrwq_s32";
case ARM::BI__builtin_arm_mve_vldrwq_u32:
return AliasName == "vldrwq_u32";
case ARM::BI__builtin_arm_mve_vldrwq_z_f32:
return AliasName == "vldrwq_z_f32";
case ARM::BI__builtin_arm_mve_vldrwq_z_s32:
return AliasName == "vldrwq_z_s32";
case ARM::BI__builtin_arm_mve_vldrwq_z_u32:
return AliasName == "vldrwq_z_u32";
case ARM::BI__builtin_arm_mve_vmaxaq_m_s16:
return AliasName == "vmaxaq_m_s16" || AliasName == "vmaxaq_m";
case ARM::BI__builtin_arm_mve_vmaxaq_m_s32:
return AliasName == "vmaxaq_m_s32" || AliasName == "vmaxaq_m";
case ARM::BI__builtin_arm_mve_vmaxaq_m_s8:
return AliasName == "vmaxaq_m_s8" || AliasName == "vmaxaq_m";
case ARM::BI__builtin_arm_mve_vmaxaq_s16:
return AliasName == "vmaxaq_s16" || AliasName == "vmaxaq";
case ARM::BI__builtin_arm_mve_vmaxaq_s32:
return AliasName == "vmaxaq_s32" || AliasName == "vmaxaq";
case ARM::BI__builtin_arm_mve_vmaxaq_s8:
return AliasName == "vmaxaq_s8" || AliasName == "vmaxaq";
case ARM::BI__builtin_arm_mve_vmaxnmaq_f16:
return AliasName == "vmaxnmaq_f16" || AliasName == "vmaxnmaq";
case ARM::BI__builtin_arm_mve_vmaxnmaq_f32:
return AliasName == "vmaxnmaq_f32" || AliasName == "vmaxnmaq";
case ARM::BI__builtin_arm_mve_vmaxnmaq_m_f16:
return AliasName == "vmaxnmaq_m_f16" || AliasName == "vmaxnmaq_m";
case ARM::BI__builtin_arm_mve_vmaxnmaq_m_f32:
return AliasName == "vmaxnmaq_m_f32" || AliasName == "vmaxnmaq_m";
case ARM::BI__builtin_arm_mve_vmaxnmq_f16:
return AliasName == "vmaxnmq_f16" || AliasName == "vmaxnmq";
case ARM::BI__builtin_arm_mve_vmaxnmq_f32:
return AliasName == "vmaxnmq_f32" || AliasName == "vmaxnmq";
case ARM::BI__builtin_arm_mve_vmaxnmq_m_f16:
return AliasName == "vmaxnmq_m_f16" || AliasName == "vmaxnmq_m";
case ARM::BI__builtin_arm_mve_vmaxnmq_m_f32:
return AliasName == "vmaxnmq_m_f32" || AliasName == "vmaxnmq_m";
case ARM::BI__builtin_arm_mve_vmaxnmq_x_f16:
return AliasName == "vmaxnmq_x_f16" || AliasName == "vmaxnmq_x";
case ARM::BI__builtin_arm_mve_vmaxnmq_x_f32:
return AliasName == "vmaxnmq_x_f32" || AliasName == "vmaxnmq_x";
case ARM::BI__builtin_arm_mve_vmaxq_m_s16:
return AliasName == "vmaxq_m_s16" || AliasName == "vmaxq_m";
case ARM::BI__builtin_arm_mve_vmaxq_m_s32:
return AliasName == "vmaxq_m_s32" || AliasName == "vmaxq_m";
case ARM::BI__builtin_arm_mve_vmaxq_m_s8:
return AliasName == "vmaxq_m_s8" || AliasName == "vmaxq_m";
case ARM::BI__builtin_arm_mve_vmaxq_m_u16:
return AliasName == "vmaxq_m_u16" || AliasName == "vmaxq_m";
case ARM::BI__builtin_arm_mve_vmaxq_m_u32:
return AliasName == "vmaxq_m_u32" || AliasName == "vmaxq_m";
case ARM::BI__builtin_arm_mve_vmaxq_m_u8:
return AliasName == "vmaxq_m_u8" || AliasName == "vmaxq_m";
case ARM::BI__builtin_arm_mve_vmaxq_s16:
return AliasName == "vmaxq_s16" || AliasName == "vmaxq";
case ARM::BI__builtin_arm_mve_vmaxq_s32:
return AliasName == "vmaxq_s32" || AliasName == "vmaxq";
case ARM::BI__builtin_arm_mve_vmaxq_s8:
return AliasName == "vmaxq_s8" || AliasName == "vmaxq";
case ARM::BI__builtin_arm_mve_vmaxq_u16:
return AliasName == "vmaxq_u16" || AliasName == "vmaxq";
case ARM::BI__builtin_arm_mve_vmaxq_u32:
return AliasName == "vmaxq_u32" || AliasName == "vmaxq";
case ARM::BI__builtin_arm_mve_vmaxq_u8:
return AliasName == "vmaxq_u8" || AliasName == "vmaxq";
case ARM::BI__builtin_arm_mve_vmaxq_x_s16:
return AliasName == "vmaxq_x_s16" || AliasName == "vmaxq_x";
case ARM::BI__builtin_arm_mve_vmaxq_x_s32:
return AliasName == "vmaxq_x_s32" || AliasName == "vmaxq_x";
case ARM::BI__builtin_arm_mve_vmaxq_x_s8:
return AliasName == "vmaxq_x_s8" || AliasName == "vmaxq_x";
case ARM::BI__builtin_arm_mve_vmaxq_x_u16:
return AliasName == "vmaxq_x_u16" || AliasName == "vmaxq_x";
case ARM::BI__builtin_arm_mve_vmaxq_x_u32:
return AliasName == "vmaxq_x_u32" || AliasName == "vmaxq_x";
case ARM::BI__builtin_arm_mve_vmaxq_x_u8:
return AliasName == "vmaxq_x_u8" || AliasName == "vmaxq_x";
case ARM::BI__builtin_arm_mve_vmaxvq_s16:
return AliasName == "vmaxvq_s16" || AliasName == "vmaxvq";
case ARM::BI__builtin_arm_mve_vmaxvq_s32:
return AliasName == "vmaxvq_s32" || AliasName == "vmaxvq";
case ARM::BI__builtin_arm_mve_vmaxvq_s8:
return AliasName == "vmaxvq_s8" || AliasName == "vmaxvq";
case ARM::BI__builtin_arm_mve_vmaxvq_u16:
return AliasName == "vmaxvq_u16" || AliasName == "vmaxvq";
case ARM::BI__builtin_arm_mve_vmaxvq_u32:
return AliasName == "vmaxvq_u32" || AliasName == "vmaxvq";
case ARM::BI__builtin_arm_mve_vmaxvq_u8:
return AliasName == "vmaxvq_u8" || AliasName == "vmaxvq";
case ARM::BI__builtin_arm_mve_vminaq_m_s16:
return AliasName == "vminaq_m_s16" || AliasName == "vminaq_m";
case ARM::BI__builtin_arm_mve_vminaq_m_s32:
return AliasName == "vminaq_m_s32" || AliasName == "vminaq_m";
case ARM::BI__builtin_arm_mve_vminaq_m_s8:
return AliasName == "vminaq_m_s8" || AliasName == "vminaq_m";
case ARM::BI__builtin_arm_mve_vminaq_s16:
return AliasName == "vminaq_s16" || AliasName == "vminaq";
case ARM::BI__builtin_arm_mve_vminaq_s32:
return AliasName == "vminaq_s32" || AliasName == "vminaq";
case ARM::BI__builtin_arm_mve_vminaq_s8:
return AliasName == "vminaq_s8" || AliasName == "vminaq";
case ARM::BI__builtin_arm_mve_vminnmaq_f16:
return AliasName == "vminnmaq_f16" || AliasName == "vminnmaq";
case ARM::BI__builtin_arm_mve_vminnmaq_f32:
return AliasName == "vminnmaq_f32" || AliasName == "vminnmaq";
case ARM::BI__builtin_arm_mve_vminnmaq_m_f16:
return AliasName == "vminnmaq_m_f16" || AliasName == "vminnmaq_m";
case ARM::BI__builtin_arm_mve_vminnmaq_m_f32:
return AliasName == "vminnmaq_m_f32" || AliasName == "vminnmaq_m";
case ARM::BI__builtin_arm_mve_vminnmq_f16:
return AliasName == "vminnmq_f16" || AliasName == "vminnmq";
case ARM::BI__builtin_arm_mve_vminnmq_f32:
return AliasName == "vminnmq_f32" || AliasName == "vminnmq";
case ARM::BI__builtin_arm_mve_vminnmq_m_f16:
return AliasName == "vminnmq_m_f16" || AliasName == "vminnmq_m";
case ARM::BI__builtin_arm_mve_vminnmq_m_f32:
return AliasName == "vminnmq_m_f32" || AliasName == "vminnmq_m";
case ARM::BI__builtin_arm_mve_vminnmq_x_f16:
return AliasName == "vminnmq_x_f16" || AliasName == "vminnmq_x";
case ARM::BI__builtin_arm_mve_vminnmq_x_f32:
return AliasName == "vminnmq_x_f32" || AliasName == "vminnmq_x";
case ARM::BI__builtin_arm_mve_vminq_m_s16:
return AliasName == "vminq_m_s16" || AliasName == "vminq_m";
case ARM::BI__builtin_arm_mve_vminq_m_s32:
return AliasName == "vminq_m_s32" || AliasName == "vminq_m";
case ARM::BI__builtin_arm_mve_vminq_m_s8:
return AliasName == "vminq_m_s8" || AliasName == "vminq_m";
case ARM::BI__builtin_arm_mve_vminq_m_u16:
return AliasName == "vminq_m_u16" || AliasName == "vminq_m";
case ARM::BI__builtin_arm_mve_vminq_m_u32:
return AliasName == "vminq_m_u32" || AliasName == "vminq_m";
case ARM::BI__builtin_arm_mve_vminq_m_u8:
return AliasName == "vminq_m_u8" || AliasName == "vminq_m";
case ARM::BI__builtin_arm_mve_vminq_s16:
return AliasName == "vminq_s16" || AliasName == "vminq";
case ARM::BI__builtin_arm_mve_vminq_s32:
return AliasName == "vminq_s32" || AliasName == "vminq";
case ARM::BI__builtin_arm_mve_vminq_s8:
return AliasName == "vminq_s8" || AliasName == "vminq";
case ARM::BI__builtin_arm_mve_vminq_u16:
return AliasName == "vminq_u16" || AliasName == "vminq";
case ARM::BI__builtin_arm_mve_vminq_u32:
return AliasName == "vminq_u32" || AliasName == "vminq";
case ARM::BI__builtin_arm_mve_vminq_u8:
return AliasName == "vminq_u8" || AliasName == "vminq";
case ARM::BI__builtin_arm_mve_vminq_x_s16:
return AliasName == "vminq_x_s16" || AliasName == "vminq_x";
case ARM::BI__builtin_arm_mve_vminq_x_s32:
return AliasName == "vminq_x_s32" || AliasName == "vminq_x";
case ARM::BI__builtin_arm_mve_vminq_x_s8:
return AliasName == "vminq_x_s8" || AliasName == "vminq_x";
case ARM::BI__builtin_arm_mve_vminq_x_u16:
return AliasName == "vminq_x_u16" || AliasName == "vminq_x";
case ARM::BI__builtin_arm_mve_vminq_x_u32:
return AliasName == "vminq_x_u32" || AliasName == "vminq_x";
case ARM::BI__builtin_arm_mve_vminq_x_u8:
return AliasName == "vminq_x_u8" || AliasName == "vminq_x";
case ARM::BI__builtin_arm_mve_vminvq_s16:
return AliasName == "vminvq_s16" || AliasName == "vminvq";
case ARM::BI__builtin_arm_mve_vminvq_s32:
return AliasName == "vminvq_s32" || AliasName == "vminvq";
case ARM::BI__builtin_arm_mve_vminvq_s8:
return AliasName == "vminvq_s8" || AliasName == "vminvq";
case ARM::BI__builtin_arm_mve_vminvq_u16:
return AliasName == "vminvq_u16" || AliasName == "vminvq";
case ARM::BI__builtin_arm_mve_vminvq_u32:
return AliasName == "vminvq_u32" || AliasName == "vminvq";
case ARM::BI__builtin_arm_mve_vminvq_u8:
return AliasName == "vminvq_u8" || AliasName == "vminvq";
case ARM::BI__builtin_arm_mve_vmladavaq_p_s16:
return AliasName == "vmladavaq_p_s16" || AliasName == "vmladavaq_p";
case ARM::BI__builtin_arm_mve_vmladavaq_p_s32:
return AliasName == "vmladavaq_p_s32" || AliasName == "vmladavaq_p";
case ARM::BI__builtin_arm_mve_vmladavaq_p_s8:
return AliasName == "vmladavaq_p_s8" || AliasName == "vmladavaq_p";
case ARM::BI__builtin_arm_mve_vmladavaq_p_u16:
return AliasName == "vmladavaq_p_u16" || AliasName == "vmladavaq_p";
case ARM::BI__builtin_arm_mve_vmladavaq_p_u32:
return AliasName == "vmladavaq_p_u32" || AliasName == "vmladavaq_p";
case ARM::BI__builtin_arm_mve_vmladavaq_p_u8:
return AliasName == "vmladavaq_p_u8" || AliasName == "vmladavaq_p";
case ARM::BI__builtin_arm_mve_vmladavaq_s16:
return AliasName == "vmladavaq_s16" || AliasName == "vmladavaq";
case ARM::BI__builtin_arm_mve_vmladavaq_s32:
return AliasName == "vmladavaq_s32" || AliasName == "vmladavaq";
case ARM::BI__builtin_arm_mve_vmladavaq_s8:
return AliasName == "vmladavaq_s8" || AliasName == "vmladavaq";
case ARM::BI__builtin_arm_mve_vmladavaq_u16:
return AliasName == "vmladavaq_u16" || AliasName == "vmladavaq";
case ARM::BI__builtin_arm_mve_vmladavaq_u32:
return AliasName == "vmladavaq_u32" || AliasName == "vmladavaq";
case ARM::BI__builtin_arm_mve_vmladavaq_u8:
return AliasName == "vmladavaq_u8" || AliasName == "vmladavaq";
case ARM::BI__builtin_arm_mve_vmladavaxq_p_s16:
return AliasName == "vmladavaxq_p_s16" || AliasName == "vmladavaxq_p";
case ARM::BI__builtin_arm_mve_vmladavaxq_p_s32:
return AliasName == "vmladavaxq_p_s32" || AliasName == "vmladavaxq_p";
case ARM::BI__builtin_arm_mve_vmladavaxq_p_s8:
return AliasName == "vmladavaxq_p_s8" || AliasName == "vmladavaxq_p";
case ARM::BI__builtin_arm_mve_vmladavaxq_s16:
return AliasName == "vmladavaxq_s16" || AliasName == "vmladavaxq";
case ARM::BI__builtin_arm_mve_vmladavaxq_s32:
return AliasName == "vmladavaxq_s32" || AliasName == "vmladavaxq";
case ARM::BI__builtin_arm_mve_vmladavaxq_s8:
return AliasName == "vmladavaxq_s8" || AliasName == "vmladavaxq";
case ARM::BI__builtin_arm_mve_vmladavq_p_s16:
return AliasName == "vmladavq_p_s16" || AliasName == "vmladavq_p";
case ARM::BI__builtin_arm_mve_vmladavq_p_s32:
return AliasName == "vmladavq_p_s32" || AliasName == "vmladavq_p";
case ARM::BI__builtin_arm_mve_vmladavq_p_s8:
return AliasName == "vmladavq_p_s8" || AliasName == "vmladavq_p";
case ARM::BI__builtin_arm_mve_vmladavq_p_u16:
return AliasName == "vmladavq_p_u16" || AliasName == "vmladavq_p";
case ARM::BI__builtin_arm_mve_vmladavq_p_u32:
return AliasName == "vmladavq_p_u32" || AliasName == "vmladavq_p";
case ARM::BI__builtin_arm_mve_vmladavq_p_u8:
return AliasName == "vmladavq_p_u8" || AliasName == "vmladavq_p";
case ARM::BI__builtin_arm_mve_vmladavq_s16:
return AliasName == "vmladavq_s16" || AliasName == "vmladavq";
case ARM::BI__builtin_arm_mve_vmladavq_s32:
return AliasName == "vmladavq_s32" || AliasName == "vmladavq";
case ARM::BI__builtin_arm_mve_vmladavq_s8:
return AliasName == "vmladavq_s8" || AliasName == "vmladavq";
case ARM::BI__builtin_arm_mve_vmladavq_u16:
return AliasName == "vmladavq_u16" || AliasName == "vmladavq";
case ARM::BI__builtin_arm_mve_vmladavq_u32:
return AliasName == "vmladavq_u32" || AliasName == "vmladavq";
case ARM::BI__builtin_arm_mve_vmladavq_u8:
return AliasName == "vmladavq_u8" || AliasName == "vmladavq";
case ARM::BI__builtin_arm_mve_vmladavxq_p_s16:
return AliasName == "vmladavxq_p_s16" || AliasName == "vmladavxq_p";
case ARM::BI__builtin_arm_mve_vmladavxq_p_s32:
return AliasName == "vmladavxq_p_s32" || AliasName == "vmladavxq_p";
case ARM::BI__builtin_arm_mve_vmladavxq_p_s8:
return AliasName == "vmladavxq_p_s8" || AliasName == "vmladavxq_p";
case ARM::BI__builtin_arm_mve_vmladavxq_s16:
return AliasName == "vmladavxq_s16" || AliasName == "vmladavxq";
case ARM::BI__builtin_arm_mve_vmladavxq_s32:
return AliasName == "vmladavxq_s32" || AliasName == "vmladavxq";
case ARM::BI__builtin_arm_mve_vmladavxq_s8:
return AliasName == "vmladavxq_s8" || AliasName == "vmladavxq";
case ARM::BI__builtin_arm_mve_vmlaldavaq_p_s16:
return AliasName == "vmlaldavaq_p_s16" || AliasName == "vmlaldavaq_p";
case ARM::BI__builtin_arm_mve_vmlaldavaq_p_s32:
return AliasName == "vmlaldavaq_p_s32" || AliasName == "vmlaldavaq_p";
case ARM::BI__builtin_arm_mve_vmlaldavaq_p_u16:
return AliasName == "vmlaldavaq_p_u16" || AliasName == "vmlaldavaq_p";
case ARM::BI__builtin_arm_mve_vmlaldavaq_p_u32:
return AliasName == "vmlaldavaq_p_u32" || AliasName == "vmlaldavaq_p";
case ARM::BI__builtin_arm_mve_vmlaldavaq_s16:
return AliasName == "vmlaldavaq_s16" || AliasName == "vmlaldavaq";
case ARM::BI__builtin_arm_mve_vmlaldavaq_s32:
return AliasName == "vmlaldavaq_s32" || AliasName == "vmlaldavaq";
case ARM::BI__builtin_arm_mve_vmlaldavaq_u16:
return AliasName == "vmlaldavaq_u16" || AliasName == "vmlaldavaq";
case ARM::BI__builtin_arm_mve_vmlaldavaq_u32:
return AliasName == "vmlaldavaq_u32" || AliasName == "vmlaldavaq";
case ARM::BI__builtin_arm_mve_vmlaldavaxq_p_s16:
return AliasName == "vmlaldavaxq_p_s16" || AliasName == "vmlaldavaxq_p";
case ARM::BI__builtin_arm_mve_vmlaldavaxq_p_s32:
return AliasName == "vmlaldavaxq_p_s32" || AliasName == "vmlaldavaxq_p";
case ARM::BI__builtin_arm_mve_vmlaldavaxq_s16:
return AliasName == "vmlaldavaxq_s16" || AliasName == "vmlaldavaxq";
case ARM::BI__builtin_arm_mve_vmlaldavaxq_s32:
return AliasName == "vmlaldavaxq_s32" || AliasName == "vmlaldavaxq";
case ARM::BI__builtin_arm_mve_vmlaldavq_p_s16:
return AliasName == "vmlaldavq_p_s16" || AliasName == "vmlaldavq_p";
case ARM::BI__builtin_arm_mve_vmlaldavq_p_s32:
return AliasName == "vmlaldavq_p_s32" || AliasName == "vmlaldavq_p";
case ARM::BI__builtin_arm_mve_vmlaldavq_p_u16:
return AliasName == "vmlaldavq_p_u16" || AliasName == "vmlaldavq_p";
case ARM::BI__builtin_arm_mve_vmlaldavq_p_u32:
return AliasName == "vmlaldavq_p_u32" || AliasName == "vmlaldavq_p";
case ARM::BI__builtin_arm_mve_vmlaldavq_s16:
return AliasName == "vmlaldavq_s16" || AliasName == "vmlaldavq";
case ARM::BI__builtin_arm_mve_vmlaldavq_s32:
return AliasName == "vmlaldavq_s32" || AliasName == "vmlaldavq";
case ARM::BI__builtin_arm_mve_vmlaldavq_u16:
return AliasName == "vmlaldavq_u16" || AliasName == "vmlaldavq";
case ARM::BI__builtin_arm_mve_vmlaldavq_u32:
return AliasName == "vmlaldavq_u32" || AliasName == "vmlaldavq";
case ARM::BI__builtin_arm_mve_vmlaldavxq_p_s16:
return AliasName == "vmlaldavxq_p_s16" || AliasName == "vmlaldavxq_p";
case ARM::BI__builtin_arm_mve_vmlaldavxq_p_s32:
return AliasName == "vmlaldavxq_p_s32" || AliasName == "vmlaldavxq_p";
case ARM::BI__builtin_arm_mve_vmlaldavxq_s16:
return AliasName == "vmlaldavxq_s16" || AliasName == "vmlaldavxq";
case ARM::BI__builtin_arm_mve_vmlaldavxq_s32:
return AliasName == "vmlaldavxq_s32" || AliasName == "vmlaldavxq";
case ARM::BI__builtin_arm_mve_vmlsdavaq_p_s16:
return AliasName == "vmlsdavaq_p_s16" || AliasName == "vmlsdavaq_p";
case ARM::BI__builtin_arm_mve_vmlsdavaq_p_s32:
return AliasName == "vmlsdavaq_p_s32" || AliasName == "vmlsdavaq_p";
case ARM::BI__builtin_arm_mve_vmlsdavaq_p_s8:
return AliasName == "vmlsdavaq_p_s8" || AliasName == "vmlsdavaq_p";
case ARM::BI__builtin_arm_mve_vmlsdavaq_s16:
return AliasName == "vmlsdavaq_s16" || AliasName == "vmlsdavaq";
case ARM::BI__builtin_arm_mve_vmlsdavaq_s32:
return AliasName == "vmlsdavaq_s32" || AliasName == "vmlsdavaq";
case ARM::BI__builtin_arm_mve_vmlsdavaq_s8:
return AliasName == "vmlsdavaq_s8" || AliasName == "vmlsdavaq";
case ARM::BI__builtin_arm_mve_vmlsdavaxq_p_s16:
return AliasName == "vmlsdavaxq_p_s16" || AliasName == "vmlsdavaxq_p";
case ARM::BI__builtin_arm_mve_vmlsdavaxq_p_s32:
return AliasName == "vmlsdavaxq_p_s32" || AliasName == "vmlsdavaxq_p";
case ARM::BI__builtin_arm_mve_vmlsdavaxq_p_s8:
return AliasName == "vmlsdavaxq_p_s8" || AliasName == "vmlsdavaxq_p";
case ARM::BI__builtin_arm_mve_vmlsdavaxq_s16:
return AliasName == "vmlsdavaxq_s16" || AliasName == "vmlsdavaxq";
case ARM::BI__builtin_arm_mve_vmlsdavaxq_s32:
return AliasName == "vmlsdavaxq_s32" || AliasName == "vmlsdavaxq";
case ARM::BI__builtin_arm_mve_vmlsdavaxq_s8:
return AliasName == "vmlsdavaxq_s8" || AliasName == "vmlsdavaxq";
case ARM::BI__builtin_arm_mve_vmlsdavq_p_s16:
return AliasName == "vmlsdavq_p_s16" || AliasName == "vmlsdavq_p";
case ARM::BI__builtin_arm_mve_vmlsdavq_p_s32:
return AliasName == "vmlsdavq_p_s32" || AliasName == "vmlsdavq_p";
case ARM::BI__builtin_arm_mve_vmlsdavq_p_s8:
return AliasName == "vmlsdavq_p_s8" || AliasName == "vmlsdavq_p";
case ARM::BI__builtin_arm_mve_vmlsdavq_s16:
return AliasName == "vmlsdavq_s16" || AliasName == "vmlsdavq";
case ARM::BI__builtin_arm_mve_vmlsdavq_s32:
return AliasName == "vmlsdavq_s32" || AliasName == "vmlsdavq";
case ARM::BI__builtin_arm_mve_vmlsdavq_s8:
return AliasName == "vmlsdavq_s8" || AliasName == "vmlsdavq";
case ARM::BI__builtin_arm_mve_vmlsdavxq_p_s16:
return AliasName == "vmlsdavxq_p_s16" || AliasName == "vmlsdavxq_p";
case ARM::BI__builtin_arm_mve_vmlsdavxq_p_s32:
return AliasName == "vmlsdavxq_p_s32" || AliasName == "vmlsdavxq_p";
case ARM::BI__builtin_arm_mve_vmlsdavxq_p_s8:
return AliasName == "vmlsdavxq_p_s8" || AliasName == "vmlsdavxq_p";
case ARM::BI__builtin_arm_mve_vmlsdavxq_s16:
return AliasName == "vmlsdavxq_s16" || AliasName == "vmlsdavxq";
case ARM::BI__builtin_arm_mve_vmlsdavxq_s32:
return AliasName == "vmlsdavxq_s32" || AliasName == "vmlsdavxq";
case ARM::BI__builtin_arm_mve_vmlsdavxq_s8:
return AliasName == "vmlsdavxq_s8" || AliasName == "vmlsdavxq";
case ARM::BI__builtin_arm_mve_vmlsldavaq_p_s16:
return AliasName == "vmlsldavaq_p_s16" || AliasName == "vmlsldavaq_p";
case ARM::BI__builtin_arm_mve_vmlsldavaq_p_s32:
return AliasName == "vmlsldavaq_p_s32" || AliasName == "vmlsldavaq_p";
case ARM::BI__builtin_arm_mve_vmlsldavaq_s16:
return AliasName == "vmlsldavaq_s16" || AliasName == "vmlsldavaq";
case ARM::BI__builtin_arm_mve_vmlsldavaq_s32:
return AliasName == "vmlsldavaq_s32" || AliasName == "vmlsldavaq";
case ARM::BI__builtin_arm_mve_vmlsldavaxq_p_s16:
return AliasName == "vmlsldavaxq_p_s16" || AliasName == "vmlsldavaxq_p";
case ARM::BI__builtin_arm_mve_vmlsldavaxq_p_s32:
return AliasName == "vmlsldavaxq_p_s32" || AliasName == "vmlsldavaxq_p";
case ARM::BI__builtin_arm_mve_vmlsldavaxq_s16:
return AliasName == "vmlsldavaxq_s16" || AliasName == "vmlsldavaxq";
case ARM::BI__builtin_arm_mve_vmlsldavaxq_s32:
return AliasName == "vmlsldavaxq_s32" || AliasName == "vmlsldavaxq";
case ARM::BI__builtin_arm_mve_vmlsldavq_p_s16:
return AliasName == "vmlsldavq_p_s16" || AliasName == "vmlsldavq_p";
case ARM::BI__builtin_arm_mve_vmlsldavq_p_s32:
return AliasName == "vmlsldavq_p_s32" || AliasName == "vmlsldavq_p";
case ARM::BI__builtin_arm_mve_vmlsldavq_s16:
return AliasName == "vmlsldavq_s16" || AliasName == "vmlsldavq";
case ARM::BI__builtin_arm_mve_vmlsldavq_s32:
return AliasName == "vmlsldavq_s32" || AliasName == "vmlsldavq";
case ARM::BI__builtin_arm_mve_vmlsldavxq_p_s16:
return AliasName == "vmlsldavxq_p_s16" || AliasName == "vmlsldavxq_p";
case ARM::BI__builtin_arm_mve_vmlsldavxq_p_s32:
return AliasName == "vmlsldavxq_p_s32" || AliasName == "vmlsldavxq_p";
case ARM::BI__builtin_arm_mve_vmlsldavxq_s16:
return AliasName == "vmlsldavxq_s16" || AliasName == "vmlsldavxq";
case ARM::BI__builtin_arm_mve_vmlsldavxq_s32:
return AliasName == "vmlsldavxq_s32" || AliasName == "vmlsldavxq";
case ARM::BI__builtin_arm_mve_vmulhq_m_s16:
return AliasName == "vmulhq_m_s16" || AliasName == "vmulhq_m";
case ARM::BI__builtin_arm_mve_vmulhq_m_s32:
return AliasName == "vmulhq_m_s32" || AliasName == "vmulhq_m";
case ARM::BI__builtin_arm_mve_vmulhq_m_s8:
return AliasName == "vmulhq_m_s8" || AliasName == "vmulhq_m";
case ARM::BI__builtin_arm_mve_vmulhq_m_u16:
return AliasName == "vmulhq_m_u16" || AliasName == "vmulhq_m";
case ARM::BI__builtin_arm_mve_vmulhq_m_u32:
return AliasName == "vmulhq_m_u32" || AliasName == "vmulhq_m";
case ARM::BI__builtin_arm_mve_vmulhq_m_u8:
return AliasName == "vmulhq_m_u8" || AliasName == "vmulhq_m";
case ARM::BI__builtin_arm_mve_vmulhq_s16:
return AliasName == "vmulhq_s16" || AliasName == "vmulhq";
case ARM::BI__builtin_arm_mve_vmulhq_s32:
return AliasName == "vmulhq_s32" || AliasName == "vmulhq";
case ARM::BI__builtin_arm_mve_vmulhq_s8:
return AliasName == "vmulhq_s8" || AliasName == "vmulhq";
case ARM::BI__builtin_arm_mve_vmulhq_u16:
return AliasName == "vmulhq_u16" || AliasName == "vmulhq";
case ARM::BI__builtin_arm_mve_vmulhq_u32:
return AliasName == "vmulhq_u32" || AliasName == "vmulhq";
case ARM::BI__builtin_arm_mve_vmulhq_u8:
return AliasName == "vmulhq_u8" || AliasName == "vmulhq";
case ARM::BI__builtin_arm_mve_vmulhq_x_s16:
return AliasName == "vmulhq_x_s16" || AliasName == "vmulhq_x";
case ARM::BI__builtin_arm_mve_vmulhq_x_s32:
return AliasName == "vmulhq_x_s32" || AliasName == "vmulhq_x";
case ARM::BI__builtin_arm_mve_vmulhq_x_s8:
return AliasName == "vmulhq_x_s8" || AliasName == "vmulhq_x";
case ARM::BI__builtin_arm_mve_vmulhq_x_u16:
return AliasName == "vmulhq_x_u16" || AliasName == "vmulhq_x";
case ARM::BI__builtin_arm_mve_vmulhq_x_u32:
return AliasName == "vmulhq_x_u32" || AliasName == "vmulhq_x";
case ARM::BI__builtin_arm_mve_vmulhq_x_u8:
return AliasName == "vmulhq_x_u8" || AliasName == "vmulhq_x";
case ARM::BI__builtin_arm_mve_vmullbq_int_m_s16:
return AliasName == "vmullbq_int_m_s16" || AliasName == "vmullbq_int_m";
case ARM::BI__builtin_arm_mve_vmullbq_int_m_s32:
return AliasName == "vmullbq_int_m_s32" || AliasName == "vmullbq_int_m";
case ARM::BI__builtin_arm_mve_vmullbq_int_m_s8:
return AliasName == "vmullbq_int_m_s8" || AliasName == "vmullbq_int_m";
case ARM::BI__builtin_arm_mve_vmullbq_int_m_u16:
return AliasName == "vmullbq_int_m_u16" || AliasName == "vmullbq_int_m";
case ARM::BI__builtin_arm_mve_vmullbq_int_m_u32:
return AliasName == "vmullbq_int_m_u32" || AliasName == "vmullbq_int_m";
case ARM::BI__builtin_arm_mve_vmullbq_int_m_u8:
return AliasName == "vmullbq_int_m_u8" || AliasName == "vmullbq_int_m";
case ARM::BI__builtin_arm_mve_vmullbq_int_s16:
return AliasName == "vmullbq_int_s16" || AliasName == "vmullbq_int";
case ARM::BI__builtin_arm_mve_vmullbq_int_s32:
return AliasName == "vmullbq_int_s32" || AliasName == "vmullbq_int";
case ARM::BI__builtin_arm_mve_vmullbq_int_s8:
return AliasName == "vmullbq_int_s8" || AliasName == "vmullbq_int";
case ARM::BI__builtin_arm_mve_vmullbq_int_u16:
return AliasName == "vmullbq_int_u16" || AliasName == "vmullbq_int";
case ARM::BI__builtin_arm_mve_vmullbq_int_u32:
return AliasName == "vmullbq_int_u32" || AliasName == "vmullbq_int";
case ARM::BI__builtin_arm_mve_vmullbq_int_u8:
return AliasName == "vmullbq_int_u8" || AliasName == "vmullbq_int";
case ARM::BI__builtin_arm_mve_vmullbq_int_x_s16:
return AliasName == "vmullbq_int_x_s16" || AliasName == "vmullbq_int_x";
case ARM::BI__builtin_arm_mve_vmullbq_int_x_s32:
return AliasName == "vmullbq_int_x_s32" || AliasName == "vmullbq_int_x";
case ARM::BI__builtin_arm_mve_vmullbq_int_x_s8:
return AliasName == "vmullbq_int_x_s8" || AliasName == "vmullbq_int_x";
case ARM::BI__builtin_arm_mve_vmullbq_int_x_u16:
return AliasName == "vmullbq_int_x_u16" || AliasName == "vmullbq_int_x";
case ARM::BI__builtin_arm_mve_vmullbq_int_x_u32:
return AliasName == "vmullbq_int_x_u32" || AliasName == "vmullbq_int_x";
case ARM::BI__builtin_arm_mve_vmullbq_int_x_u8:
return AliasName == "vmullbq_int_x_u8" || AliasName == "vmullbq_int_x";
case ARM::BI__builtin_arm_mve_vmullbq_poly_m_p16:
return AliasName == "vmullbq_poly_m_p16" || AliasName == "vmullbq_poly_m";
case ARM::BI__builtin_arm_mve_vmullbq_poly_m_p8:
return AliasName == "vmullbq_poly_m_p8" || AliasName == "vmullbq_poly_m";
case ARM::BI__builtin_arm_mve_vmullbq_poly_p16:
return AliasName == "vmullbq_poly_p16" || AliasName == "vmullbq_poly";
case ARM::BI__builtin_arm_mve_vmullbq_poly_p8:
return AliasName == "vmullbq_poly_p8" || AliasName == "vmullbq_poly";
case ARM::BI__builtin_arm_mve_vmullbq_poly_x_p16:
return AliasName == "vmullbq_poly_x_p16" || AliasName == "vmullbq_poly_x";
case ARM::BI__builtin_arm_mve_vmullbq_poly_x_p8:
return AliasName == "vmullbq_poly_x_p8" || AliasName == "vmullbq_poly_x";
case ARM::BI__builtin_arm_mve_vmulltq_int_m_s16:
return AliasName == "vmulltq_int_m_s16" || AliasName == "vmulltq_int_m";
case ARM::BI__builtin_arm_mve_vmulltq_int_m_s32:
return AliasName == "vmulltq_int_m_s32" || AliasName == "vmulltq_int_m";
case ARM::BI__builtin_arm_mve_vmulltq_int_m_s8:
return AliasName == "vmulltq_int_m_s8" || AliasName == "vmulltq_int_m";
case ARM::BI__builtin_arm_mve_vmulltq_int_m_u16:
return AliasName == "vmulltq_int_m_u16" || AliasName == "vmulltq_int_m";
case ARM::BI__builtin_arm_mve_vmulltq_int_m_u32:
return AliasName == "vmulltq_int_m_u32" || AliasName == "vmulltq_int_m";
case ARM::BI__builtin_arm_mve_vmulltq_int_m_u8:
return AliasName == "vmulltq_int_m_u8" || AliasName == "vmulltq_int_m";
case ARM::BI__builtin_arm_mve_vmulltq_int_s16:
return AliasName == "vmulltq_int_s16" || AliasName == "vmulltq_int";
case ARM::BI__builtin_arm_mve_vmulltq_int_s32:
return AliasName == "vmulltq_int_s32" || AliasName == "vmulltq_int";
case ARM::BI__builtin_arm_mve_vmulltq_int_s8:
return AliasName == "vmulltq_int_s8" || AliasName == "vmulltq_int";
case ARM::BI__builtin_arm_mve_vmulltq_int_u16:
return AliasName == "vmulltq_int_u16" || AliasName == "vmulltq_int";
case ARM::BI__builtin_arm_mve_vmulltq_int_u32:
return AliasName == "vmulltq_int_u32" || AliasName == "vmulltq_int";
case ARM::BI__builtin_arm_mve_vmulltq_int_u8:
return AliasName == "vmulltq_int_u8" || AliasName == "vmulltq_int";
case ARM::BI__builtin_arm_mve_vmulltq_int_x_s16:
return AliasName == "vmulltq_int_x_s16" || AliasName == "vmulltq_int_x";
case ARM::BI__builtin_arm_mve_vmulltq_int_x_s32:
return AliasName == "vmulltq_int_x_s32" || AliasName == "vmulltq_int_x";
case ARM::BI__builtin_arm_mve_vmulltq_int_x_s8:
return AliasName == "vmulltq_int_x_s8" || AliasName == "vmulltq_int_x";
case ARM::BI__builtin_arm_mve_vmulltq_int_x_u16:
return AliasName == "vmulltq_int_x_u16" || AliasName == "vmulltq_int_x";
case ARM::BI__builtin_arm_mve_vmulltq_int_x_u32:
return AliasName == "vmulltq_int_x_u32" || AliasName == "vmulltq_int_x";
case ARM::BI__builtin_arm_mve_vmulltq_int_x_u8:
return AliasName == "vmulltq_int_x_u8" || AliasName == "vmulltq_int_x";
case ARM::BI__builtin_arm_mve_vmulltq_poly_m_p16:
return AliasName == "vmulltq_poly_m_p16" || AliasName == "vmulltq_poly_m";
case ARM::BI__builtin_arm_mve_vmulltq_poly_m_p8:
return AliasName == "vmulltq_poly_m_p8" || AliasName == "vmulltq_poly_m";
case ARM::BI__builtin_arm_mve_vmulltq_poly_p16:
return AliasName == "vmulltq_poly_p16" || AliasName == "vmulltq_poly";
case ARM::BI__builtin_arm_mve_vmulltq_poly_p8:
return AliasName == "vmulltq_poly_p8" || AliasName == "vmulltq_poly";
case ARM::BI__builtin_arm_mve_vmulltq_poly_x_p16:
return AliasName == "vmulltq_poly_x_p16" || AliasName == "vmulltq_poly_x";
case ARM::BI__builtin_arm_mve_vmulltq_poly_x_p8:
return AliasName == "vmulltq_poly_x_p8" || AliasName == "vmulltq_poly_x";
case ARM::BI__builtin_arm_mve_vmulq_f16:
return AliasName == "vmulq_f16" || AliasName == "vmulq";
case ARM::BI__builtin_arm_mve_vmulq_f32:
return AliasName == "vmulq_f32" || AliasName == "vmulq";
case ARM::BI__builtin_arm_mve_vmulq_m_f16:
return AliasName == "vmulq_m_f16" || AliasName == "vmulq_m";
case ARM::BI__builtin_arm_mve_vmulq_m_f32:
return AliasName == "vmulq_m_f32" || AliasName == "vmulq_m";
case ARM::BI__builtin_arm_mve_vmulq_m_s16:
return AliasName == "vmulq_m_s16" || AliasName == "vmulq_m";
case ARM::BI__builtin_arm_mve_vmulq_m_s32:
return AliasName == "vmulq_m_s32" || AliasName == "vmulq_m";
case ARM::BI__builtin_arm_mve_vmulq_m_s8:
return AliasName == "vmulq_m_s8" || AliasName == "vmulq_m";
case ARM::BI__builtin_arm_mve_vmulq_m_u16:
return AliasName == "vmulq_m_u16" || AliasName == "vmulq_m";
case ARM::BI__builtin_arm_mve_vmulq_m_u32:
return AliasName == "vmulq_m_u32" || AliasName == "vmulq_m";
case ARM::BI__builtin_arm_mve_vmulq_m_u8:
return AliasName == "vmulq_m_u8" || AliasName == "vmulq_m";
case ARM::BI__builtin_arm_mve_vmulq_s16:
return AliasName == "vmulq_s16" || AliasName == "vmulq";
case ARM::BI__builtin_arm_mve_vmulq_s32:
return AliasName == "vmulq_s32" || AliasName == "vmulq";
case ARM::BI__builtin_arm_mve_vmulq_s8:
return AliasName == "vmulq_s8" || AliasName == "vmulq";
case ARM::BI__builtin_arm_mve_vmulq_u16:
return AliasName == "vmulq_u16" || AliasName == "vmulq";
case ARM::BI__builtin_arm_mve_vmulq_u32:
return AliasName == "vmulq_u32" || AliasName == "vmulq";
case ARM::BI__builtin_arm_mve_vmulq_u8:
return AliasName == "vmulq_u8" || AliasName == "vmulq";
case ARM::BI__builtin_arm_mve_vmulq_x_f16:
return AliasName == "vmulq_x_f16" || AliasName == "vmulq_x";
case ARM::BI__builtin_arm_mve_vmulq_x_f32:
return AliasName == "vmulq_x_f32" || AliasName == "vmulq_x";
case ARM::BI__builtin_arm_mve_vmulq_x_s16:
return AliasName == "vmulq_x_s16" || AliasName == "vmulq_x";
case ARM::BI__builtin_arm_mve_vmulq_x_s32:
return AliasName == "vmulq_x_s32" || AliasName == "vmulq_x";
case ARM::BI__builtin_arm_mve_vmulq_x_s8:
return AliasName == "vmulq_x_s8" || AliasName == "vmulq_x";
case ARM::BI__builtin_arm_mve_vmulq_x_u16:
return AliasName == "vmulq_x_u16" || AliasName == "vmulq_x";
case ARM::BI__builtin_arm_mve_vmulq_x_u32:
return AliasName == "vmulq_x_u32" || AliasName == "vmulq_x";
case ARM::BI__builtin_arm_mve_vmulq_x_u8:
return AliasName == "vmulq_x_u8" || AliasName == "vmulq_x";
case ARM::BI__builtin_arm_mve_vornq_f16:
return AliasName == "vornq_f16" || AliasName == "vornq";
case ARM::BI__builtin_arm_mve_vornq_f32:
return AliasName == "vornq_f32" || AliasName == "vornq";
case ARM::BI__builtin_arm_mve_vornq_m_f16:
return AliasName == "vornq_m_f16" || AliasName == "vornq_m";
case ARM::BI__builtin_arm_mve_vornq_m_f32:
return AliasName == "vornq_m_f32" || AliasName == "vornq_m";
case ARM::BI__builtin_arm_mve_vornq_m_s16:
return AliasName == "vornq_m_s16" || AliasName == "vornq_m";
case ARM::BI__builtin_arm_mve_vornq_m_s32:
return AliasName == "vornq_m_s32" || AliasName == "vornq_m";
case ARM::BI__builtin_arm_mve_vornq_m_s8:
return AliasName == "vornq_m_s8" || AliasName == "vornq_m";
case ARM::BI__builtin_arm_mve_vornq_m_u16:
return AliasName == "vornq_m_u16" || AliasName == "vornq_m";
case ARM::BI__builtin_arm_mve_vornq_m_u32:
return AliasName == "vornq_m_u32" || AliasName == "vornq_m";
case ARM::BI__builtin_arm_mve_vornq_m_u8:
return AliasName == "vornq_m_u8" || AliasName == "vornq_m";
case ARM::BI__builtin_arm_mve_vornq_s16:
return AliasName == "vornq_s16" || AliasName == "vornq";
case ARM::BI__builtin_arm_mve_vornq_s32:
return AliasName == "vornq_s32" || AliasName == "vornq";
case ARM::BI__builtin_arm_mve_vornq_s8:
return AliasName == "vornq_s8" || AliasName == "vornq";
case ARM::BI__builtin_arm_mve_vornq_u16:
return AliasName == "vornq_u16" || AliasName == "vornq";
case ARM::BI__builtin_arm_mve_vornq_u32:
return AliasName == "vornq_u32" || AliasName == "vornq";
case ARM::BI__builtin_arm_mve_vornq_u8:
return AliasName == "vornq_u8" || AliasName == "vornq";
case ARM::BI__builtin_arm_mve_vornq_x_f16:
return AliasName == "vornq_x_f16" || AliasName == "vornq_x";
case ARM::BI__builtin_arm_mve_vornq_x_f32:
return AliasName == "vornq_x_f32" || AliasName == "vornq_x";
case ARM::BI__builtin_arm_mve_vornq_x_s16:
return AliasName == "vornq_x_s16" || AliasName == "vornq_x";
case ARM::BI__builtin_arm_mve_vornq_x_s32:
return AliasName == "vornq_x_s32" || AliasName == "vornq_x";
case ARM::BI__builtin_arm_mve_vornq_x_s8:
return AliasName == "vornq_x_s8" || AliasName == "vornq_x";
case ARM::BI__builtin_arm_mve_vornq_x_u16:
return AliasName == "vornq_x_u16" || AliasName == "vornq_x";
case ARM::BI__builtin_arm_mve_vornq_x_u32:
return AliasName == "vornq_x_u32" || AliasName == "vornq_x";
case ARM::BI__builtin_arm_mve_vornq_x_u8:
return AliasName == "vornq_x_u8" || AliasName == "vornq_x";
case ARM::BI__builtin_arm_mve_vorrq_f16:
return AliasName == "vorrq_f16" || AliasName == "vorrq";
case ARM::BI__builtin_arm_mve_vorrq_f32:
return AliasName == "vorrq_f32" || AliasName == "vorrq";
case ARM::BI__builtin_arm_mve_vorrq_m_f16:
return AliasName == "vorrq_m_f16" || AliasName == "vorrq_m";
case ARM::BI__builtin_arm_mve_vorrq_m_f32:
return AliasName == "vorrq_m_f32" || AliasName == "vorrq_m";
case ARM::BI__builtin_arm_mve_vorrq_m_s16:
return AliasName == "vorrq_m_s16" || AliasName == "vorrq_m";
case ARM::BI__builtin_arm_mve_vorrq_m_s32:
return AliasName == "vorrq_m_s32" || AliasName == "vorrq_m";
case ARM::BI__builtin_arm_mve_vorrq_m_s8:
return AliasName == "vorrq_m_s8" || AliasName == "vorrq_m";
case ARM::BI__builtin_arm_mve_vorrq_m_u16:
return AliasName == "vorrq_m_u16" || AliasName == "vorrq_m";
case ARM::BI__builtin_arm_mve_vorrq_m_u32:
return AliasName == "vorrq_m_u32" || AliasName == "vorrq_m";
case ARM::BI__builtin_arm_mve_vorrq_m_u8:
return AliasName == "vorrq_m_u8" || AliasName == "vorrq_m";
case ARM::BI__builtin_arm_mve_vorrq_s16:
return AliasName == "vorrq_s16" || AliasName == "vorrq";
case ARM::BI__builtin_arm_mve_vorrq_s32:
return AliasName == "vorrq_s32" || AliasName == "vorrq";
case ARM::BI__builtin_arm_mve_vorrq_s8:
return AliasName == "vorrq_s8" || AliasName == "vorrq";
case ARM::BI__builtin_arm_mve_vorrq_u16:
return AliasName == "vorrq_u16" || AliasName == "vorrq";
case ARM::BI__builtin_arm_mve_vorrq_u32:
return AliasName == "vorrq_u32" || AliasName == "vorrq";
case ARM::BI__builtin_arm_mve_vorrq_u8:
return AliasName == "vorrq_u8" || AliasName == "vorrq";
case ARM::BI__builtin_arm_mve_vorrq_x_f16:
return AliasName == "vorrq_x_f16" || AliasName == "vorrq_x";
case ARM::BI__builtin_arm_mve_vorrq_x_f32:
return AliasName == "vorrq_x_f32" || AliasName == "vorrq_x";
case ARM::BI__builtin_arm_mve_vorrq_x_s16:
return AliasName == "vorrq_x_s16" || AliasName == "vorrq_x";
case ARM::BI__builtin_arm_mve_vorrq_x_s32:
return AliasName == "vorrq_x_s32" || AliasName == "vorrq_x";
case ARM::BI__builtin_arm_mve_vorrq_x_s8:
return AliasName == "vorrq_x_s8" || AliasName == "vorrq_x";
case ARM::BI__builtin_arm_mve_vorrq_x_u16:
return AliasName == "vorrq_x_u16" || AliasName == "vorrq_x";
case ARM::BI__builtin_arm_mve_vorrq_x_u32:
return AliasName == "vorrq_x_u32" || AliasName == "vorrq_x";
case ARM::BI__builtin_arm_mve_vorrq_x_u8:
return AliasName == "vorrq_x_u8" || AliasName == "vorrq_x";
case ARM::BI__builtin_arm_mve_vpnot:
return AliasName == "vpnot";
case ARM::BI__builtin_arm_mve_vpselq_f16:
return AliasName == "vpselq_f16" || AliasName == "vpselq";
case ARM::BI__builtin_arm_mve_vpselq_f32:
return AliasName == "vpselq_f32" || AliasName == "vpselq";
case ARM::BI__builtin_arm_mve_vpselq_s16:
return AliasName == "vpselq_s16" || AliasName == "vpselq";
case ARM::BI__builtin_arm_mve_vpselq_s32:
return AliasName == "vpselq_s32" || AliasName == "vpselq";
case ARM::BI__builtin_arm_mve_vpselq_s64:
return AliasName == "vpselq_s64" || AliasName == "vpselq";
case ARM::BI__builtin_arm_mve_vpselq_s8:
return AliasName == "vpselq_s8" || AliasName == "vpselq";
case ARM::BI__builtin_arm_mve_vpselq_u16:
return AliasName == "vpselq_u16" || AliasName == "vpselq";
case ARM::BI__builtin_arm_mve_vpselq_u32:
return AliasName == "vpselq_u32" || AliasName == "vpselq";
case ARM::BI__builtin_arm_mve_vpselq_u64:
return AliasName == "vpselq_u64" || AliasName == "vpselq";
case ARM::BI__builtin_arm_mve_vpselq_u8:
return AliasName == "vpselq_u8" || AliasName == "vpselq";
case ARM::BI__builtin_arm_mve_vqaddq_m_s16:
return AliasName == "vqaddq_m_s16" || AliasName == "vqaddq_m";
case ARM::BI__builtin_arm_mve_vqaddq_m_s32:
return AliasName == "vqaddq_m_s32" || AliasName == "vqaddq_m";
case ARM::BI__builtin_arm_mve_vqaddq_m_s8:
return AliasName == "vqaddq_m_s8" || AliasName == "vqaddq_m";
case ARM::BI__builtin_arm_mve_vqaddq_m_u16:
return AliasName == "vqaddq_m_u16" || AliasName == "vqaddq_m";
case ARM::BI__builtin_arm_mve_vqaddq_m_u32:
return AliasName == "vqaddq_m_u32" || AliasName == "vqaddq_m";
case ARM::BI__builtin_arm_mve_vqaddq_m_u8:
return AliasName == "vqaddq_m_u8" || AliasName == "vqaddq_m";
case ARM::BI__builtin_arm_mve_vqaddq_s16:
return AliasName == "vqaddq_s16" || AliasName == "vqaddq";
case ARM::BI__builtin_arm_mve_vqaddq_s32:
return AliasName == "vqaddq_s32" || AliasName == "vqaddq";
case ARM::BI__builtin_arm_mve_vqaddq_s8:
return AliasName == "vqaddq_s8" || AliasName == "vqaddq";
case ARM::BI__builtin_arm_mve_vqaddq_u16:
return AliasName == "vqaddq_u16" || AliasName == "vqaddq";
case ARM::BI__builtin_arm_mve_vqaddq_u32:
return AliasName == "vqaddq_u32" || AliasName == "vqaddq";
case ARM::BI__builtin_arm_mve_vqaddq_u8:
return AliasName == "vqaddq_u8" || AliasName == "vqaddq";
case ARM::BI__builtin_arm_mve_vqdmulhq_m_s16:
return AliasName == "vqdmulhq_m_s16" || AliasName == "vqdmulhq_m";
case ARM::BI__builtin_arm_mve_vqdmulhq_m_s32:
return AliasName == "vqdmulhq_m_s32" || AliasName == "vqdmulhq_m";
case ARM::BI__builtin_arm_mve_vqdmulhq_m_s8:
return AliasName == "vqdmulhq_m_s8" || AliasName == "vqdmulhq_m";
case ARM::BI__builtin_arm_mve_vqdmulhq_s16:
return AliasName == "vqdmulhq_s16" || AliasName == "vqdmulhq";
case ARM::BI__builtin_arm_mve_vqdmulhq_s32:
return AliasName == "vqdmulhq_s32" || AliasName == "vqdmulhq";
case ARM::BI__builtin_arm_mve_vqdmulhq_s8:
return AliasName == "vqdmulhq_s8" || AliasName == "vqdmulhq";
case ARM::BI__builtin_arm_mve_vqrdmulhq_m_s16:
return AliasName == "vqrdmulhq_m_s16" || AliasName == "vqrdmulhq_m";
case ARM::BI__builtin_arm_mve_vqrdmulhq_m_s32:
return AliasName == "vqrdmulhq_m_s32" || AliasName == "vqrdmulhq_m";
case ARM::BI__builtin_arm_mve_vqrdmulhq_m_s8:
return AliasName == "vqrdmulhq_m_s8" || AliasName == "vqrdmulhq_m";
case ARM::BI__builtin_arm_mve_vqrdmulhq_s16:
return AliasName == "vqrdmulhq_s16" || AliasName == "vqrdmulhq";
case ARM::BI__builtin_arm_mve_vqrdmulhq_s32:
return AliasName == "vqrdmulhq_s32" || AliasName == "vqrdmulhq";
case ARM::BI__builtin_arm_mve_vqrdmulhq_s8:
return AliasName == "vqrdmulhq_s8" || AliasName == "vqrdmulhq";
case ARM::BI__builtin_arm_mve_vqrshlq_m_n_s16:
return AliasName == "vqrshlq_m_n_s16" || AliasName == "vqrshlq_m_n";
case ARM::BI__builtin_arm_mve_vqrshlq_m_n_s32:
return AliasName == "vqrshlq_m_n_s32" || AliasName == "vqrshlq_m_n";
case ARM::BI__builtin_arm_mve_vqrshlq_m_n_s8:
return AliasName == "vqrshlq_m_n_s8" || AliasName == "vqrshlq_m_n";
case ARM::BI__builtin_arm_mve_vqrshlq_m_n_u16:
return AliasName == "vqrshlq_m_n_u16" || AliasName == "vqrshlq_m_n";
case ARM::BI__builtin_arm_mve_vqrshlq_m_n_u32:
return AliasName == "vqrshlq_m_n_u32" || AliasName == "vqrshlq_m_n";
case ARM::BI__builtin_arm_mve_vqrshlq_m_n_u8:
return AliasName == "vqrshlq_m_n_u8" || AliasName == "vqrshlq_m_n";
case ARM::BI__builtin_arm_mve_vqrshlq_m_s16:
return AliasName == "vqrshlq_m_s16" || AliasName == "vqrshlq_m";
case ARM::BI__builtin_arm_mve_vqrshlq_m_s32:
return AliasName == "vqrshlq_m_s32" || AliasName == "vqrshlq_m";
case ARM::BI__builtin_arm_mve_vqrshlq_m_s8:
return AliasName == "vqrshlq_m_s8" || AliasName == "vqrshlq_m";
case ARM::BI__builtin_arm_mve_vqrshlq_m_u16:
return AliasName == "vqrshlq_m_u16" || AliasName == "vqrshlq_m";
case ARM::BI__builtin_arm_mve_vqrshlq_m_u32:
return AliasName == "vqrshlq_m_u32" || AliasName == "vqrshlq_m";
case ARM::BI__builtin_arm_mve_vqrshlq_m_u8:
return AliasName == "vqrshlq_m_u8" || AliasName == "vqrshlq_m";
case ARM::BI__builtin_arm_mve_vqrshlq_n_s16:
return AliasName == "vqrshlq_n_s16" || AliasName == "vqrshlq";
case ARM::BI__builtin_arm_mve_vqrshlq_n_s32:
return AliasName == "vqrshlq_n_s32" || AliasName == "vqrshlq";
case ARM::BI__builtin_arm_mve_vqrshlq_n_s8:
return AliasName == "vqrshlq_n_s8" || AliasName == "vqrshlq";
case ARM::BI__builtin_arm_mve_vqrshlq_n_u16:
return AliasName == "vqrshlq_n_u16" || AliasName == "vqrshlq";
case ARM::BI__builtin_arm_mve_vqrshlq_n_u32:
return AliasName == "vqrshlq_n_u32" || AliasName == "vqrshlq";
case ARM::BI__builtin_arm_mve_vqrshlq_n_u8:
return AliasName == "vqrshlq_n_u8" || AliasName == "vqrshlq";
case ARM::BI__builtin_arm_mve_vqrshlq_s16:
return AliasName == "vqrshlq_s16" || AliasName == "vqrshlq";
case ARM::BI__builtin_arm_mve_vqrshlq_s32:
return AliasName == "vqrshlq_s32" || AliasName == "vqrshlq";
case ARM::BI__builtin_arm_mve_vqrshlq_s8:
return AliasName == "vqrshlq_s8" || AliasName == "vqrshlq";
case ARM::BI__builtin_arm_mve_vqrshlq_u16:
return AliasName == "vqrshlq_u16" || AliasName == "vqrshlq";
case ARM::BI__builtin_arm_mve_vqrshlq_u32:
return AliasName == "vqrshlq_u32" || AliasName == "vqrshlq";
case ARM::BI__builtin_arm_mve_vqrshlq_u8:
return AliasName == "vqrshlq_u8" || AliasName == "vqrshlq";
case ARM::BI__builtin_arm_mve_vqrshrnbq_m_n_s16:
return AliasName == "vqrshrnbq_m_n_s16" || AliasName == "vqrshrnbq_m";
case ARM::BI__builtin_arm_mve_vqrshrnbq_m_n_s32:
return AliasName == "vqrshrnbq_m_n_s32" || AliasName == "vqrshrnbq_m";
case ARM::BI__builtin_arm_mve_vqrshrnbq_m_n_u16:
return AliasName == "vqrshrnbq_m_n_u16" || AliasName == "vqrshrnbq_m";
case ARM::BI__builtin_arm_mve_vqrshrnbq_m_n_u32:
return AliasName == "vqrshrnbq_m_n_u32" || AliasName == "vqrshrnbq_m";
case ARM::BI__builtin_arm_mve_vqrshrnbq_n_s16:
return AliasName == "vqrshrnbq_n_s16" || AliasName == "vqrshrnbq";
case ARM::BI__builtin_arm_mve_vqrshrnbq_n_s32:
return AliasName == "vqrshrnbq_n_s32" || AliasName == "vqrshrnbq";
case ARM::BI__builtin_arm_mve_vqrshrnbq_n_u16:
return AliasName == "vqrshrnbq_n_u16" || AliasName == "vqrshrnbq";
case ARM::BI__builtin_arm_mve_vqrshrnbq_n_u32:
return AliasName == "vqrshrnbq_n_u32" || AliasName == "vqrshrnbq";
case ARM::BI__builtin_arm_mve_vqrshrntq_m_n_s16:
return AliasName == "vqrshrntq_m_n_s16" || AliasName == "vqrshrntq_m";
case ARM::BI__builtin_arm_mve_vqrshrntq_m_n_s32:
return AliasName == "vqrshrntq_m_n_s32" || AliasName == "vqrshrntq_m";
case ARM::BI__builtin_arm_mve_vqrshrntq_m_n_u16:
return AliasName == "vqrshrntq_m_n_u16" || AliasName == "vqrshrntq_m";
case ARM::BI__builtin_arm_mve_vqrshrntq_m_n_u32:
return AliasName == "vqrshrntq_m_n_u32" || AliasName == "vqrshrntq_m";
case ARM::BI__builtin_arm_mve_vqrshrntq_n_s16:
return AliasName == "vqrshrntq_n_s16" || AliasName == "vqrshrntq";
case ARM::BI__builtin_arm_mve_vqrshrntq_n_s32:
return AliasName == "vqrshrntq_n_s32" || AliasName == "vqrshrntq";
case ARM::BI__builtin_arm_mve_vqrshrntq_n_u16:
return AliasName == "vqrshrntq_n_u16" || AliasName == "vqrshrntq";
case ARM::BI__builtin_arm_mve_vqrshrntq_n_u32:
return AliasName == "vqrshrntq_n_u32" || AliasName == "vqrshrntq";
case ARM::BI__builtin_arm_mve_vqrshrunbq_m_n_s16:
return AliasName == "vqrshrunbq_m_n_s16" || AliasName == "vqrshrunbq_m";
case ARM::BI__builtin_arm_mve_vqrshrunbq_m_n_s32:
return AliasName == "vqrshrunbq_m_n_s32" || AliasName == "vqrshrunbq_m";
case ARM::BI__builtin_arm_mve_vqrshrunbq_n_s16:
return AliasName == "vqrshrunbq_n_s16" || AliasName == "vqrshrunbq";
case ARM::BI__builtin_arm_mve_vqrshrunbq_n_s32:
return AliasName == "vqrshrunbq_n_s32" || AliasName == "vqrshrunbq";
case ARM::BI__builtin_arm_mve_vqrshruntq_m_n_s16:
return AliasName == "vqrshruntq_m_n_s16" || AliasName == "vqrshruntq_m";
case ARM::BI__builtin_arm_mve_vqrshruntq_m_n_s32:
return AliasName == "vqrshruntq_m_n_s32" || AliasName == "vqrshruntq_m";
case ARM::BI__builtin_arm_mve_vqrshruntq_n_s16:
return AliasName == "vqrshruntq_n_s16" || AliasName == "vqrshruntq";
case ARM::BI__builtin_arm_mve_vqrshruntq_n_s32:
return AliasName == "vqrshruntq_n_s32" || AliasName == "vqrshruntq";
case ARM::BI__builtin_arm_mve_vqshlq_m_n_s16:
return AliasName == "vqshlq_m_n_s16" || AliasName == "vqshlq_m_n";
case ARM::BI__builtin_arm_mve_vqshlq_m_n_s32:
return AliasName == "vqshlq_m_n_s32" || AliasName == "vqshlq_m_n";
case ARM::BI__builtin_arm_mve_vqshlq_m_n_s8:
return AliasName == "vqshlq_m_n_s8" || AliasName == "vqshlq_m_n";
case ARM::BI__builtin_arm_mve_vqshlq_m_n_u16:
return AliasName == "vqshlq_m_n_u16" || AliasName == "vqshlq_m_n";
case ARM::BI__builtin_arm_mve_vqshlq_m_n_u32:
return AliasName == "vqshlq_m_n_u32" || AliasName == "vqshlq_m_n";
case ARM::BI__builtin_arm_mve_vqshlq_m_n_u8:
return AliasName == "vqshlq_m_n_u8" || AliasName == "vqshlq_m_n";
case ARM::BI__builtin_arm_mve_vqshlq_m_r_s16:
return AliasName == "vqshlq_m_r_s16" || AliasName == "vqshlq_m_r";
case ARM::BI__builtin_arm_mve_vqshlq_m_r_s32:
return AliasName == "vqshlq_m_r_s32" || AliasName == "vqshlq_m_r";
case ARM::BI__builtin_arm_mve_vqshlq_m_r_s8:
return AliasName == "vqshlq_m_r_s8" || AliasName == "vqshlq_m_r";
case ARM::BI__builtin_arm_mve_vqshlq_m_r_u16:
return AliasName == "vqshlq_m_r_u16" || AliasName == "vqshlq_m_r";
case ARM::BI__builtin_arm_mve_vqshlq_m_r_u32:
return AliasName == "vqshlq_m_r_u32" || AliasName == "vqshlq_m_r";
case ARM::BI__builtin_arm_mve_vqshlq_m_r_u8:
return AliasName == "vqshlq_m_r_u8" || AliasName == "vqshlq_m_r";
case ARM::BI__builtin_arm_mve_vqshlq_m_s16:
return AliasName == "vqshlq_m_s16" || AliasName == "vqshlq_m";
case ARM::BI__builtin_arm_mve_vqshlq_m_s32:
return AliasName == "vqshlq_m_s32" || AliasName == "vqshlq_m";
case ARM::BI__builtin_arm_mve_vqshlq_m_s8:
return AliasName == "vqshlq_m_s8" || AliasName == "vqshlq_m";
case ARM::BI__builtin_arm_mve_vqshlq_m_u16:
return AliasName == "vqshlq_m_u16" || AliasName == "vqshlq_m";
case ARM::BI__builtin_arm_mve_vqshlq_m_u32:
return AliasName == "vqshlq_m_u32" || AliasName == "vqshlq_m";
case ARM::BI__builtin_arm_mve_vqshlq_m_u8:
return AliasName == "vqshlq_m_u8" || AliasName == "vqshlq_m";
case ARM::BI__builtin_arm_mve_vqshlq_n_s16:
return AliasName == "vqshlq_n_s16" || AliasName == "vqshlq_n";
case ARM::BI__builtin_arm_mve_vqshlq_n_s32:
return AliasName == "vqshlq_n_s32" || AliasName == "vqshlq_n";
case ARM::BI__builtin_arm_mve_vqshlq_n_s8:
return AliasName == "vqshlq_n_s8" || AliasName == "vqshlq_n";
case ARM::BI__builtin_arm_mve_vqshlq_n_u16:
return AliasName == "vqshlq_n_u16" || AliasName == "vqshlq_n";
case ARM::BI__builtin_arm_mve_vqshlq_n_u32:
return AliasName == "vqshlq_n_u32" || AliasName == "vqshlq_n";
case ARM::BI__builtin_arm_mve_vqshlq_n_u8:
return AliasName == "vqshlq_n_u8" || AliasName == "vqshlq_n";
case ARM::BI__builtin_arm_mve_vqshlq_r_s16:
return AliasName == "vqshlq_r_s16" || AliasName == "vqshlq_r";
case ARM::BI__builtin_arm_mve_vqshlq_r_s32:
return AliasName == "vqshlq_r_s32" || AliasName == "vqshlq_r";
case ARM::BI__builtin_arm_mve_vqshlq_r_s8:
return AliasName == "vqshlq_r_s8" || AliasName == "vqshlq_r";
case ARM::BI__builtin_arm_mve_vqshlq_r_u16:
return AliasName == "vqshlq_r_u16" || AliasName == "vqshlq_r";
case ARM::BI__builtin_arm_mve_vqshlq_r_u32:
return AliasName == "vqshlq_r_u32" || AliasName == "vqshlq_r";
case ARM::BI__builtin_arm_mve_vqshlq_r_u8:
return AliasName == "vqshlq_r_u8" || AliasName == "vqshlq_r";
case ARM::BI__builtin_arm_mve_vqshlq_s16:
return AliasName == "vqshlq_s16" || AliasName == "vqshlq";
case ARM::BI__builtin_arm_mve_vqshlq_s32:
return AliasName == "vqshlq_s32" || AliasName == "vqshlq";
case ARM::BI__builtin_arm_mve_vqshlq_s8:
return AliasName == "vqshlq_s8" || AliasName == "vqshlq";
case ARM::BI__builtin_arm_mve_vqshlq_u16:
return AliasName == "vqshlq_u16" || AliasName == "vqshlq";
case ARM::BI__builtin_arm_mve_vqshlq_u32:
return AliasName == "vqshlq_u32" || AliasName == "vqshlq";
case ARM::BI__builtin_arm_mve_vqshlq_u8:
return AliasName == "vqshlq_u8" || AliasName == "vqshlq";
case ARM::BI__builtin_arm_mve_vqshluq_m_n_s16:
return AliasName == "vqshluq_m_n_s16" || AliasName == "vqshluq_m";
case ARM::BI__builtin_arm_mve_vqshluq_m_n_s32:
return AliasName == "vqshluq_m_n_s32" || AliasName == "vqshluq_m";
case ARM::BI__builtin_arm_mve_vqshluq_m_n_s8:
return AliasName == "vqshluq_m_n_s8" || AliasName == "vqshluq_m";
case ARM::BI__builtin_arm_mve_vqshluq_n_s16:
return AliasName == "vqshluq_n_s16" || AliasName == "vqshluq";
case ARM::BI__builtin_arm_mve_vqshluq_n_s32:
return AliasName == "vqshluq_n_s32" || AliasName == "vqshluq";
case ARM::BI__builtin_arm_mve_vqshluq_n_s8:
return AliasName == "vqshluq_n_s8" || AliasName == "vqshluq";
case ARM::BI__builtin_arm_mve_vqshrnbq_m_n_s16:
return AliasName == "vqshrnbq_m_n_s16" || AliasName == "vqshrnbq_m";
case ARM::BI__builtin_arm_mve_vqshrnbq_m_n_s32:
return AliasName == "vqshrnbq_m_n_s32" || AliasName == "vqshrnbq_m";
case ARM::BI__builtin_arm_mve_vqshrnbq_m_n_u16:
return AliasName == "vqshrnbq_m_n_u16" || AliasName == "vqshrnbq_m";
case ARM::BI__builtin_arm_mve_vqshrnbq_m_n_u32:
return AliasName == "vqshrnbq_m_n_u32" || AliasName == "vqshrnbq_m";
case ARM::BI__builtin_arm_mve_vqshrnbq_n_s16:
return AliasName == "vqshrnbq_n_s16" || AliasName == "vqshrnbq";
case ARM::BI__builtin_arm_mve_vqshrnbq_n_s32:
return AliasName == "vqshrnbq_n_s32" || AliasName == "vqshrnbq";
case ARM::BI__builtin_arm_mve_vqshrnbq_n_u16:
return AliasName == "vqshrnbq_n_u16" || AliasName == "vqshrnbq";
case ARM::BI__builtin_arm_mve_vqshrnbq_n_u32:
return AliasName == "vqshrnbq_n_u32" || AliasName == "vqshrnbq";
case ARM::BI__builtin_arm_mve_vqshrntq_m_n_s16:
return AliasName == "vqshrntq_m_n_s16" || AliasName == "vqshrntq_m";
case ARM::BI__builtin_arm_mve_vqshrntq_m_n_s32:
return AliasName == "vqshrntq_m_n_s32" || AliasName == "vqshrntq_m";
case ARM::BI__builtin_arm_mve_vqshrntq_m_n_u16:
return AliasName == "vqshrntq_m_n_u16" || AliasName == "vqshrntq_m";
case ARM::BI__builtin_arm_mve_vqshrntq_m_n_u32:
return AliasName == "vqshrntq_m_n_u32" || AliasName == "vqshrntq_m";
case ARM::BI__builtin_arm_mve_vqshrntq_n_s16:
return AliasName == "vqshrntq_n_s16" || AliasName == "vqshrntq";
case ARM::BI__builtin_arm_mve_vqshrntq_n_s32:
return AliasName == "vqshrntq_n_s32" || AliasName == "vqshrntq";
case ARM::BI__builtin_arm_mve_vqshrntq_n_u16:
return AliasName == "vqshrntq_n_u16" || AliasName == "vqshrntq";
case ARM::BI__builtin_arm_mve_vqshrntq_n_u32:
return AliasName == "vqshrntq_n_u32" || AliasName == "vqshrntq";
case ARM::BI__builtin_arm_mve_vqshrunbq_m_n_s16:
return AliasName == "vqshrunbq_m_n_s16" || AliasName == "vqshrunbq_m";
case ARM::BI__builtin_arm_mve_vqshrunbq_m_n_s32:
return AliasName == "vqshrunbq_m_n_s32" || AliasName == "vqshrunbq_m";
case ARM::BI__builtin_arm_mve_vqshrunbq_n_s16:
return AliasName == "vqshrunbq_n_s16" || AliasName == "vqshrunbq";
case ARM::BI__builtin_arm_mve_vqshrunbq_n_s32:
return AliasName == "vqshrunbq_n_s32" || AliasName == "vqshrunbq";
case ARM::BI__builtin_arm_mve_vqshruntq_m_n_s16:
return AliasName == "vqshruntq_m_n_s16" || AliasName == "vqshruntq_m";
case ARM::BI__builtin_arm_mve_vqshruntq_m_n_s32:
return AliasName == "vqshruntq_m_n_s32" || AliasName == "vqshruntq_m";
case ARM::BI__builtin_arm_mve_vqshruntq_n_s16:
return AliasName == "vqshruntq_n_s16" || AliasName == "vqshruntq";
case ARM::BI__builtin_arm_mve_vqshruntq_n_s32:
return AliasName == "vqshruntq_n_s32" || AliasName == "vqshruntq";
case ARM::BI__builtin_arm_mve_vqsubq_m_s16:
return AliasName == "vqsubq_m_s16" || AliasName == "vqsubq_m";
case ARM::BI__builtin_arm_mve_vqsubq_m_s32:
return AliasName == "vqsubq_m_s32" || AliasName == "vqsubq_m";
case ARM::BI__builtin_arm_mve_vqsubq_m_s8:
return AliasName == "vqsubq_m_s8" || AliasName == "vqsubq_m";
case ARM::BI__builtin_arm_mve_vqsubq_m_u16:
return AliasName == "vqsubq_m_u16" || AliasName == "vqsubq_m";
case ARM::BI__builtin_arm_mve_vqsubq_m_u32:
return AliasName == "vqsubq_m_u32" || AliasName == "vqsubq_m";
case ARM::BI__builtin_arm_mve_vqsubq_m_u8:
return AliasName == "vqsubq_m_u8" || AliasName == "vqsubq_m";
case ARM::BI__builtin_arm_mve_vqsubq_s16:
return AliasName == "vqsubq_s16" || AliasName == "vqsubq";
case ARM::BI__builtin_arm_mve_vqsubq_s32:
return AliasName == "vqsubq_s32" || AliasName == "vqsubq";
case ARM::BI__builtin_arm_mve_vqsubq_s8:
return AliasName == "vqsubq_s8" || AliasName == "vqsubq";
case ARM::BI__builtin_arm_mve_vqsubq_u16:
return AliasName == "vqsubq_u16" || AliasName == "vqsubq";
case ARM::BI__builtin_arm_mve_vqsubq_u32:
return AliasName == "vqsubq_u32" || AliasName == "vqsubq";
case ARM::BI__builtin_arm_mve_vqsubq_u8:
return AliasName == "vqsubq_u8" || AliasName == "vqsubq";
case ARM::BI__builtin_arm_mve_vreinterpretq_f16_f32:
return AliasName == "vreinterpretq_f16_f32" || AliasName == "vreinterpretq_f16";
case ARM::BI__builtin_arm_mve_vreinterpretq_f16_s16:
return AliasName == "vreinterpretq_f16_s16" || AliasName == "vreinterpretq_f16";
case ARM::BI__builtin_arm_mve_vreinterpretq_f16_s32:
return AliasName == "vreinterpretq_f16_s32" || AliasName == "vreinterpretq_f16";
case ARM::BI__builtin_arm_mve_vreinterpretq_f16_s64:
return AliasName == "vreinterpretq_f16_s64" || AliasName == "vreinterpretq_f16";
case ARM::BI__builtin_arm_mve_vreinterpretq_f16_s8:
return AliasName == "vreinterpretq_f16_s8" || AliasName == "vreinterpretq_f16";
case ARM::BI__builtin_arm_mve_vreinterpretq_f16_u16:
return AliasName == "vreinterpretq_f16_u16" || AliasName == "vreinterpretq_f16";
case ARM::BI__builtin_arm_mve_vreinterpretq_f16_u32:
return AliasName == "vreinterpretq_f16_u32" || AliasName == "vreinterpretq_f16";
case ARM::BI__builtin_arm_mve_vreinterpretq_f16_u64:
return AliasName == "vreinterpretq_f16_u64" || AliasName == "vreinterpretq_f16";
case ARM::BI__builtin_arm_mve_vreinterpretq_f16_u8:
return AliasName == "vreinterpretq_f16_u8" || AliasName == "vreinterpretq_f16";
case ARM::BI__builtin_arm_mve_vreinterpretq_f32_f16:
return AliasName == "vreinterpretq_f32_f16" || AliasName == "vreinterpretq_f32";
case ARM::BI__builtin_arm_mve_vreinterpretq_f32_s16:
return AliasName == "vreinterpretq_f32_s16" || AliasName == "vreinterpretq_f32";
case ARM::BI__builtin_arm_mve_vreinterpretq_f32_s32:
return AliasName == "vreinterpretq_f32_s32" || AliasName == "vreinterpretq_f32";
case ARM::BI__builtin_arm_mve_vreinterpretq_f32_s64:
return AliasName == "vreinterpretq_f32_s64" || AliasName == "vreinterpretq_f32";
case ARM::BI__builtin_arm_mve_vreinterpretq_f32_s8:
return AliasName == "vreinterpretq_f32_s8" || AliasName == "vreinterpretq_f32";
case ARM::BI__builtin_arm_mve_vreinterpretq_f32_u16:
return AliasName == "vreinterpretq_f32_u16" || AliasName == "vreinterpretq_f32";
case ARM::BI__builtin_arm_mve_vreinterpretq_f32_u32:
return AliasName == "vreinterpretq_f32_u32" || AliasName == "vreinterpretq_f32";
case ARM::BI__builtin_arm_mve_vreinterpretq_f32_u64:
return AliasName == "vreinterpretq_f32_u64" || AliasName == "vreinterpretq_f32";
case ARM::BI__builtin_arm_mve_vreinterpretq_f32_u8:
return AliasName == "vreinterpretq_f32_u8" || AliasName == "vreinterpretq_f32";
case ARM::BI__builtin_arm_mve_vreinterpretq_s16_f16:
return AliasName == "vreinterpretq_s16_f16" || AliasName == "vreinterpretq_s16";
case ARM::BI__builtin_arm_mve_vreinterpretq_s16_f32:
return AliasName == "vreinterpretq_s16_f32" || AliasName == "vreinterpretq_s16";
case ARM::BI__builtin_arm_mve_vreinterpretq_s16_s32:
return AliasName == "vreinterpretq_s16_s32" || AliasName == "vreinterpretq_s16";
case ARM::BI__builtin_arm_mve_vreinterpretq_s16_s64:
return AliasName == "vreinterpretq_s16_s64" || AliasName == "vreinterpretq_s16";
case ARM::BI__builtin_arm_mve_vreinterpretq_s16_s8:
return AliasName == "vreinterpretq_s16_s8" || AliasName == "vreinterpretq_s16";
case ARM::BI__builtin_arm_mve_vreinterpretq_s16_u16:
return AliasName == "vreinterpretq_s16_u16" || AliasName == "vreinterpretq_s16";
case ARM::BI__builtin_arm_mve_vreinterpretq_s16_u32:
return AliasName == "vreinterpretq_s16_u32" || AliasName == "vreinterpretq_s16";
case ARM::BI__builtin_arm_mve_vreinterpretq_s16_u64:
return AliasName == "vreinterpretq_s16_u64" || AliasName == "vreinterpretq_s16";
case ARM::BI__builtin_arm_mve_vreinterpretq_s16_u8:
return AliasName == "vreinterpretq_s16_u8" || AliasName == "vreinterpretq_s16";
case ARM::BI__builtin_arm_mve_vreinterpretq_s32_f16:
return AliasName == "vreinterpretq_s32_f16" || AliasName == "vreinterpretq_s32";
case ARM::BI__builtin_arm_mve_vreinterpretq_s32_f32:
return AliasName == "vreinterpretq_s32_f32" || AliasName == "vreinterpretq_s32";
case ARM::BI__builtin_arm_mve_vreinterpretq_s32_s16:
return AliasName == "vreinterpretq_s32_s16" || AliasName == "vreinterpretq_s32";
case ARM::BI__builtin_arm_mve_vreinterpretq_s32_s64:
return AliasName == "vreinterpretq_s32_s64" || AliasName == "vreinterpretq_s32";
case ARM::BI__builtin_arm_mve_vreinterpretq_s32_s8:
return AliasName == "vreinterpretq_s32_s8" || AliasName == "vreinterpretq_s32";
case ARM::BI__builtin_arm_mve_vreinterpretq_s32_u16:
return AliasName == "vreinterpretq_s32_u16" || AliasName == "vreinterpretq_s32";
case ARM::BI__builtin_arm_mve_vreinterpretq_s32_u32:
return AliasName == "vreinterpretq_s32_u32" || AliasName == "vreinterpretq_s32";
case ARM::BI__builtin_arm_mve_vreinterpretq_s32_u64:
return AliasName == "vreinterpretq_s32_u64" || AliasName == "vreinterpretq_s32";
case ARM::BI__builtin_arm_mve_vreinterpretq_s32_u8:
return AliasName == "vreinterpretq_s32_u8" || AliasName == "vreinterpretq_s32";
case ARM::BI__builtin_arm_mve_vreinterpretq_s64_f16:
return AliasName == "vreinterpretq_s64_f16" || AliasName == "vreinterpretq_s64";
case ARM::BI__builtin_arm_mve_vreinterpretq_s64_f32:
return AliasName == "vreinterpretq_s64_f32" || AliasName == "vreinterpretq_s64";
case ARM::BI__builtin_arm_mve_vreinterpretq_s64_s16:
return AliasName == "vreinterpretq_s64_s16" || AliasName == "vreinterpretq_s64";
case ARM::BI__builtin_arm_mve_vreinterpretq_s64_s32:
return AliasName == "vreinterpretq_s64_s32" || AliasName == "vreinterpretq_s64";
case ARM::BI__builtin_arm_mve_vreinterpretq_s64_s8:
return AliasName == "vreinterpretq_s64_s8" || AliasName == "vreinterpretq_s64";
case ARM::BI__builtin_arm_mve_vreinterpretq_s64_u16:
return AliasName == "vreinterpretq_s64_u16" || AliasName == "vreinterpretq_s64";
case ARM::BI__builtin_arm_mve_vreinterpretq_s64_u32:
return AliasName == "vreinterpretq_s64_u32" || AliasName == "vreinterpretq_s64";
case ARM::BI__builtin_arm_mve_vreinterpretq_s64_u64:
return AliasName == "vreinterpretq_s64_u64" || AliasName == "vreinterpretq_s64";
case ARM::BI__builtin_arm_mve_vreinterpretq_s64_u8:
return AliasName == "vreinterpretq_s64_u8" || AliasName == "vreinterpretq_s64";
case ARM::BI__builtin_arm_mve_vreinterpretq_s8_f16:
return AliasName == "vreinterpretq_s8_f16" || AliasName == "vreinterpretq_s8";
case ARM::BI__builtin_arm_mve_vreinterpretq_s8_f32:
return AliasName == "vreinterpretq_s8_f32" || AliasName == "vreinterpretq_s8";
case ARM::BI__builtin_arm_mve_vreinterpretq_s8_s16:
return AliasName == "vreinterpretq_s8_s16" || AliasName == "vreinterpretq_s8";
case ARM::BI__builtin_arm_mve_vreinterpretq_s8_s32:
return AliasName == "vreinterpretq_s8_s32" || AliasName == "vreinterpretq_s8";
case ARM::BI__builtin_arm_mve_vreinterpretq_s8_s64:
return AliasName == "vreinterpretq_s8_s64" || AliasName == "vreinterpretq_s8";
case ARM::BI__builtin_arm_mve_vreinterpretq_s8_u16:
return AliasName == "vreinterpretq_s8_u16" || AliasName == "vreinterpretq_s8";
case ARM::BI__builtin_arm_mve_vreinterpretq_s8_u32:
return AliasName == "vreinterpretq_s8_u32" || AliasName == "vreinterpretq_s8";
case ARM::BI__builtin_arm_mve_vreinterpretq_s8_u64:
return AliasName == "vreinterpretq_s8_u64" || AliasName == "vreinterpretq_s8";
case ARM::BI__builtin_arm_mve_vreinterpretq_s8_u8:
return AliasName == "vreinterpretq_s8_u8" || AliasName == "vreinterpretq_s8";
case ARM::BI__builtin_arm_mve_vreinterpretq_u16_f16:
return AliasName == "vreinterpretq_u16_f16" || AliasName == "vreinterpretq_u16";
case ARM::BI__builtin_arm_mve_vreinterpretq_u16_f32:
return AliasName == "vreinterpretq_u16_f32" || AliasName == "vreinterpretq_u16";
case ARM::BI__builtin_arm_mve_vreinterpretq_u16_s16:
return AliasName == "vreinterpretq_u16_s16" || AliasName == "vreinterpretq_u16";
case ARM::BI__builtin_arm_mve_vreinterpretq_u16_s32:
return AliasName == "vreinterpretq_u16_s32" || AliasName == "vreinterpretq_u16";
case ARM::BI__builtin_arm_mve_vreinterpretq_u16_s64:
return AliasName == "vreinterpretq_u16_s64" || AliasName == "vreinterpretq_u16";
case ARM::BI__builtin_arm_mve_vreinterpretq_u16_s8:
return AliasName == "vreinterpretq_u16_s8" || AliasName == "vreinterpretq_u16";
case ARM::BI__builtin_arm_mve_vreinterpretq_u16_u32:
return AliasName == "vreinterpretq_u16_u32" || AliasName == "vreinterpretq_u16";
case ARM::BI__builtin_arm_mve_vreinterpretq_u16_u64:
return AliasName == "vreinterpretq_u16_u64" || AliasName == "vreinterpretq_u16";
case ARM::BI__builtin_arm_mve_vreinterpretq_u16_u8:
return AliasName == "vreinterpretq_u16_u8" || AliasName == "vreinterpretq_u16";
case ARM::BI__builtin_arm_mve_vreinterpretq_u32_f16:
return AliasName == "vreinterpretq_u32_f16" || AliasName == "vreinterpretq_u32";
case ARM::BI__builtin_arm_mve_vreinterpretq_u32_f32:
return AliasName == "vreinterpretq_u32_f32" || AliasName == "vreinterpretq_u32";
case ARM::BI__builtin_arm_mve_vreinterpretq_u32_s16:
return AliasName == "vreinterpretq_u32_s16" || AliasName == "vreinterpretq_u32";
case ARM::BI__builtin_arm_mve_vreinterpretq_u32_s32:
return AliasName == "vreinterpretq_u32_s32" || AliasName == "vreinterpretq_u32";
case ARM::BI__builtin_arm_mve_vreinterpretq_u32_s64:
return AliasName == "vreinterpretq_u32_s64" || AliasName == "vreinterpretq_u32";
case ARM::BI__builtin_arm_mve_vreinterpretq_u32_s8:
return AliasName == "vreinterpretq_u32_s8" || AliasName == "vreinterpretq_u32";
case ARM::BI__builtin_arm_mve_vreinterpretq_u32_u16:
return AliasName == "vreinterpretq_u32_u16" || AliasName == "vreinterpretq_u32";
case ARM::BI__builtin_arm_mve_vreinterpretq_u32_u64:
return AliasName == "vreinterpretq_u32_u64" || AliasName == "vreinterpretq_u32";
case ARM::BI__builtin_arm_mve_vreinterpretq_u32_u8:
return AliasName == "vreinterpretq_u32_u8" || AliasName == "vreinterpretq_u32";
case ARM::BI__builtin_arm_mve_vreinterpretq_u64_f16:
return AliasName == "vreinterpretq_u64_f16" || AliasName == "vreinterpretq_u64";
case ARM::BI__builtin_arm_mve_vreinterpretq_u64_f32:
return AliasName == "vreinterpretq_u64_f32" || AliasName == "vreinterpretq_u64";
case ARM::BI__builtin_arm_mve_vreinterpretq_u64_s16:
return AliasName == "vreinterpretq_u64_s16" || AliasName == "vreinterpretq_u64";
case ARM::BI__builtin_arm_mve_vreinterpretq_u64_s32:
return AliasName == "vreinterpretq_u64_s32" || AliasName == "vreinterpretq_u64";
case ARM::BI__builtin_arm_mve_vreinterpretq_u64_s64:
return AliasName == "vreinterpretq_u64_s64" || AliasName == "vreinterpretq_u64";
case ARM::BI__builtin_arm_mve_vreinterpretq_u64_s8:
return AliasName == "vreinterpretq_u64_s8" || AliasName == "vreinterpretq_u64";
case ARM::BI__builtin_arm_mve_vreinterpretq_u64_u16:
return AliasName == "vreinterpretq_u64_u16" || AliasName == "vreinterpretq_u64";
case ARM::BI__builtin_arm_mve_vreinterpretq_u64_u32:
return AliasName == "vreinterpretq_u64_u32" || AliasName == "vreinterpretq_u64";
case ARM::BI__builtin_arm_mve_vreinterpretq_u64_u8:
return AliasName == "vreinterpretq_u64_u8" || AliasName == "vreinterpretq_u64";
case ARM::BI__builtin_arm_mve_vreinterpretq_u8_f16:
return AliasName == "vreinterpretq_u8_f16" || AliasName == "vreinterpretq_u8";
case ARM::BI__builtin_arm_mve_vreinterpretq_u8_f32:
return AliasName == "vreinterpretq_u8_f32" || AliasName == "vreinterpretq_u8";
case ARM::BI__builtin_arm_mve_vreinterpretq_u8_s16:
return AliasName == "vreinterpretq_u8_s16" || AliasName == "vreinterpretq_u8";
case ARM::BI__builtin_arm_mve_vreinterpretq_u8_s32:
return AliasName == "vreinterpretq_u8_s32" || AliasName == "vreinterpretq_u8";
case ARM::BI__builtin_arm_mve_vreinterpretq_u8_s64:
return AliasName == "vreinterpretq_u8_s64" || AliasName == "vreinterpretq_u8";
case ARM::BI__builtin_arm_mve_vreinterpretq_u8_s8:
return AliasName == "vreinterpretq_u8_s8" || AliasName == "vreinterpretq_u8";
case ARM::BI__builtin_arm_mve_vreinterpretq_u8_u16:
return AliasName == "vreinterpretq_u8_u16" || AliasName == "vreinterpretq_u8";
case ARM::BI__builtin_arm_mve_vreinterpretq_u8_u32:
return AliasName == "vreinterpretq_u8_u32" || AliasName == "vreinterpretq_u8";
case ARM::BI__builtin_arm_mve_vreinterpretq_u8_u64:
return AliasName == "vreinterpretq_u8_u64" || AliasName == "vreinterpretq_u8";
case ARM::BI__builtin_arm_mve_vrhaddq_m_s16:
return AliasName == "vrhaddq_m_s16" || AliasName == "vrhaddq_m";
case ARM::BI__builtin_arm_mve_vrhaddq_m_s32:
return AliasName == "vrhaddq_m_s32" || AliasName == "vrhaddq_m";
case ARM::BI__builtin_arm_mve_vrhaddq_m_s8:
return AliasName == "vrhaddq_m_s8" || AliasName == "vrhaddq_m";
case ARM::BI__builtin_arm_mve_vrhaddq_m_u16:
return AliasName == "vrhaddq_m_u16" || AliasName == "vrhaddq_m";
case ARM::BI__builtin_arm_mve_vrhaddq_m_u32:
return AliasName == "vrhaddq_m_u32" || AliasName == "vrhaddq_m";
case ARM::BI__builtin_arm_mve_vrhaddq_m_u8:
return AliasName == "vrhaddq_m_u8" || AliasName == "vrhaddq_m";
case ARM::BI__builtin_arm_mve_vrhaddq_s16:
return AliasName == "vrhaddq_s16" || AliasName == "vrhaddq";
case ARM::BI__builtin_arm_mve_vrhaddq_s32:
return AliasName == "vrhaddq_s32" || AliasName == "vrhaddq";
case ARM::BI__builtin_arm_mve_vrhaddq_s8:
return AliasName == "vrhaddq_s8" || AliasName == "vrhaddq";
case ARM::BI__builtin_arm_mve_vrhaddq_u16:
return AliasName == "vrhaddq_u16" || AliasName == "vrhaddq";
case ARM::BI__builtin_arm_mve_vrhaddq_u32:
return AliasName == "vrhaddq_u32" || AliasName == "vrhaddq";
case ARM::BI__builtin_arm_mve_vrhaddq_u8:
return AliasName == "vrhaddq_u8" || AliasName == "vrhaddq";
case ARM::BI__builtin_arm_mve_vrhaddq_x_s16:
return AliasName == "vrhaddq_x_s16" || AliasName == "vrhaddq_x";
case ARM::BI__builtin_arm_mve_vrhaddq_x_s32:
return AliasName == "vrhaddq_x_s32" || AliasName == "vrhaddq_x";
case ARM::BI__builtin_arm_mve_vrhaddq_x_s8:
return AliasName == "vrhaddq_x_s8" || AliasName == "vrhaddq_x";
case ARM::BI__builtin_arm_mve_vrhaddq_x_u16:
return AliasName == "vrhaddq_x_u16" || AliasName == "vrhaddq_x";
case ARM::BI__builtin_arm_mve_vrhaddq_x_u32:
return AliasName == "vrhaddq_x_u32" || AliasName == "vrhaddq_x";
case ARM::BI__builtin_arm_mve_vrhaddq_x_u8:
return AliasName == "vrhaddq_x_u8" || AliasName == "vrhaddq_x";
case ARM::BI__builtin_arm_mve_vrmlaldavhaq_p_s32:
return AliasName == "vrmlaldavhaq_p_s32" || AliasName == "vrmlaldavhaq_p";
case ARM::BI__builtin_arm_mve_vrmlaldavhaq_p_u32:
return AliasName == "vrmlaldavhaq_p_u32" || AliasName == "vrmlaldavhaq_p";
case ARM::BI__builtin_arm_mve_vrmlaldavhaq_s32:
return AliasName == "vrmlaldavhaq_s32" || AliasName == "vrmlaldavhaq";
case ARM::BI__builtin_arm_mve_vrmlaldavhaq_u32:
return AliasName == "vrmlaldavhaq_u32" || AliasName == "vrmlaldavhaq";
case ARM::BI__builtin_arm_mve_vrmlaldavhaxq_p_s32:
return AliasName == "vrmlaldavhaxq_p_s32" || AliasName == "vrmlaldavhaxq_p";
case ARM::BI__builtin_arm_mve_vrmlaldavhaxq_s32:
return AliasName == "vrmlaldavhaxq_s32" || AliasName == "vrmlaldavhaxq";
case ARM::BI__builtin_arm_mve_vrmlaldavhq_p_s32:
return AliasName == "vrmlaldavhq_p_s32" || AliasName == "vrmlaldavhq_p";
case ARM::BI__builtin_arm_mve_vrmlaldavhq_p_u32:
return AliasName == "vrmlaldavhq_p_u32" || AliasName == "vrmlaldavhq_p";
case ARM::BI__builtin_arm_mve_vrmlaldavhq_s32:
return AliasName == "vrmlaldavhq_s32" || AliasName == "vrmlaldavhq";
case ARM::BI__builtin_arm_mve_vrmlaldavhq_u32:
return AliasName == "vrmlaldavhq_u32" || AliasName == "vrmlaldavhq";
case ARM::BI__builtin_arm_mve_vrmlaldavhxq_p_s32:
return AliasName == "vrmlaldavhxq_p_s32" || AliasName == "vrmlaldavhxq_p";
case ARM::BI__builtin_arm_mve_vrmlaldavhxq_s32:
return AliasName == "vrmlaldavhxq_s32" || AliasName == "vrmlaldavhxq";
case ARM::BI__builtin_arm_mve_vrmlsldavhaq_p_s32:
return AliasName == "vrmlsldavhaq_p_s32" || AliasName == "vrmlsldavhaq_p";
case ARM::BI__builtin_arm_mve_vrmlsldavhaq_s32:
return AliasName == "vrmlsldavhaq_s32" || AliasName == "vrmlsldavhaq";
case ARM::BI__builtin_arm_mve_vrmlsldavhaxq_p_s32:
return AliasName == "vrmlsldavhaxq_p_s32" || AliasName == "vrmlsldavhaxq_p";
case ARM::BI__builtin_arm_mve_vrmlsldavhaxq_s32:
return AliasName == "vrmlsldavhaxq_s32" || AliasName == "vrmlsldavhaxq";
case ARM::BI__builtin_arm_mve_vrmlsldavhq_p_s32:
return AliasName == "vrmlsldavhq_p_s32" || AliasName == "vrmlsldavhq_p";
case ARM::BI__builtin_arm_mve_vrmlsldavhq_s32:
return AliasName == "vrmlsldavhq_s32" || AliasName == "vrmlsldavhq";
case ARM::BI__builtin_arm_mve_vrmlsldavhxq_p_s32:
return AliasName == "vrmlsldavhxq_p_s32" || AliasName == "vrmlsldavhxq_p";
case ARM::BI__builtin_arm_mve_vrmlsldavhxq_s32:
return AliasName == "vrmlsldavhxq_s32" || AliasName == "vrmlsldavhxq";
case ARM::BI__builtin_arm_mve_vrmulhq_m_s16:
return AliasName == "vrmulhq_m_s16" || AliasName == "vrmulhq_m";
case ARM::BI__builtin_arm_mve_vrmulhq_m_s32:
return AliasName == "vrmulhq_m_s32" || AliasName == "vrmulhq_m";
case ARM::BI__builtin_arm_mve_vrmulhq_m_s8:
return AliasName == "vrmulhq_m_s8" || AliasName == "vrmulhq_m";
case ARM::BI__builtin_arm_mve_vrmulhq_m_u16:
return AliasName == "vrmulhq_m_u16" || AliasName == "vrmulhq_m";
case ARM::BI__builtin_arm_mve_vrmulhq_m_u32:
return AliasName == "vrmulhq_m_u32" || AliasName == "vrmulhq_m";
case ARM::BI__builtin_arm_mve_vrmulhq_m_u8:
return AliasName == "vrmulhq_m_u8" || AliasName == "vrmulhq_m";
case ARM::BI__builtin_arm_mve_vrmulhq_s16:
return AliasName == "vrmulhq_s16" || AliasName == "vrmulhq";
case ARM::BI__builtin_arm_mve_vrmulhq_s32:
return AliasName == "vrmulhq_s32" || AliasName == "vrmulhq";
case ARM::BI__builtin_arm_mve_vrmulhq_s8:
return AliasName == "vrmulhq_s8" || AliasName == "vrmulhq";
case ARM::BI__builtin_arm_mve_vrmulhq_u16:
return AliasName == "vrmulhq_u16" || AliasName == "vrmulhq";
case ARM::BI__builtin_arm_mve_vrmulhq_u32:
return AliasName == "vrmulhq_u32" || AliasName == "vrmulhq";
case ARM::BI__builtin_arm_mve_vrmulhq_u8:
return AliasName == "vrmulhq_u8" || AliasName == "vrmulhq";
case ARM::BI__builtin_arm_mve_vrmulhq_x_s16:
return AliasName == "vrmulhq_x_s16" || AliasName == "vrmulhq_x";
case ARM::BI__builtin_arm_mve_vrmulhq_x_s32:
return AliasName == "vrmulhq_x_s32" || AliasName == "vrmulhq_x";
case ARM::BI__builtin_arm_mve_vrmulhq_x_s8:
return AliasName == "vrmulhq_x_s8" || AliasName == "vrmulhq_x";
case ARM::BI__builtin_arm_mve_vrmulhq_x_u16:
return AliasName == "vrmulhq_x_u16" || AliasName == "vrmulhq_x";
case ARM::BI__builtin_arm_mve_vrmulhq_x_u32:
return AliasName == "vrmulhq_x_u32" || AliasName == "vrmulhq_x";
case ARM::BI__builtin_arm_mve_vrmulhq_x_u8:
return AliasName == "vrmulhq_x_u8" || AliasName == "vrmulhq_x";
case ARM::BI__builtin_arm_mve_vrshlq_m_n_s16:
return AliasName == "vrshlq_m_n_s16" || AliasName == "vrshlq_m_n";
case ARM::BI__builtin_arm_mve_vrshlq_m_n_s32:
return AliasName == "vrshlq_m_n_s32" || AliasName == "vrshlq_m_n";
case ARM::BI__builtin_arm_mve_vrshlq_m_n_s8:
return AliasName == "vrshlq_m_n_s8" || AliasName == "vrshlq_m_n";
case ARM::BI__builtin_arm_mve_vrshlq_m_n_u16:
return AliasName == "vrshlq_m_n_u16" || AliasName == "vrshlq_m_n";
case ARM::BI__builtin_arm_mve_vrshlq_m_n_u32:
return AliasName == "vrshlq_m_n_u32" || AliasName == "vrshlq_m_n";
case ARM::BI__builtin_arm_mve_vrshlq_m_n_u8:
return AliasName == "vrshlq_m_n_u8" || AliasName == "vrshlq_m_n";
case ARM::BI__builtin_arm_mve_vrshlq_m_s16:
return AliasName == "vrshlq_m_s16" || AliasName == "vrshlq_m";
case ARM::BI__builtin_arm_mve_vrshlq_m_s32:
return AliasName == "vrshlq_m_s32" || AliasName == "vrshlq_m";
case ARM::BI__builtin_arm_mve_vrshlq_m_s8:
return AliasName == "vrshlq_m_s8" || AliasName == "vrshlq_m";
case ARM::BI__builtin_arm_mve_vrshlq_m_u16:
return AliasName == "vrshlq_m_u16" || AliasName == "vrshlq_m";
case ARM::BI__builtin_arm_mve_vrshlq_m_u32:
return AliasName == "vrshlq_m_u32" || AliasName == "vrshlq_m";
case ARM::BI__builtin_arm_mve_vrshlq_m_u8:
return AliasName == "vrshlq_m_u8" || AliasName == "vrshlq_m";
case ARM::BI__builtin_arm_mve_vrshlq_n_s16:
return AliasName == "vrshlq_n_s16" || AliasName == "vrshlq";
case ARM::BI__builtin_arm_mve_vrshlq_n_s32:
return AliasName == "vrshlq_n_s32" || AliasName == "vrshlq";
case ARM::BI__builtin_arm_mve_vrshlq_n_s8:
return AliasName == "vrshlq_n_s8" || AliasName == "vrshlq";
case ARM::BI__builtin_arm_mve_vrshlq_n_u16:
return AliasName == "vrshlq_n_u16" || AliasName == "vrshlq";
case ARM::BI__builtin_arm_mve_vrshlq_n_u32:
return AliasName == "vrshlq_n_u32" || AliasName == "vrshlq";
case ARM::BI__builtin_arm_mve_vrshlq_n_u8:
return AliasName == "vrshlq_n_u8" || AliasName == "vrshlq";
case ARM::BI__builtin_arm_mve_vrshlq_s16:
return AliasName == "vrshlq_s16" || AliasName == "vrshlq";
case ARM::BI__builtin_arm_mve_vrshlq_s32:
return AliasName == "vrshlq_s32" || AliasName == "vrshlq";
case ARM::BI__builtin_arm_mve_vrshlq_s8:
return AliasName == "vrshlq_s8" || AliasName == "vrshlq";
case ARM::BI__builtin_arm_mve_vrshlq_u16:
return AliasName == "vrshlq_u16" || AliasName == "vrshlq";
case ARM::BI__builtin_arm_mve_vrshlq_u32:
return AliasName == "vrshlq_u32" || AliasName == "vrshlq";
case ARM::BI__builtin_arm_mve_vrshlq_u8:
return AliasName == "vrshlq_u8" || AliasName == "vrshlq";
case ARM::BI__builtin_arm_mve_vrshlq_x_s16:
return AliasName == "vrshlq_x_s16" || AliasName == "vrshlq_x";
case ARM::BI__builtin_arm_mve_vrshlq_x_s32:
return AliasName == "vrshlq_x_s32" || AliasName == "vrshlq_x";
case ARM::BI__builtin_arm_mve_vrshlq_x_s8:
return AliasName == "vrshlq_x_s8" || AliasName == "vrshlq_x";
case ARM::BI__builtin_arm_mve_vrshlq_x_u16:
return AliasName == "vrshlq_x_u16" || AliasName == "vrshlq_x";
case ARM::BI__builtin_arm_mve_vrshlq_x_u32:
return AliasName == "vrshlq_x_u32" || AliasName == "vrshlq_x";
case ARM::BI__builtin_arm_mve_vrshlq_x_u8:
return AliasName == "vrshlq_x_u8" || AliasName == "vrshlq_x";
case ARM::BI__builtin_arm_mve_vrshrnbq_m_n_s16:
return AliasName == "vrshrnbq_m_n_s16" || AliasName == "vrshrnbq_m";
case ARM::BI__builtin_arm_mve_vrshrnbq_m_n_s32:
return AliasName == "vrshrnbq_m_n_s32" || AliasName == "vrshrnbq_m";
case ARM::BI__builtin_arm_mve_vrshrnbq_m_n_u16:
return AliasName == "vrshrnbq_m_n_u16" || AliasName == "vrshrnbq_m";
case ARM::BI__builtin_arm_mve_vrshrnbq_m_n_u32:
return AliasName == "vrshrnbq_m_n_u32" || AliasName == "vrshrnbq_m";
case ARM::BI__builtin_arm_mve_vrshrnbq_n_s16:
return AliasName == "vrshrnbq_n_s16" || AliasName == "vrshrnbq";
case ARM::BI__builtin_arm_mve_vrshrnbq_n_s32:
return AliasName == "vrshrnbq_n_s32" || AliasName == "vrshrnbq";
case ARM::BI__builtin_arm_mve_vrshrnbq_n_u16:
return AliasName == "vrshrnbq_n_u16" || AliasName == "vrshrnbq";
case ARM::BI__builtin_arm_mve_vrshrnbq_n_u32:
return AliasName == "vrshrnbq_n_u32" || AliasName == "vrshrnbq";
case ARM::BI__builtin_arm_mve_vrshrntq_m_n_s16:
return AliasName == "vrshrntq_m_n_s16" || AliasName == "vrshrntq_m";
case ARM::BI__builtin_arm_mve_vrshrntq_m_n_s32:
return AliasName == "vrshrntq_m_n_s32" || AliasName == "vrshrntq_m";
case ARM::BI__builtin_arm_mve_vrshrntq_m_n_u16:
return AliasName == "vrshrntq_m_n_u16" || AliasName == "vrshrntq_m";
case ARM::BI__builtin_arm_mve_vrshrntq_m_n_u32:
return AliasName == "vrshrntq_m_n_u32" || AliasName == "vrshrntq_m";
case ARM::BI__builtin_arm_mve_vrshrntq_n_s16:
return AliasName == "vrshrntq_n_s16" || AliasName == "vrshrntq";
case ARM::BI__builtin_arm_mve_vrshrntq_n_s32:
return AliasName == "vrshrntq_n_s32" || AliasName == "vrshrntq";
case ARM::BI__builtin_arm_mve_vrshrntq_n_u16:
return AliasName == "vrshrntq_n_u16" || AliasName == "vrshrntq";
case ARM::BI__builtin_arm_mve_vrshrntq_n_u32:
return AliasName == "vrshrntq_n_u32" || AliasName == "vrshrntq";
case ARM::BI__builtin_arm_mve_vrshrq_m_n_s16:
return AliasName == "vrshrq_m_n_s16" || AliasName == "vrshrq_m";
case ARM::BI__builtin_arm_mve_vrshrq_m_n_s32:
return AliasName == "vrshrq_m_n_s32" || AliasName == "vrshrq_m";
case ARM::BI__builtin_arm_mve_vrshrq_m_n_s8:
return AliasName == "vrshrq_m_n_s8" || AliasName == "vrshrq_m";
case ARM::BI__builtin_arm_mve_vrshrq_m_n_u16:
return AliasName == "vrshrq_m_n_u16" || AliasName == "vrshrq_m";
case ARM::BI__builtin_arm_mve_vrshrq_m_n_u32:
return AliasName == "vrshrq_m_n_u32" || AliasName == "vrshrq_m";
case ARM::BI__builtin_arm_mve_vrshrq_m_n_u8:
return AliasName == "vrshrq_m_n_u8" || AliasName == "vrshrq_m";
case ARM::BI__builtin_arm_mve_vrshrq_n_s16:
return AliasName == "vrshrq_n_s16" || AliasName == "vrshrq";
case ARM::BI__builtin_arm_mve_vrshrq_n_s32:
return AliasName == "vrshrq_n_s32" || AliasName == "vrshrq";
case ARM::BI__builtin_arm_mve_vrshrq_n_s8:
return AliasName == "vrshrq_n_s8" || AliasName == "vrshrq";
case ARM::BI__builtin_arm_mve_vrshrq_n_u16:
return AliasName == "vrshrq_n_u16" || AliasName == "vrshrq";
case ARM::BI__builtin_arm_mve_vrshrq_n_u32:
return AliasName == "vrshrq_n_u32" || AliasName == "vrshrq";
case ARM::BI__builtin_arm_mve_vrshrq_n_u8:
return AliasName == "vrshrq_n_u8" || AliasName == "vrshrq";
case ARM::BI__builtin_arm_mve_vrshrq_x_n_s16:
return AliasName == "vrshrq_x_n_s16" || AliasName == "vrshrq_x";
case ARM::BI__builtin_arm_mve_vrshrq_x_n_s32:
return AliasName == "vrshrq_x_n_s32" || AliasName == "vrshrq_x";
case ARM::BI__builtin_arm_mve_vrshrq_x_n_s8:
return AliasName == "vrshrq_x_n_s8" || AliasName == "vrshrq_x";
case ARM::BI__builtin_arm_mve_vrshrq_x_n_u16:
return AliasName == "vrshrq_x_n_u16" || AliasName == "vrshrq_x";
case ARM::BI__builtin_arm_mve_vrshrq_x_n_u32:
return AliasName == "vrshrq_x_n_u32" || AliasName == "vrshrq_x";
case ARM::BI__builtin_arm_mve_vrshrq_x_n_u8:
return AliasName == "vrshrq_x_n_u8" || AliasName == "vrshrq_x";
case ARM::BI__builtin_arm_mve_vsetq_lane_f16:
return AliasName == "vsetq_lane_f16" || AliasName == "vsetq_lane";
case ARM::BI__builtin_arm_mve_vsetq_lane_f32:
return AliasName == "vsetq_lane_f32" || AliasName == "vsetq_lane";
case ARM::BI__builtin_arm_mve_vsetq_lane_s16:
return AliasName == "vsetq_lane_s16" || AliasName == "vsetq_lane";
case ARM::BI__builtin_arm_mve_vsetq_lane_s32:
return AliasName == "vsetq_lane_s32" || AliasName == "vsetq_lane";
case ARM::BI__builtin_arm_mve_vsetq_lane_s64:
return AliasName == "vsetq_lane_s64" || AliasName == "vsetq_lane";
case ARM::BI__builtin_arm_mve_vsetq_lane_s8:
return AliasName == "vsetq_lane_s8" || AliasName == "vsetq_lane";
case ARM::BI__builtin_arm_mve_vsetq_lane_u16:
return AliasName == "vsetq_lane_u16" || AliasName == "vsetq_lane";
case ARM::BI__builtin_arm_mve_vsetq_lane_u32:
return AliasName == "vsetq_lane_u32" || AliasName == "vsetq_lane";
case ARM::BI__builtin_arm_mve_vsetq_lane_u64:
return AliasName == "vsetq_lane_u64" || AliasName == "vsetq_lane";
case ARM::BI__builtin_arm_mve_vsetq_lane_u8:
return AliasName == "vsetq_lane_u8" || AliasName == "vsetq_lane";
case ARM::BI__builtin_arm_mve_vshllbq_m_n_s16:
return AliasName == "vshllbq_m_n_s16" || AliasName == "vshllbq_m";
case ARM::BI__builtin_arm_mve_vshllbq_m_n_s8:
return AliasName == "vshllbq_m_n_s8" || AliasName == "vshllbq_m";
case ARM::BI__builtin_arm_mve_vshllbq_m_n_u16:
return AliasName == "vshllbq_m_n_u16" || AliasName == "vshllbq_m";
case ARM::BI__builtin_arm_mve_vshllbq_m_n_u8:
return AliasName == "vshllbq_m_n_u8" || AliasName == "vshllbq_m";
case ARM::BI__builtin_arm_mve_vshllbq_n_s16:
return AliasName == "vshllbq_n_s16" || AliasName == "vshllbq";
case ARM::BI__builtin_arm_mve_vshllbq_n_s8:
return AliasName == "vshllbq_n_s8" || AliasName == "vshllbq";
case ARM::BI__builtin_arm_mve_vshllbq_n_u16:
return AliasName == "vshllbq_n_u16" || AliasName == "vshllbq";
case ARM::BI__builtin_arm_mve_vshllbq_n_u8:
return AliasName == "vshllbq_n_u8" || AliasName == "vshllbq";
case ARM::BI__builtin_arm_mve_vshllbq_x_n_s16:
return AliasName == "vshllbq_x_n_s16" || AliasName == "vshllbq_x";
case ARM::BI__builtin_arm_mve_vshllbq_x_n_s8:
return AliasName == "vshllbq_x_n_s8" || AliasName == "vshllbq_x";
case ARM::BI__builtin_arm_mve_vshllbq_x_n_u16:
return AliasName == "vshllbq_x_n_u16" || AliasName == "vshllbq_x";
case ARM::BI__builtin_arm_mve_vshllbq_x_n_u8:
return AliasName == "vshllbq_x_n_u8" || AliasName == "vshllbq_x";
case ARM::BI__builtin_arm_mve_vshlltq_m_n_s16:
return AliasName == "vshlltq_m_n_s16" || AliasName == "vshlltq_m";
case ARM::BI__builtin_arm_mve_vshlltq_m_n_s8:
return AliasName == "vshlltq_m_n_s8" || AliasName == "vshlltq_m";
case ARM::BI__builtin_arm_mve_vshlltq_m_n_u16:
return AliasName == "vshlltq_m_n_u16" || AliasName == "vshlltq_m";
case ARM::BI__builtin_arm_mve_vshlltq_m_n_u8:
return AliasName == "vshlltq_m_n_u8" || AliasName == "vshlltq_m";
case ARM::BI__builtin_arm_mve_vshlltq_n_s16:
return AliasName == "vshlltq_n_s16" || AliasName == "vshlltq";
case ARM::BI__builtin_arm_mve_vshlltq_n_s8:
return AliasName == "vshlltq_n_s8" || AliasName == "vshlltq";
case ARM::BI__builtin_arm_mve_vshlltq_n_u16:
return AliasName == "vshlltq_n_u16" || AliasName == "vshlltq";
case ARM::BI__builtin_arm_mve_vshlltq_n_u8:
return AliasName == "vshlltq_n_u8" || AliasName == "vshlltq";
case ARM::BI__builtin_arm_mve_vshlltq_x_n_s16:
return AliasName == "vshlltq_x_n_s16" || AliasName == "vshlltq_x";
case ARM::BI__builtin_arm_mve_vshlltq_x_n_s8:
return AliasName == "vshlltq_x_n_s8" || AliasName == "vshlltq_x";
case ARM::BI__builtin_arm_mve_vshlltq_x_n_u16:
return AliasName == "vshlltq_x_n_u16" || AliasName == "vshlltq_x";
case ARM::BI__builtin_arm_mve_vshlltq_x_n_u8:
return AliasName == "vshlltq_x_n_u8" || AliasName == "vshlltq_x";
case ARM::BI__builtin_arm_mve_vshlq_m_n_s16:
return AliasName == "vshlq_m_n_s16" || AliasName == "vshlq_m_n";
case ARM::BI__builtin_arm_mve_vshlq_m_n_s32:
return AliasName == "vshlq_m_n_s32" || AliasName == "vshlq_m_n";
case ARM::BI__builtin_arm_mve_vshlq_m_n_s8:
return AliasName == "vshlq_m_n_s8" || AliasName == "vshlq_m_n";
case ARM::BI__builtin_arm_mve_vshlq_m_n_u16:
return AliasName == "vshlq_m_n_u16" || AliasName == "vshlq_m_n";
case ARM::BI__builtin_arm_mve_vshlq_m_n_u32:
return AliasName == "vshlq_m_n_u32" || AliasName == "vshlq_m_n";
case ARM::BI__builtin_arm_mve_vshlq_m_n_u8:
return AliasName == "vshlq_m_n_u8" || AliasName == "vshlq_m_n";
case ARM::BI__builtin_arm_mve_vshlq_m_r_s16:
return AliasName == "vshlq_m_r_s16" || AliasName == "vshlq_m_r";
case ARM::BI__builtin_arm_mve_vshlq_m_r_s32:
return AliasName == "vshlq_m_r_s32" || AliasName == "vshlq_m_r";
case ARM::BI__builtin_arm_mve_vshlq_m_r_s8:
return AliasName == "vshlq_m_r_s8" || AliasName == "vshlq_m_r";
case ARM::BI__builtin_arm_mve_vshlq_m_r_u16:
return AliasName == "vshlq_m_r_u16" || AliasName == "vshlq_m_r";
case ARM::BI__builtin_arm_mve_vshlq_m_r_u32:
return AliasName == "vshlq_m_r_u32" || AliasName == "vshlq_m_r";
case ARM::BI__builtin_arm_mve_vshlq_m_r_u8:
return AliasName == "vshlq_m_r_u8" || AliasName == "vshlq_m_r";
case ARM::BI__builtin_arm_mve_vshlq_m_s16:
return AliasName == "vshlq_m_s16" || AliasName == "vshlq_m";
case ARM::BI__builtin_arm_mve_vshlq_m_s32:
return AliasName == "vshlq_m_s32" || AliasName == "vshlq_m";
case ARM::BI__builtin_arm_mve_vshlq_m_s8:
return AliasName == "vshlq_m_s8" || AliasName == "vshlq_m";
case ARM::BI__builtin_arm_mve_vshlq_m_u16:
return AliasName == "vshlq_m_u16" || AliasName == "vshlq_m";
case ARM::BI__builtin_arm_mve_vshlq_m_u32:
return AliasName == "vshlq_m_u32" || AliasName == "vshlq_m";
case ARM::BI__builtin_arm_mve_vshlq_m_u8:
return AliasName == "vshlq_m_u8" || AliasName == "vshlq_m";
case ARM::BI__builtin_arm_mve_vshlq_n_s16:
return AliasName == "vshlq_n_s16" || AliasName == "vshlq_n";
case ARM::BI__builtin_arm_mve_vshlq_n_s32:
return AliasName == "vshlq_n_s32" || AliasName == "vshlq_n";
case ARM::BI__builtin_arm_mve_vshlq_n_s8:
return AliasName == "vshlq_n_s8" || AliasName == "vshlq_n";
case ARM::BI__builtin_arm_mve_vshlq_n_u16:
return AliasName == "vshlq_n_u16" || AliasName == "vshlq_n";
case ARM::BI__builtin_arm_mve_vshlq_n_u32:
return AliasName == "vshlq_n_u32" || AliasName == "vshlq_n";
case ARM::BI__builtin_arm_mve_vshlq_n_u8:
return AliasName == "vshlq_n_u8" || AliasName == "vshlq_n";
case ARM::BI__builtin_arm_mve_vshlq_r_s16:
return AliasName == "vshlq_r_s16" || AliasName == "vshlq_r";
case ARM::BI__builtin_arm_mve_vshlq_r_s32:
return AliasName == "vshlq_r_s32" || AliasName == "vshlq_r";
case ARM::BI__builtin_arm_mve_vshlq_r_s8:
return AliasName == "vshlq_r_s8" || AliasName == "vshlq_r";
case ARM::BI__builtin_arm_mve_vshlq_r_u16:
return AliasName == "vshlq_r_u16" || AliasName == "vshlq_r";
case ARM::BI__builtin_arm_mve_vshlq_r_u32:
return AliasName == "vshlq_r_u32" || AliasName == "vshlq_r";
case ARM::BI__builtin_arm_mve_vshlq_r_u8:
return AliasName == "vshlq_r_u8" || AliasName == "vshlq_r";
case ARM::BI__builtin_arm_mve_vshlq_s16:
return AliasName == "vshlq_s16" || AliasName == "vshlq";
case ARM::BI__builtin_arm_mve_vshlq_s32:
return AliasName == "vshlq_s32" || AliasName == "vshlq";
case ARM::BI__builtin_arm_mve_vshlq_s8:
return AliasName == "vshlq_s8" || AliasName == "vshlq";
case ARM::BI__builtin_arm_mve_vshlq_u16:
return AliasName == "vshlq_u16" || AliasName == "vshlq";
case ARM::BI__builtin_arm_mve_vshlq_u32:
return AliasName == "vshlq_u32" || AliasName == "vshlq";
case ARM::BI__builtin_arm_mve_vshlq_u8:
return AliasName == "vshlq_u8" || AliasName == "vshlq";
case ARM::BI__builtin_arm_mve_vshlq_x_n_s16:
return AliasName == "vshlq_x_n_s16" || AliasName == "vshlq_x_n";
case ARM::BI__builtin_arm_mve_vshlq_x_n_s32:
return AliasName == "vshlq_x_n_s32" || AliasName == "vshlq_x_n";
case ARM::BI__builtin_arm_mve_vshlq_x_n_s8:
return AliasName == "vshlq_x_n_s8" || AliasName == "vshlq_x_n";
case ARM::BI__builtin_arm_mve_vshlq_x_n_u16:
return AliasName == "vshlq_x_n_u16" || AliasName == "vshlq_x_n";
case ARM::BI__builtin_arm_mve_vshlq_x_n_u32:
return AliasName == "vshlq_x_n_u32" || AliasName == "vshlq_x_n";
case ARM::BI__builtin_arm_mve_vshlq_x_n_u8:
return AliasName == "vshlq_x_n_u8" || AliasName == "vshlq_x_n";
case ARM::BI__builtin_arm_mve_vshlq_x_s16:
return AliasName == "vshlq_x_s16" || AliasName == "vshlq_x";
case ARM::BI__builtin_arm_mve_vshlq_x_s32:
return AliasName == "vshlq_x_s32" || AliasName == "vshlq_x";
case ARM::BI__builtin_arm_mve_vshlq_x_s8:
return AliasName == "vshlq_x_s8" || AliasName == "vshlq_x";
case ARM::BI__builtin_arm_mve_vshlq_x_u16:
return AliasName == "vshlq_x_u16" || AliasName == "vshlq_x";
case ARM::BI__builtin_arm_mve_vshlq_x_u32:
return AliasName == "vshlq_x_u32" || AliasName == "vshlq_x";
case ARM::BI__builtin_arm_mve_vshlq_x_u8:
return AliasName == "vshlq_x_u8" || AliasName == "vshlq_x";
case ARM::BI__builtin_arm_mve_vshrnbq_m_n_s16:
return AliasName == "vshrnbq_m_n_s16" || AliasName == "vshrnbq_m";
case ARM::BI__builtin_arm_mve_vshrnbq_m_n_s32:
return AliasName == "vshrnbq_m_n_s32" || AliasName == "vshrnbq_m";
case ARM::BI__builtin_arm_mve_vshrnbq_m_n_u16:
return AliasName == "vshrnbq_m_n_u16" || AliasName == "vshrnbq_m";
case ARM::BI__builtin_arm_mve_vshrnbq_m_n_u32:
return AliasName == "vshrnbq_m_n_u32" || AliasName == "vshrnbq_m";
case ARM::BI__builtin_arm_mve_vshrnbq_n_s16:
return AliasName == "vshrnbq_n_s16" || AliasName == "vshrnbq";
case ARM::BI__builtin_arm_mve_vshrnbq_n_s32:
return AliasName == "vshrnbq_n_s32" || AliasName == "vshrnbq";
case ARM::BI__builtin_arm_mve_vshrnbq_n_u16:
return AliasName == "vshrnbq_n_u16" || AliasName == "vshrnbq";
case ARM::BI__builtin_arm_mve_vshrnbq_n_u32:
return AliasName == "vshrnbq_n_u32" || AliasName == "vshrnbq";
case ARM::BI__builtin_arm_mve_vshrntq_m_n_s16:
return AliasName == "vshrntq_m_n_s16" || AliasName == "vshrntq_m";
case ARM::BI__builtin_arm_mve_vshrntq_m_n_s32:
return AliasName == "vshrntq_m_n_s32" || AliasName == "vshrntq_m";
case ARM::BI__builtin_arm_mve_vshrntq_m_n_u16:
return AliasName == "vshrntq_m_n_u16" || AliasName == "vshrntq_m";
case ARM::BI__builtin_arm_mve_vshrntq_m_n_u32:
return AliasName == "vshrntq_m_n_u32" || AliasName == "vshrntq_m";
case ARM::BI__builtin_arm_mve_vshrntq_n_s16:
return AliasName == "vshrntq_n_s16" || AliasName == "vshrntq";
case ARM::BI__builtin_arm_mve_vshrntq_n_s32:
return AliasName == "vshrntq_n_s32" || AliasName == "vshrntq";
case ARM::BI__builtin_arm_mve_vshrntq_n_u16:
return AliasName == "vshrntq_n_u16" || AliasName == "vshrntq";
case ARM::BI__builtin_arm_mve_vshrntq_n_u32:
return AliasName == "vshrntq_n_u32" || AliasName == "vshrntq";
case ARM::BI__builtin_arm_mve_vshrq_m_n_s16:
return AliasName == "vshrq_m_n_s16" || AliasName == "vshrq_m";
case ARM::BI__builtin_arm_mve_vshrq_m_n_s32:
return AliasName == "vshrq_m_n_s32" || AliasName == "vshrq_m";
case ARM::BI__builtin_arm_mve_vshrq_m_n_s8:
return AliasName == "vshrq_m_n_s8" || AliasName == "vshrq_m";
case ARM::BI__builtin_arm_mve_vshrq_m_n_u16:
return AliasName == "vshrq_m_n_u16" || AliasName == "vshrq_m";
case ARM::BI__builtin_arm_mve_vshrq_m_n_u32:
return AliasName == "vshrq_m_n_u32" || AliasName == "vshrq_m";
case ARM::BI__builtin_arm_mve_vshrq_m_n_u8:
return AliasName == "vshrq_m_n_u8" || AliasName == "vshrq_m";
case ARM::BI__builtin_arm_mve_vshrq_n_s16:
return AliasName == "vshrq_n_s16" || AliasName == "vshrq";
case ARM::BI__builtin_arm_mve_vshrq_n_s32:
return AliasName == "vshrq_n_s32" || AliasName == "vshrq";
case ARM::BI__builtin_arm_mve_vshrq_n_s8:
return AliasName == "vshrq_n_s8" || AliasName == "vshrq";
case ARM::BI__builtin_arm_mve_vshrq_n_u16:
return AliasName == "vshrq_n_u16" || AliasName == "vshrq";
case ARM::BI__builtin_arm_mve_vshrq_n_u32:
return AliasName == "vshrq_n_u32" || AliasName == "vshrq";
case ARM::BI__builtin_arm_mve_vshrq_n_u8:
return AliasName == "vshrq_n_u8" || AliasName == "vshrq";
case ARM::BI__builtin_arm_mve_vshrq_x_n_s16:
return AliasName == "vshrq_x_n_s16" || AliasName == "vshrq_x";
case ARM::BI__builtin_arm_mve_vshrq_x_n_s32:
return AliasName == "vshrq_x_n_s32" || AliasName == "vshrq_x";
case ARM::BI__builtin_arm_mve_vshrq_x_n_s8:
return AliasName == "vshrq_x_n_s8" || AliasName == "vshrq_x";
case ARM::BI__builtin_arm_mve_vshrq_x_n_u16:
return AliasName == "vshrq_x_n_u16" || AliasName == "vshrq_x";
case ARM::BI__builtin_arm_mve_vshrq_x_n_u32:
return AliasName == "vshrq_x_n_u32" || AliasName == "vshrq_x";
case ARM::BI__builtin_arm_mve_vshrq_x_n_u8:
return AliasName == "vshrq_x_n_u8" || AliasName == "vshrq_x";
case ARM::BI__builtin_arm_mve_vsliq_m_n_s16:
return AliasName == "vsliq_m_n_s16" || AliasName == "vsliq_m";
case ARM::BI__builtin_arm_mve_vsliq_m_n_s32:
return AliasName == "vsliq_m_n_s32" || AliasName == "vsliq_m";
case ARM::BI__builtin_arm_mve_vsliq_m_n_s8:
return AliasName == "vsliq_m_n_s8" || AliasName == "vsliq_m";
case ARM::BI__builtin_arm_mve_vsliq_m_n_u16:
return AliasName == "vsliq_m_n_u16" || AliasName == "vsliq_m";
case ARM::BI__builtin_arm_mve_vsliq_m_n_u32:
return AliasName == "vsliq_m_n_u32" || AliasName == "vsliq_m";
case ARM::BI__builtin_arm_mve_vsliq_m_n_u8:
return AliasName == "vsliq_m_n_u8" || AliasName == "vsliq_m";
case ARM::BI__builtin_arm_mve_vsliq_n_s16:
return AliasName == "vsliq_n_s16" || AliasName == "vsliq";
case ARM::BI__builtin_arm_mve_vsliq_n_s32:
return AliasName == "vsliq_n_s32" || AliasName == "vsliq";
case ARM::BI__builtin_arm_mve_vsliq_n_s8:
return AliasName == "vsliq_n_s8" || AliasName == "vsliq";
case ARM::BI__builtin_arm_mve_vsliq_n_u16:
return AliasName == "vsliq_n_u16" || AliasName == "vsliq";
case ARM::BI__builtin_arm_mve_vsliq_n_u32:
return AliasName == "vsliq_n_u32" || AliasName == "vsliq";
case ARM::BI__builtin_arm_mve_vsliq_n_u8:
return AliasName == "vsliq_n_u8" || AliasName == "vsliq";
case ARM::BI__builtin_arm_mve_vsriq_m_n_s16:
return AliasName == "vsriq_m_n_s16" || AliasName == "vsriq_m";
case ARM::BI__builtin_arm_mve_vsriq_m_n_s32:
return AliasName == "vsriq_m_n_s32" || AliasName == "vsriq_m";
case ARM::BI__builtin_arm_mve_vsriq_m_n_s8:
return AliasName == "vsriq_m_n_s8" || AliasName == "vsriq_m";
case ARM::BI__builtin_arm_mve_vsriq_m_n_u16:
return AliasName == "vsriq_m_n_u16" || AliasName == "vsriq_m";
case ARM::BI__builtin_arm_mve_vsriq_m_n_u32:
return AliasName == "vsriq_m_n_u32" || AliasName == "vsriq_m";
case ARM::BI__builtin_arm_mve_vsriq_m_n_u8:
return AliasName == "vsriq_m_n_u8" || AliasName == "vsriq_m";
case ARM::BI__builtin_arm_mve_vsriq_n_s16:
return AliasName == "vsriq_n_s16" || AliasName == "vsriq";
case ARM::BI__builtin_arm_mve_vsriq_n_s32:
return AliasName == "vsriq_n_s32" || AliasName == "vsriq";
case ARM::BI__builtin_arm_mve_vsriq_n_s8:
return AliasName == "vsriq_n_s8" || AliasName == "vsriq";
case ARM::BI__builtin_arm_mve_vsriq_n_u16:
return AliasName == "vsriq_n_u16" || AliasName == "vsriq";
case ARM::BI__builtin_arm_mve_vsriq_n_u32:
return AliasName == "vsriq_n_u32" || AliasName == "vsriq";
case ARM::BI__builtin_arm_mve_vsriq_n_u8:
return AliasName == "vsriq_n_u8" || AliasName == "vsriq";
case ARM::BI__builtin_arm_mve_vst1q_f16:
return AliasName == "vst1q_f16" || AliasName == "vst1q";
case ARM::BI__builtin_arm_mve_vst1q_f32:
return AliasName == "vst1q_f32" || AliasName == "vst1q";
case ARM::BI__builtin_arm_mve_vst1q_p_f16:
return AliasName == "vst1q_p_f16" || AliasName == "vst1q_p";
case ARM::BI__builtin_arm_mve_vst1q_p_f32:
return AliasName == "vst1q_p_f32" || AliasName == "vst1q_p";
case ARM::BI__builtin_arm_mve_vst1q_p_s16:
return AliasName == "vst1q_p_s16" || AliasName == "vst1q_p";
case ARM::BI__builtin_arm_mve_vst1q_p_s32:
return AliasName == "vst1q_p_s32" || AliasName == "vst1q_p";
case ARM::BI__builtin_arm_mve_vst1q_p_s8:
return AliasName == "vst1q_p_s8" || AliasName == "vst1q_p";
case ARM::BI__builtin_arm_mve_vst1q_p_u16:
return AliasName == "vst1q_p_u16" || AliasName == "vst1q_p";
case ARM::BI__builtin_arm_mve_vst1q_p_u32:
return AliasName == "vst1q_p_u32" || AliasName == "vst1q_p";
case ARM::BI__builtin_arm_mve_vst1q_p_u8:
return AliasName == "vst1q_p_u8" || AliasName == "vst1q_p";
case ARM::BI__builtin_arm_mve_vst1q_s16:
return AliasName == "vst1q_s16" || AliasName == "vst1q";
case ARM::BI__builtin_arm_mve_vst1q_s32:
return AliasName == "vst1q_s32" || AliasName == "vst1q";
case ARM::BI__builtin_arm_mve_vst1q_s8:
return AliasName == "vst1q_s8" || AliasName == "vst1q";
case ARM::BI__builtin_arm_mve_vst1q_u16:
return AliasName == "vst1q_u16" || AliasName == "vst1q";
case ARM::BI__builtin_arm_mve_vst1q_u32:
return AliasName == "vst1q_u32" || AliasName == "vst1q";
case ARM::BI__builtin_arm_mve_vst1q_u8:
return AliasName == "vst1q_u8" || AliasName == "vst1q";
case ARM::BI__builtin_arm_mve_vst2q_f16:
return AliasName == "vst2q_f16" || AliasName == "vst2q";
case ARM::BI__builtin_arm_mve_vst2q_f32:
return AliasName == "vst2q_f32" || AliasName == "vst2q";
case ARM::BI__builtin_arm_mve_vst2q_s16:
return AliasName == "vst2q_s16" || AliasName == "vst2q";
case ARM::BI__builtin_arm_mve_vst2q_s32:
return AliasName == "vst2q_s32" || AliasName == "vst2q";
case ARM::BI__builtin_arm_mve_vst2q_s8:
return AliasName == "vst2q_s8" || AliasName == "vst2q";
case ARM::BI__builtin_arm_mve_vst2q_u16:
return AliasName == "vst2q_u16" || AliasName == "vst2q";
case ARM::BI__builtin_arm_mve_vst2q_u32:
return AliasName == "vst2q_u32" || AliasName == "vst2q";
case ARM::BI__builtin_arm_mve_vst2q_u8:
return AliasName == "vst2q_u8" || AliasName == "vst2q";
case ARM::BI__builtin_arm_mve_vst4q_f16:
return AliasName == "vst4q_f16" || AliasName == "vst4q";
case ARM::BI__builtin_arm_mve_vst4q_f32:
return AliasName == "vst4q_f32" || AliasName == "vst4q";
case ARM::BI__builtin_arm_mve_vst4q_s16:
return AliasName == "vst4q_s16" || AliasName == "vst4q";
case ARM::BI__builtin_arm_mve_vst4q_s32:
return AliasName == "vst4q_s32" || AliasName == "vst4q";
case ARM::BI__builtin_arm_mve_vst4q_s8:
return AliasName == "vst4q_s8" || AliasName == "vst4q";
case ARM::BI__builtin_arm_mve_vst4q_u16:
return AliasName == "vst4q_u16" || AliasName == "vst4q";
case ARM::BI__builtin_arm_mve_vst4q_u32:
return AliasName == "vst4q_u32" || AliasName == "vst4q";
case ARM::BI__builtin_arm_mve_vst4q_u8:
return AliasName == "vst4q_u8" || AliasName == "vst4q";
case ARM::BI__builtin_arm_mve_vstrbq_p_s16:
return AliasName == "vstrbq_p_s16" || AliasName == "vstrbq_p";
case ARM::BI__builtin_arm_mve_vstrbq_p_s32:
return AliasName == "vstrbq_p_s32" || AliasName == "vstrbq_p";
case ARM::BI__builtin_arm_mve_vstrbq_p_s8:
return AliasName == "vstrbq_p_s8" || AliasName == "vstrbq_p";
case ARM::BI__builtin_arm_mve_vstrbq_p_u16:
return AliasName == "vstrbq_p_u16" || AliasName == "vstrbq_p";
case ARM::BI__builtin_arm_mve_vstrbq_p_u32:
return AliasName == "vstrbq_p_u32" || AliasName == "vstrbq_p";
case ARM::BI__builtin_arm_mve_vstrbq_p_u8:
return AliasName == "vstrbq_p_u8" || AliasName == "vstrbq_p";
case ARM::BI__builtin_arm_mve_vstrbq_s16:
return AliasName == "vstrbq_s16" || AliasName == "vstrbq";
case ARM::BI__builtin_arm_mve_vstrbq_s32:
return AliasName == "vstrbq_s32" || AliasName == "vstrbq";
case ARM::BI__builtin_arm_mve_vstrbq_s8:
return AliasName == "vstrbq_s8" || AliasName == "vstrbq";
case ARM::BI__builtin_arm_mve_vstrbq_scatter_offset_p_s16:
return AliasName == "vstrbq_scatter_offset_p_s16" || AliasName == "vstrbq_scatter_offset_p";
case ARM::BI__builtin_arm_mve_vstrbq_scatter_offset_p_s32:
return AliasName == "vstrbq_scatter_offset_p_s32" || AliasName == "vstrbq_scatter_offset_p";
case ARM::BI__builtin_arm_mve_vstrbq_scatter_offset_p_s8:
return AliasName == "vstrbq_scatter_offset_p_s8" || AliasName == "vstrbq_scatter_offset_p";
case ARM::BI__builtin_arm_mve_vstrbq_scatter_offset_p_u16:
return AliasName == "vstrbq_scatter_offset_p_u16" || AliasName == "vstrbq_scatter_offset_p";
case ARM::BI__builtin_arm_mve_vstrbq_scatter_offset_p_u32:
return AliasName == "vstrbq_scatter_offset_p_u32" || AliasName == "vstrbq_scatter_offset_p";
case ARM::BI__builtin_arm_mve_vstrbq_scatter_offset_p_u8:
return AliasName == "vstrbq_scatter_offset_p_u8" || AliasName == "vstrbq_scatter_offset_p";
case ARM::BI__builtin_arm_mve_vstrbq_scatter_offset_s16:
return AliasName == "vstrbq_scatter_offset_s16" || AliasName == "vstrbq_scatter_offset";
case ARM::BI__builtin_arm_mve_vstrbq_scatter_offset_s32:
return AliasName == "vstrbq_scatter_offset_s32" || AliasName == "vstrbq_scatter_offset";
case ARM::BI__builtin_arm_mve_vstrbq_scatter_offset_s8:
return AliasName == "vstrbq_scatter_offset_s8" || AliasName == "vstrbq_scatter_offset";
case ARM::BI__builtin_arm_mve_vstrbq_scatter_offset_u16:
return AliasName == "vstrbq_scatter_offset_u16" || AliasName == "vstrbq_scatter_offset";
case ARM::BI__builtin_arm_mve_vstrbq_scatter_offset_u32:
return AliasName == "vstrbq_scatter_offset_u32" || AliasName == "vstrbq_scatter_offset";
case ARM::BI__builtin_arm_mve_vstrbq_scatter_offset_u8:
return AliasName == "vstrbq_scatter_offset_u8" || AliasName == "vstrbq_scatter_offset";
case ARM::BI__builtin_arm_mve_vstrbq_u16:
return AliasName == "vstrbq_u16" || AliasName == "vstrbq";
case ARM::BI__builtin_arm_mve_vstrbq_u32:
return AliasName == "vstrbq_u32" || AliasName == "vstrbq";
case ARM::BI__builtin_arm_mve_vstrbq_u8:
return AliasName == "vstrbq_u8" || AliasName == "vstrbq";
case ARM::BI__builtin_arm_mve_vstrdq_scatter_base_p_s64:
return AliasName == "vstrdq_scatter_base_p_s64" || AliasName == "vstrdq_scatter_base_p";
case ARM::BI__builtin_arm_mve_vstrdq_scatter_base_p_u64:
return AliasName == "vstrdq_scatter_base_p_u64" || AliasName == "vstrdq_scatter_base_p";
case ARM::BI__builtin_arm_mve_vstrdq_scatter_base_s64:
return AliasName == "vstrdq_scatter_base_s64" || AliasName == "vstrdq_scatter_base";
case ARM::BI__builtin_arm_mve_vstrdq_scatter_base_u64:
return AliasName == "vstrdq_scatter_base_u64" || AliasName == "vstrdq_scatter_base";
case ARM::BI__builtin_arm_mve_vstrdq_scatter_base_wb_p_s64:
return AliasName == "vstrdq_scatter_base_wb_p_s64" || AliasName == "vstrdq_scatter_base_wb_p";
case ARM::BI__builtin_arm_mve_vstrdq_scatter_base_wb_p_u64:
return AliasName == "vstrdq_scatter_base_wb_p_u64" || AliasName == "vstrdq_scatter_base_wb_p";
case ARM::BI__builtin_arm_mve_vstrdq_scatter_base_wb_s64:
return AliasName == "vstrdq_scatter_base_wb_s64" || AliasName == "vstrdq_scatter_base_wb";
case ARM::BI__builtin_arm_mve_vstrdq_scatter_base_wb_u64:
return AliasName == "vstrdq_scatter_base_wb_u64" || AliasName == "vstrdq_scatter_base_wb";
case ARM::BI__builtin_arm_mve_vstrdq_scatter_offset_p_s64:
return AliasName == "vstrdq_scatter_offset_p_s64" || AliasName == "vstrdq_scatter_offset_p";
case ARM::BI__builtin_arm_mve_vstrdq_scatter_offset_p_u64:
return AliasName == "vstrdq_scatter_offset_p_u64" || AliasName == "vstrdq_scatter_offset_p";
case ARM::BI__builtin_arm_mve_vstrdq_scatter_offset_s64:
return AliasName == "vstrdq_scatter_offset_s64" || AliasName == "vstrdq_scatter_offset";
case ARM::BI__builtin_arm_mve_vstrdq_scatter_offset_u64:
return AliasName == "vstrdq_scatter_offset_u64" || AliasName == "vstrdq_scatter_offset";
case ARM::BI__builtin_arm_mve_vstrdq_scatter_shifted_offset_p_s64:
return AliasName == "vstrdq_scatter_shifted_offset_p_s64" || AliasName == "vstrdq_scatter_shifted_offset_p";
case ARM::BI__builtin_arm_mve_vstrdq_scatter_shifted_offset_p_u64:
return AliasName == "vstrdq_scatter_shifted_offset_p_u64" || AliasName == "vstrdq_scatter_shifted_offset_p";
case ARM::BI__builtin_arm_mve_vstrdq_scatter_shifted_offset_s64:
return AliasName == "vstrdq_scatter_shifted_offset_s64" || AliasName == "vstrdq_scatter_shifted_offset";
case ARM::BI__builtin_arm_mve_vstrdq_scatter_shifted_offset_u64:
return AliasName == "vstrdq_scatter_shifted_offset_u64" || AliasName == "vstrdq_scatter_shifted_offset";
case ARM::BI__builtin_arm_mve_vstrhq_f16:
return AliasName == "vstrhq_f16" || AliasName == "vstrhq";
case ARM::BI__builtin_arm_mve_vstrhq_p_f16:
return AliasName == "vstrhq_p_f16" || AliasName == "vstrhq_p";
case ARM::BI__builtin_arm_mve_vstrhq_p_s16:
return AliasName == "vstrhq_p_s16" || AliasName == "vstrhq_p";
case ARM::BI__builtin_arm_mve_vstrhq_p_s32:
return AliasName == "vstrhq_p_s32" || AliasName == "vstrhq_p";
case ARM::BI__builtin_arm_mve_vstrhq_p_u16:
return AliasName == "vstrhq_p_u16" || AliasName == "vstrhq_p";
case ARM::BI__builtin_arm_mve_vstrhq_p_u32:
return AliasName == "vstrhq_p_u32" || AliasName == "vstrhq_p";
case ARM::BI__builtin_arm_mve_vstrhq_s16:
return AliasName == "vstrhq_s16" || AliasName == "vstrhq";
case ARM::BI__builtin_arm_mve_vstrhq_s32:
return AliasName == "vstrhq_s32" || AliasName == "vstrhq";
case ARM::BI__builtin_arm_mve_vstrhq_scatter_offset_f16:
return AliasName == "vstrhq_scatter_offset_f16" || AliasName == "vstrhq_scatter_offset";
case ARM::BI__builtin_arm_mve_vstrhq_scatter_offset_p_f16:
return AliasName == "vstrhq_scatter_offset_p_f16" || AliasName == "vstrhq_scatter_offset_p";
case ARM::BI__builtin_arm_mve_vstrhq_scatter_offset_p_s16:
return AliasName == "vstrhq_scatter_offset_p_s16" || AliasName == "vstrhq_scatter_offset_p";
case ARM::BI__builtin_arm_mve_vstrhq_scatter_offset_p_s32:
return AliasName == "vstrhq_scatter_offset_p_s32" || AliasName == "vstrhq_scatter_offset_p";
case ARM::BI__builtin_arm_mve_vstrhq_scatter_offset_p_u16:
return AliasName == "vstrhq_scatter_offset_p_u16" || AliasName == "vstrhq_scatter_offset_p";
case ARM::BI__builtin_arm_mve_vstrhq_scatter_offset_p_u32:
return AliasName == "vstrhq_scatter_offset_p_u32" || AliasName == "vstrhq_scatter_offset_p";
case ARM::BI__builtin_arm_mve_vstrhq_scatter_offset_s16:
return AliasName == "vstrhq_scatter_offset_s16" || AliasName == "vstrhq_scatter_offset";
case ARM::BI__builtin_arm_mve_vstrhq_scatter_offset_s32:
return AliasName == "vstrhq_scatter_offset_s32" || AliasName == "vstrhq_scatter_offset";
case ARM::BI__builtin_arm_mve_vstrhq_scatter_offset_u16:
return AliasName == "vstrhq_scatter_offset_u16" || AliasName == "vstrhq_scatter_offset";
case ARM::BI__builtin_arm_mve_vstrhq_scatter_offset_u32:
return AliasName == "vstrhq_scatter_offset_u32" || AliasName == "vstrhq_scatter_offset";
case ARM::BI__builtin_arm_mve_vstrhq_scatter_shifted_offset_f16:
return AliasName == "vstrhq_scatter_shifted_offset_f16" || AliasName == "vstrhq_scatter_shifted_offset";
case ARM::BI__builtin_arm_mve_vstrhq_scatter_shifted_offset_p_f16:
return AliasName == "vstrhq_scatter_shifted_offset_p_f16" || AliasName == "vstrhq_scatter_shifted_offset_p";
case ARM::BI__builtin_arm_mve_vstrhq_scatter_shifted_offset_p_s16:
return AliasName == "vstrhq_scatter_shifted_offset_p_s16" || AliasName == "vstrhq_scatter_shifted_offset_p";
case ARM::BI__builtin_arm_mve_vstrhq_scatter_shifted_offset_p_s32:
return AliasName == "vstrhq_scatter_shifted_offset_p_s32" || AliasName == "vstrhq_scatter_shifted_offset_p";
case ARM::BI__builtin_arm_mve_vstrhq_scatter_shifted_offset_p_u16:
return AliasName == "vstrhq_scatter_shifted_offset_p_u16" || AliasName == "vstrhq_scatter_shifted_offset_p";
case ARM::BI__builtin_arm_mve_vstrhq_scatter_shifted_offset_p_u32:
return AliasName == "vstrhq_scatter_shifted_offset_p_u32" || AliasName == "vstrhq_scatter_shifted_offset_p";
case ARM::BI__builtin_arm_mve_vstrhq_scatter_shifted_offset_s16:
return AliasName == "vstrhq_scatter_shifted_offset_s16" || AliasName == "vstrhq_scatter_shifted_offset";
case ARM::BI__builtin_arm_mve_vstrhq_scatter_shifted_offset_s32:
return AliasName == "vstrhq_scatter_shifted_offset_s32" || AliasName == "vstrhq_scatter_shifted_offset";
case ARM::BI__builtin_arm_mve_vstrhq_scatter_shifted_offset_u16:
return AliasName == "vstrhq_scatter_shifted_offset_u16" || AliasName == "vstrhq_scatter_shifted_offset";
case ARM::BI__builtin_arm_mve_vstrhq_scatter_shifted_offset_u32:
return AliasName == "vstrhq_scatter_shifted_offset_u32" || AliasName == "vstrhq_scatter_shifted_offset";
case ARM::BI__builtin_arm_mve_vstrhq_u16:
return AliasName == "vstrhq_u16" || AliasName == "vstrhq";
case ARM::BI__builtin_arm_mve_vstrhq_u32:
return AliasName == "vstrhq_u32" || AliasName == "vstrhq";
case ARM::BI__builtin_arm_mve_vstrwq_f32:
return AliasName == "vstrwq_f32" || AliasName == "vstrwq";
case ARM::BI__builtin_arm_mve_vstrwq_p_f32:
return AliasName == "vstrwq_p_f32" || AliasName == "vstrwq_p";
case ARM::BI__builtin_arm_mve_vstrwq_p_s32:
return AliasName == "vstrwq_p_s32" || AliasName == "vstrwq_p";
case ARM::BI__builtin_arm_mve_vstrwq_p_u32:
return AliasName == "vstrwq_p_u32" || AliasName == "vstrwq_p";
case ARM::BI__builtin_arm_mve_vstrwq_s32:
return AliasName == "vstrwq_s32" || AliasName == "vstrwq";
case ARM::BI__builtin_arm_mve_vstrwq_scatter_base_f32:
return AliasName == "vstrwq_scatter_base_f32" || AliasName == "vstrwq_scatter_base";
case ARM::BI__builtin_arm_mve_vstrwq_scatter_base_p_f32:
return AliasName == "vstrwq_scatter_base_p_f32" || AliasName == "vstrwq_scatter_base_p";
case ARM::BI__builtin_arm_mve_vstrwq_scatter_base_p_s32:
return AliasName == "vstrwq_scatter_base_p_s32" || AliasName == "vstrwq_scatter_base_p";
case ARM::BI__builtin_arm_mve_vstrwq_scatter_base_p_u32:
return AliasName == "vstrwq_scatter_base_p_u32" || AliasName == "vstrwq_scatter_base_p";
case ARM::BI__builtin_arm_mve_vstrwq_scatter_base_s32:
return AliasName == "vstrwq_scatter_base_s32" || AliasName == "vstrwq_scatter_base";
case ARM::BI__builtin_arm_mve_vstrwq_scatter_base_u32:
return AliasName == "vstrwq_scatter_base_u32" || AliasName == "vstrwq_scatter_base";
case ARM::BI__builtin_arm_mve_vstrwq_scatter_base_wb_f32:
return AliasName == "vstrwq_scatter_base_wb_f32" || AliasName == "vstrwq_scatter_base_wb";
case ARM::BI__builtin_arm_mve_vstrwq_scatter_base_wb_p_f32:
return AliasName == "vstrwq_scatter_base_wb_p_f32" || AliasName == "vstrwq_scatter_base_wb_p";
case ARM::BI__builtin_arm_mve_vstrwq_scatter_base_wb_p_s32:
return AliasName == "vstrwq_scatter_base_wb_p_s32" || AliasName == "vstrwq_scatter_base_wb_p";
case ARM::BI__builtin_arm_mve_vstrwq_scatter_base_wb_p_u32:
return AliasName == "vstrwq_scatter_base_wb_p_u32" || AliasName == "vstrwq_scatter_base_wb_p";
case ARM::BI__builtin_arm_mve_vstrwq_scatter_base_wb_s32:
return AliasName == "vstrwq_scatter_base_wb_s32" || AliasName == "vstrwq_scatter_base_wb";
case ARM::BI__builtin_arm_mve_vstrwq_scatter_base_wb_u32:
return AliasName == "vstrwq_scatter_base_wb_u32" || AliasName == "vstrwq_scatter_base_wb";
case ARM::BI__builtin_arm_mve_vstrwq_scatter_offset_f32:
return AliasName == "vstrwq_scatter_offset_f32" || AliasName == "vstrwq_scatter_offset";
case ARM::BI__builtin_arm_mve_vstrwq_scatter_offset_p_f32:
return AliasName == "vstrwq_scatter_offset_p_f32" || AliasName == "vstrwq_scatter_offset_p";
case ARM::BI__builtin_arm_mve_vstrwq_scatter_offset_p_s32:
return AliasName == "vstrwq_scatter_offset_p_s32" || AliasName == "vstrwq_scatter_offset_p";
case ARM::BI__builtin_arm_mve_vstrwq_scatter_offset_p_u32:
return AliasName == "vstrwq_scatter_offset_p_u32" || AliasName == "vstrwq_scatter_offset_p";
case ARM::BI__builtin_arm_mve_vstrwq_scatter_offset_s32:
return AliasName == "vstrwq_scatter_offset_s32" || AliasName == "vstrwq_scatter_offset";
case ARM::BI__builtin_arm_mve_vstrwq_scatter_offset_u32:
return AliasName == "vstrwq_scatter_offset_u32" || AliasName == "vstrwq_scatter_offset";
case ARM::BI__builtin_arm_mve_vstrwq_scatter_shifted_offset_f32:
return AliasName == "vstrwq_scatter_shifted_offset_f32" || AliasName == "vstrwq_scatter_shifted_offset";
case ARM::BI__builtin_arm_mve_vstrwq_scatter_shifted_offset_p_f32:
return AliasName == "vstrwq_scatter_shifted_offset_p_f32" || AliasName == "vstrwq_scatter_shifted_offset_p";
case ARM::BI__builtin_arm_mve_vstrwq_scatter_shifted_offset_p_s32:
return AliasName == "vstrwq_scatter_shifted_offset_p_s32" || AliasName == "vstrwq_scatter_shifted_offset_p";
case ARM::BI__builtin_arm_mve_vstrwq_scatter_shifted_offset_p_u32:
return AliasName == "vstrwq_scatter_shifted_offset_p_u32" || AliasName == "vstrwq_scatter_shifted_offset_p";
case ARM::BI__builtin_arm_mve_vstrwq_scatter_shifted_offset_s32:
return AliasName == "vstrwq_scatter_shifted_offset_s32" || AliasName == "vstrwq_scatter_shifted_offset";
case ARM::BI__builtin_arm_mve_vstrwq_scatter_shifted_offset_u32:
return AliasName == "vstrwq_scatter_shifted_offset_u32" || AliasName == "vstrwq_scatter_shifted_offset";
case ARM::BI__builtin_arm_mve_vstrwq_u32:
return AliasName == "vstrwq_u32" || AliasName == "vstrwq";
case ARM::BI__builtin_arm_mve_vsubq_f16:
return AliasName == "vsubq_f16" || AliasName == "vsubq";
case ARM::BI__builtin_arm_mve_vsubq_f32:
return AliasName == "vsubq_f32" || AliasName == "vsubq";
case ARM::BI__builtin_arm_mve_vsubq_m_f16:
return AliasName == "vsubq_m_f16" || AliasName == "vsubq_m";
case ARM::BI__builtin_arm_mve_vsubq_m_f32:
return AliasName == "vsubq_m_f32" || AliasName == "vsubq_m";
case ARM::BI__builtin_arm_mve_vsubq_m_s16:
return AliasName == "vsubq_m_s16" || AliasName == "vsubq_m";
case ARM::BI__builtin_arm_mve_vsubq_m_s32:
return AliasName == "vsubq_m_s32" || AliasName == "vsubq_m";
case ARM::BI__builtin_arm_mve_vsubq_m_s8:
return AliasName == "vsubq_m_s8" || AliasName == "vsubq_m";
case ARM::BI__builtin_arm_mve_vsubq_m_u16:
return AliasName == "vsubq_m_u16" || AliasName == "vsubq_m";
case ARM::BI__builtin_arm_mve_vsubq_m_u32:
return AliasName == "vsubq_m_u32" || AliasName == "vsubq_m";
case ARM::BI__builtin_arm_mve_vsubq_m_u8:
return AliasName == "vsubq_m_u8" || AliasName == "vsubq_m";
case ARM::BI__builtin_arm_mve_vsubq_s16:
return AliasName == "vsubq_s16" || AliasName == "vsubq";
case ARM::BI__builtin_arm_mve_vsubq_s32:
return AliasName == "vsubq_s32" || AliasName == "vsubq";
case ARM::BI__builtin_arm_mve_vsubq_s8:
return AliasName == "vsubq_s8" || AliasName == "vsubq";
case ARM::BI__builtin_arm_mve_vsubq_u16:
return AliasName == "vsubq_u16" || AliasName == "vsubq";
case ARM::BI__builtin_arm_mve_vsubq_u32:
return AliasName == "vsubq_u32" || AliasName == "vsubq";
case ARM::BI__builtin_arm_mve_vsubq_u8:
return AliasName == "vsubq_u8" || AliasName == "vsubq";
case ARM::BI__builtin_arm_mve_vsubq_x_f16:
return AliasName == "vsubq_x_f16" || AliasName == "vsubq_x";
case ARM::BI__builtin_arm_mve_vsubq_x_f32:
return AliasName == "vsubq_x_f32" || AliasName == "vsubq_x";
case ARM::BI__builtin_arm_mve_vsubq_x_s16:
return AliasName == "vsubq_x_s16" || AliasName == "vsubq_x";
case ARM::BI__builtin_arm_mve_vsubq_x_s32:
return AliasName == "vsubq_x_s32" || AliasName == "vsubq_x";
case ARM::BI__builtin_arm_mve_vsubq_x_s8:
return AliasName == "vsubq_x_s8" || AliasName == "vsubq_x";
case ARM::BI__builtin_arm_mve_vsubq_x_u16:
return AliasName == "vsubq_x_u16" || AliasName == "vsubq_x";
case ARM::BI__builtin_arm_mve_vsubq_x_u32:
return AliasName == "vsubq_x_u32" || AliasName == "vsubq_x";
case ARM::BI__builtin_arm_mve_vsubq_x_u8:
return AliasName == "vsubq_x_u8" || AliasName == "vsubq_x";
case ARM::BI__builtin_arm_mve_vuninitializedq_f16:
return AliasName == "vuninitializedq_f16";
case ARM::BI__builtin_arm_mve_vuninitializedq_f32:
return AliasName == "vuninitializedq_f32";
case ARM::BI__builtin_arm_mve_vuninitializedq_polymorphic_f16:
return AliasName == "vuninitializedq_polymorphic_f16" || AliasName == "vuninitializedq";
case ARM::BI__builtin_arm_mve_vuninitializedq_polymorphic_f32:
return AliasName == "vuninitializedq_polymorphic_f32" || AliasName == "vuninitializedq";
case ARM::BI__builtin_arm_mve_vuninitializedq_polymorphic_s16:
return AliasName == "vuninitializedq_polymorphic_s16" || AliasName == "vuninitializedq";
case ARM::BI__builtin_arm_mve_vuninitializedq_polymorphic_s32:
return AliasName == "vuninitializedq_polymorphic_s32" || AliasName == "vuninitializedq";
case ARM::BI__builtin_arm_mve_vuninitializedq_polymorphic_s64:
return AliasName == "vuninitializedq_polymorphic_s64" || AliasName == "vuninitializedq";
case ARM::BI__builtin_arm_mve_vuninitializedq_polymorphic_s8:
return AliasName == "vuninitializedq_polymorphic_s8" || AliasName == "vuninitializedq";
case ARM::BI__builtin_arm_mve_vuninitializedq_polymorphic_u16:
return AliasName == "vuninitializedq_polymorphic_u16" || AliasName == "vuninitializedq";
case ARM::BI__builtin_arm_mve_vuninitializedq_polymorphic_u32:
return AliasName == "vuninitializedq_polymorphic_u32" || AliasName == "vuninitializedq";
case ARM::BI__builtin_arm_mve_vuninitializedq_polymorphic_u64:
return AliasName == "vuninitializedq_polymorphic_u64" || AliasName == "vuninitializedq";
case ARM::BI__builtin_arm_mve_vuninitializedq_polymorphic_u8:
return AliasName == "vuninitializedq_polymorphic_u8" || AliasName == "vuninitializedq";
case ARM::BI__builtin_arm_mve_vuninitializedq_s16:
return AliasName == "vuninitializedq_s16";
case ARM::BI__builtin_arm_mve_vuninitializedq_s32:
return AliasName == "vuninitializedq_s32";
case ARM::BI__builtin_arm_mve_vuninitializedq_s64:
return AliasName == "vuninitializedq_s64";
case ARM::BI__builtin_arm_mve_vuninitializedq_s8:
return AliasName == "vuninitializedq_s8";
case ARM::BI__builtin_arm_mve_vuninitializedq_u16:
return AliasName == "vuninitializedq_u16";
case ARM::BI__builtin_arm_mve_vuninitializedq_u32:
return AliasName == "vuninitializedq_u32";
case ARM::BI__builtin_arm_mve_vuninitializedq_u64:
return AliasName == "vuninitializedq_u64";
case ARM::BI__builtin_arm_mve_vuninitializedq_u8:
return AliasName == "vuninitializedq_u8";
| [
"herlambangdicky5@gmail.com"
] | herlambangdicky5@gmail.com |
8ec5a2d0d0e4be5bf8982d570d47e298d700a81f | 1c961bfb785fb4bbd84343f110d12c2d5ca98f14 | /common/parser/agenda.h | 4601a880196a301496f610dc280c795a242662a4 | [] | no_license | yangzhixuan/xParser | 85622cac937f9ac19672192d1f9250c6f318608f | b439b1e27f477f5c41cddf4df7e10a36b25d44b2 | refs/heads/master | 2021-01-22T16:45:08.994989 | 2015-10-27T06:02:17 | 2015-10-27T06:02:17 | 45,020,492 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,140 | h | #include <utility>
#include <iterator>
#include <functional>
#ifndef _AGENDA_H
#define _AGENDA_H
template<typename T>
class BeamIterator {
public:
typedef BeamIterator<T> self;
typedef T value_type;
typedef T *pointer;
typedef T &reference;
public:
T *node;
public:
BeamIterator() = default;
BeamIterator(T *x) : node(x) { }
BeamIterator(const self &b) : node(b.node) { }
bool operator==(const self &x) const { return node == x.node; }
bool operator!=(const self &x) const { return node != x.node; }
reference operator*() { return *node; }
pointer operator->() { return node; }
reference operator*() const { return *node; }
pointer operator->() const { return node; }
self &operator++() {
++node;
return *this;
}
self &operator++(int) {
self tmp = *this;
++*this;
return tmp;
}
self &operator--() {
--node;
return *this;
}
self &operator--(int) {
self tmp = *this;
++*this;
return tmp;
}
};
template<typename KEY_TYPE, int SIZE, typename COMPARE = std::greater<KEY_TYPE> >
class AgendaBeam {
public:
typedef BeamIterator<KEY_TYPE> iterator;
typedef BeamIterator<const KEY_TYPE> const_iterator;
private:
int m_nBeamSize;
bool m_bItemSorted;
KEY_TYPE m_lBeam[SIZE];
COMPARE comparer;
void pop_heap();
void push_heap(int base);
public:
AgendaBeam() : m_nBeamSize(0), m_bItemSorted(false) { }
~AgendaBeam() = default;
int size();
void clear();
void insertItem(const KEY_TYPE &item);
void sortItems();
const KEY_TYPE &bestItem(const int &index = 0);
iterator begin() { return &m_lBeam[0]; }
iterator end() { return &m_lBeam[m_nBeamSize]; }
const_iterator begin() const { return &m_lBeam[0]; }
const_iterator end() const { return &m_lBeam[m_nBeamSize]; }
const KEY_TYPE &operator[](int index) { return m_lBeam[index]; }
};
template<typename KEY_TYPE, int SIZE, typename COMPARE>
void AgendaBeam<KEY_TYPE, SIZE, COMPARE>::push_heap(int base) {
while (base > 0) {
int next_base = (base - 1) >> 1;
if (m_lBeam[next_base] > m_lBeam[base]) {
std::swap(m_lBeam[next_base], m_lBeam[base]);
base = next_base;
}
else {
break;
}
}
}
template<typename KEY_TYPE, int SIZE, typename COMPARE>
void AgendaBeam<KEY_TYPE, SIZE, COMPARE>::pop_heap() {
if (m_nBeamSize <= 0) {
return;
}
std::swap(m_lBeam[0], m_lBeam[--m_nBeamSize]);
KEY_TYPE smallest(m_lBeam[0]);
int index = 0, child = 1;
while (child < m_nBeamSize) {
if (child + 1 < m_nBeamSize && !(m_lBeam[child + 1] > m_lBeam[child])) {
++child;
}
m_lBeam[index] = m_lBeam[child];
index = child;
child = (child << 1) + 1;
}
m_lBeam[index] = smallest;
push_heap(index);
}
template<typename KEY_TYPE, int SIZE, typename COMPARE>
void AgendaBeam<KEY_TYPE, SIZE, COMPARE>::clear() {
m_nBeamSize = 0;
m_bItemSorted = false;
}
template<typename KEY_TYPE, int SIZE, typename COMPARE>
int AgendaBeam<KEY_TYPE, SIZE, COMPARE>::size() {
return m_nBeamSize;
}
template<typename KEY_TYPE, int SIZE, typename COMPARE>
void AgendaBeam<KEY_TYPE, SIZE, COMPARE>::insertItem(const KEY_TYPE &item) {
if (m_nBeamSize == SIZE) {
if (comparer(item, m_lBeam[0])) {
pop_heap();
}
else {
return;
}
}
m_lBeam[m_nBeamSize] = item;
push_heap(m_nBeamSize++);
}
template<typename KEY_TYPE, int SIZE, typename COMPARE>
void AgendaBeam<KEY_TYPE, SIZE, COMPARE>::sortItems() {
if (m_bItemSorted) {
return;
}
int size = m_nBeamSize;
while (m_nBeamSize > 0) {
pop_heap();
}
m_nBeamSize = size;
m_bItemSorted = true;
}
template<typename KEY_TYPE, int SIZE, typename COMPARE>
const KEY_TYPE &AgendaBeam<KEY_TYPE, SIZE, COMPARE>::bestItem(const int &index) {
if (!m_bItemSorted) {
sortItems();
}
return m_lBeam[index];
}
#endif | [
"javer821@gmail.com"
] | javer821@gmail.com |
fff6d9968a3ed99a2e713ae292d161c98da88c25 | 00e925fe9705dddd93c155667d71da861fb01772 | /src/util/time.h | 292f9f9ed7272a270eb240543de99364b743d0d4 | [
"MIT"
] | permissive | Crowndev/crown | f017445d4cbc6b5dda4e6a57fec16d07febfdf92 | 7d8f35e5f1749b0b93e16fda5c45c800ba15f882 | refs/heads/main | 2022-12-28T08:08:51.649518 | 2022-12-25T19:59:36 | 2022-12-25T19:59:36 | 415,886,236 | 7 | 3 | MIT | 2022-12-25T19:59:37 | 2021-10-11T10:57:29 | C++ | UTF-8 | C++ | false | false | 2,198 | h | // Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2020 The Crown Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#ifndef CROWN_UTIL_TIME_H
#define CROWN_UTIL_TIME_H
#include <stdint.h>
#include <string>
#include <chrono>
void UninterruptibleSleep(const std::chrono::microseconds& n);
/**
* Helper to count the seconds of a duration.
*
* All durations should be using std::chrono and calling this should generally
* be avoided in code. Though, it is still preferred to an inline t.count() to
* protect against a reliance on the exact type of t.
*
* This helper is used to convert durations before passing them over an
* interface that doesn't support std::chrono (e.g. RPC, debug log, or the GUI)
*/
inline int64_t count_seconds(std::chrono::seconds t) { return t.count(); }
inline int64_t count_microseconds(std::chrono::microseconds t) { return t.count(); }
/**
* DEPRECATED
* Use either GetSystemTimeInSeconds (not mockable) or GetTime<T> (mockable)
*/
int64_t GetTime();
/** Returns the system time (not mockable) */
int64_t GetTimeMillis();
/** Returns the system time (not mockable) */
int64_t GetTimeMicros();
/** Returns the system time (not mockable) */
int64_t GetSystemTimeInSeconds(); // Like GetTime(), but not mockable
/** For testing. Set e.g. with the setmocktime rpc, or -mocktime argument */
void SetMockTime(int64_t nMockTimeIn);
/** For testing */
int64_t GetMockTime();
/** Return system time (or mocked time, if set) */
template <typename T>
T GetTime();
/**
* ISO 8601 formatting is preferred. Use the FormatISO8601{DateTime,Date}
* helper functions if possible.
*/
std::string FormatISO8601DateTime(int64_t nTime);
std::string FormatISO8601Date(int64_t nTime);
int64_t ParseISO8601DateTime(const std::string& str);
std::string DateTimeStrFormat(const char* pszFormat, int64_t nTime);
std::string DurationToDHMS(int64_t nDurationTime);
namespace part
{
std::string GetTimeString(int64_t timestamp, char *buffer, size_t nBuffer);
int64_t strToEpoch(const char *input, bool fFillMax=false);
}
#endif // CROWN_UTIL_TIME_H
| [
"blockmecha@gmail.com"
] | blockmecha@gmail.com |
112528d7dfe97bc35c5b2762ca8565a19118e70d | 1a77b5eac40055032b72e27e720ac5d43451bbd6 | /フォーム対応/VisualC++/MFC/Chap2/Dr15_1/Dr15_1/MainFrm.cpp | ad4c92e48471d077ee19a4a667452c20bdd0d7b4 | [] | no_license | motonobu-t/algorithm | 8c8d360ebb982a0262069bb968022fe79f2c84c2 | ca7b29d53860eb06a357eb268f44f47ec9cb63f7 | refs/heads/master | 2021-01-22T21:38:34.195001 | 2017-05-15T12:00:51 | 2017-05-15T12:01:00 | 85,451,237 | 0 | 0 | null | null | null | null | SHIFT_JIS | C++ | false | false | 2,110 | cpp | // MainFrm.cpp : CMainFrame クラスの実装
//
#include "stdafx.h"
#include "Dr15_1.h"
#include "MainFrm.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#endif
// CMainFrame
IMPLEMENT_DYNCREATE(CMainFrame, CFrameWnd)
BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd)
ON_WM_CREATE()
END_MESSAGE_MAP()
static UINT indicators[] =
{
ID_SEPARATOR, // ステータス ライン インジケータ
ID_INDICATOR_CAPS,
ID_INDICATOR_NUM,
ID_INDICATOR_SCRL,
};
// CMainFrame コンストラクション/デストラクション
CMainFrame::CMainFrame()
{
// TODO: メンバ初期化コードをここに追加してください。
}
CMainFrame::~CMainFrame()
{
}
int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
if (CFrameWnd::OnCreate(lpCreateStruct) == -1)
return -1;
if (!m_wndToolBar.CreateEx(this, TBSTYLE_FLAT, WS_CHILD | WS_VISIBLE | CBRS_TOP
| CBRS_GRIPPER | CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC) ||
!m_wndToolBar.LoadToolBar(IDR_MAINFRAME))
{
TRACE0("ツール バーの作成に失敗しました。\n");
return -1; // 作成できませんでした。
}
if (!m_wndStatusBar.Create(this) ||
!m_wndStatusBar.SetIndicators(indicators,
sizeof(indicators)/sizeof(UINT)))
{
TRACE0("ステータス バーの作成に失敗しました。\n");
return -1; // 作成できませんでした。
}
// TODO: ツール バーをドッキング可能にしない場合は、これらの 3 行を削除してください。
m_wndToolBar.EnableDocking(CBRS_ALIGN_ANY);
EnableDocking(CBRS_ALIGN_ANY);
DockControlBar(&m_wndToolBar);
return 0;
}
BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
{
if( !CFrameWnd::PreCreateWindow(cs) )
return FALSE;
// TODO: この位置で CREATESTRUCT cs を修正して Window クラスまたはスタイルを
// 修正してください。
return TRUE;
}
// CMainFrame 診断
#ifdef _DEBUG
void CMainFrame::AssertValid() const
{
CFrameWnd::AssertValid();
}
void CMainFrame::Dump(CDumpContext& dc) const
{
CFrameWnd::Dump(dc);
}
#endif //_DEBUG
// CMainFrame メッセージ ハンドラ
| [
"rx_78_bd@yahoo.co.jp"
] | rx_78_bd@yahoo.co.jp |
7a1cff07a879abd334914ec7bdd4cb1bae1eb17d | 174522e7e2f3e38d0a3b8f1fa65f68e367f42290 | /InteractionBase/src/expression_editor/tree_builder/ExpressionTreeBuildInstruction.h | 0439ea6eceebbb8e4c61a2f9ce2ceacff521978b | [
"BSD-3-Clause"
] | permissive | helandre/Envision | e8c97a34a66d0fbbe55c61ec6a68150079c32460 | 904e69146e38c0ee52d2cfee4ab01a93970d86c8 | refs/heads/master | 2021-01-21T01:12:16.809436 | 2012-09-12T15:29:18 | 2012-09-12T15:29:18 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,419 | h | /***********************************************************************************************************************
**
** Copyright (c) 2011, 2012 ETH Zurich
** All rights reserved.
**
** Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
** following conditions are met:
**
** * Redistributions of source code must retain the above copyright notice, this list of conditions and the
** following disclaimer.
** * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
** following disclaimer in the documentation and/or other materials provided with the distribution.
** * Neither the name of the ETH Zurich nor the names of its contributors may be used to endorse or promote products
** derived from this software without specific prior written permission.
**
**
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
** INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
** DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
** SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
** WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
**
**********************************************************************************************************************/
/*
* ExpressionTreeBuildInstruction.h
*
* Created on: Jan 11, 2012
* Author: Dimitar Asenov
*/
#ifndef INTERACTIONBASE_EXPRESSIONTREEBUILDINSTRUCTION_H_
#define INTERACTIONBASE_EXPRESSIONTREEBUILDINSTRUCTION_H_
#include "../../interactionbase_api.h"
namespace Interaction {
class ExpressionTreeBuilder;
class INTERACTIONBASE_API ExpressionTreeBuildInstruction {
public:
virtual ~ExpressionTreeBuildInstruction();
virtual void perform(ExpressionTreeBuilder& tb) = 0;
};
} /* namespace InteractionBase */
#endif /* INTERACTIONBASE_EXPRESSIONTREEBUILDINSTRUCTION_H_ */
| [
"dimitar.asenov@inf.ethz.ch"
] | dimitar.asenov@inf.ethz.ch |
b0817a6df46137f64a1661fc3cb5725c5618815b | 332515cb827e57f3359cfe0562c5b91d711752df | /Application_UWP_WinRT/Generated Files/winrt/impl/Windows.Devices.Printers.Extensions.0.h | b64b8875636dc9d89a257e7a2720c16ce1e76475 | [
"MIT"
] | permissive | GCourtney27/DX12-Simple-Xbox-Win32-Application | 7c1f09abbfb768a1d5c2ab0d7ee9621f66ad85d5 | 4f0bc4a52aa67c90376f05146f2ebea92db1ec57 | refs/heads/master | 2023-02-19T06:54:18.923600 | 2021-01-24T08:18:19 | 2021-01-24T08:18:19 | 312,744,674 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 24,708 | h | // WARNING: Please don't edit this file. It was generated by C++/WinRT v2.0.201113.7
#ifndef WINRT_Windows_Devices_Printers_Extensions_0_H
#define WINRT_Windows_Devices_Printers_Extensions_0_H
WINRT_EXPORT namespace winrt::Windows::Foundation
{
struct EventRegistrationToken;
template <typename TSender, typename TResult> struct __declspec(empty_bases) TypedEventHandler;
}
WINRT_EXPORT namespace winrt::Windows::Devices::Printers::Extensions
{
enum class Print3DWorkflowDetail : int32_t
{
Unknown = 0,
ModelExceedsPrintBed = 1,
UploadFailed = 2,
InvalidMaterialSelection = 3,
InvalidModel = 4,
ModelNotManifold = 5,
InvalidPrintTicket = 6,
};
enum class Print3DWorkflowStatus : int32_t
{
Abandoned = 0,
Canceled = 1,
Failed = 2,
Slicing = 3,
Submitted = 4,
};
struct IPrint3DWorkflow;
struct IPrint3DWorkflow2;
struct IPrint3DWorkflowPrintRequestedEventArgs;
struct IPrint3DWorkflowPrinterChangedEventArgs;
struct IPrintExtensionContextStatic;
struct IPrintNotificationEventDetails;
struct IPrintTaskConfiguration;
struct IPrintTaskConfigurationSaveRequest;
struct IPrintTaskConfigurationSaveRequestedDeferral;
struct IPrintTaskConfigurationSaveRequestedEventArgs;
struct Print3DWorkflow;
struct Print3DWorkflowPrintRequestedEventArgs;
struct Print3DWorkflowPrinterChangedEventArgs;
struct PrintExtensionContext;
struct PrintNotificationEventDetails;
struct PrintTaskConfiguration;
struct PrintTaskConfigurationSaveRequest;
struct PrintTaskConfigurationSaveRequestedDeferral;
struct PrintTaskConfigurationSaveRequestedEventArgs;
}
namespace winrt::impl
{
template <> struct category<Windows::Devices::Printers::Extensions::IPrint3DWorkflow>{ using type = interface_category; };
template <> struct category<Windows::Devices::Printers::Extensions::IPrint3DWorkflow2>{ using type = interface_category; };
template <> struct category<Windows::Devices::Printers::Extensions::IPrint3DWorkflowPrintRequestedEventArgs>{ using type = interface_category; };
template <> struct category<Windows::Devices::Printers::Extensions::IPrint3DWorkflowPrinterChangedEventArgs>{ using type = interface_category; };
template <> struct category<Windows::Devices::Printers::Extensions::IPrintExtensionContextStatic>{ using type = interface_category; };
template <> struct category<Windows::Devices::Printers::Extensions::IPrintNotificationEventDetails>{ using type = interface_category; };
template <> struct category<Windows::Devices::Printers::Extensions::IPrintTaskConfiguration>{ using type = interface_category; };
template <> struct category<Windows::Devices::Printers::Extensions::IPrintTaskConfigurationSaveRequest>{ using type = interface_category; };
template <> struct category<Windows::Devices::Printers::Extensions::IPrintTaskConfigurationSaveRequestedDeferral>{ using type = interface_category; };
template <> struct category<Windows::Devices::Printers::Extensions::IPrintTaskConfigurationSaveRequestedEventArgs>{ using type = interface_category; };
template <> struct category<Windows::Devices::Printers::Extensions::Print3DWorkflow>{ using type = class_category; };
template <> struct category<Windows::Devices::Printers::Extensions::Print3DWorkflowPrintRequestedEventArgs>{ using type = class_category; };
template <> struct category<Windows::Devices::Printers::Extensions::Print3DWorkflowPrinterChangedEventArgs>{ using type = class_category; };
template <> struct category<Windows::Devices::Printers::Extensions::PrintExtensionContext>{ using type = class_category; };
template <> struct category<Windows::Devices::Printers::Extensions::PrintNotificationEventDetails>{ using type = class_category; };
template <> struct category<Windows::Devices::Printers::Extensions::PrintTaskConfiguration>{ using type = class_category; };
template <> struct category<Windows::Devices::Printers::Extensions::PrintTaskConfigurationSaveRequest>{ using type = class_category; };
template <> struct category<Windows::Devices::Printers::Extensions::PrintTaskConfigurationSaveRequestedDeferral>{ using type = class_category; };
template <> struct category<Windows::Devices::Printers::Extensions::PrintTaskConfigurationSaveRequestedEventArgs>{ using type = class_category; };
template <> struct category<Windows::Devices::Printers::Extensions::Print3DWorkflowDetail>{ using type = enum_category; };
template <> struct category<Windows::Devices::Printers::Extensions::Print3DWorkflowStatus>{ using type = enum_category; };
template <> inline constexpr auto& name_v<Windows::Devices::Printers::Extensions::Print3DWorkflow> = L"Windows.Devices.Printers.Extensions.Print3DWorkflow";
template <> inline constexpr auto& name_v<Windows::Devices::Printers::Extensions::Print3DWorkflowPrintRequestedEventArgs> = L"Windows.Devices.Printers.Extensions.Print3DWorkflowPrintRequestedEventArgs";
template <> inline constexpr auto& name_v<Windows::Devices::Printers::Extensions::Print3DWorkflowPrinterChangedEventArgs> = L"Windows.Devices.Printers.Extensions.Print3DWorkflowPrinterChangedEventArgs";
template <> inline constexpr auto& name_v<Windows::Devices::Printers::Extensions::PrintExtensionContext> = L"Windows.Devices.Printers.Extensions.PrintExtensionContext";
template <> inline constexpr auto& name_v<Windows::Devices::Printers::Extensions::PrintNotificationEventDetails> = L"Windows.Devices.Printers.Extensions.PrintNotificationEventDetails";
template <> inline constexpr auto& name_v<Windows::Devices::Printers::Extensions::PrintTaskConfiguration> = L"Windows.Devices.Printers.Extensions.PrintTaskConfiguration";
template <> inline constexpr auto& name_v<Windows::Devices::Printers::Extensions::PrintTaskConfigurationSaveRequest> = L"Windows.Devices.Printers.Extensions.PrintTaskConfigurationSaveRequest";
template <> inline constexpr auto& name_v<Windows::Devices::Printers::Extensions::PrintTaskConfigurationSaveRequestedDeferral> = L"Windows.Devices.Printers.Extensions.PrintTaskConfigurationSaveRequestedDeferral";
template <> inline constexpr auto& name_v<Windows::Devices::Printers::Extensions::PrintTaskConfigurationSaveRequestedEventArgs> = L"Windows.Devices.Printers.Extensions.PrintTaskConfigurationSaveRequestedEventArgs";
template <> inline constexpr auto& name_v<Windows::Devices::Printers::Extensions::Print3DWorkflowDetail> = L"Windows.Devices.Printers.Extensions.Print3DWorkflowDetail";
template <> inline constexpr auto& name_v<Windows::Devices::Printers::Extensions::Print3DWorkflowStatus> = L"Windows.Devices.Printers.Extensions.Print3DWorkflowStatus";
template <> inline constexpr auto& name_v<Windows::Devices::Printers::Extensions::IPrint3DWorkflow> = L"Windows.Devices.Printers.Extensions.IPrint3DWorkflow";
template <> inline constexpr auto& name_v<Windows::Devices::Printers::Extensions::IPrint3DWorkflow2> = L"Windows.Devices.Printers.Extensions.IPrint3DWorkflow2";
template <> inline constexpr auto& name_v<Windows::Devices::Printers::Extensions::IPrint3DWorkflowPrintRequestedEventArgs> = L"Windows.Devices.Printers.Extensions.IPrint3DWorkflowPrintRequestedEventArgs";
template <> inline constexpr auto& name_v<Windows::Devices::Printers::Extensions::IPrint3DWorkflowPrinterChangedEventArgs> = L"Windows.Devices.Printers.Extensions.IPrint3DWorkflowPrinterChangedEventArgs";
template <> inline constexpr auto& name_v<Windows::Devices::Printers::Extensions::IPrintExtensionContextStatic> = L"Windows.Devices.Printers.Extensions.IPrintExtensionContextStatic";
template <> inline constexpr auto& name_v<Windows::Devices::Printers::Extensions::IPrintNotificationEventDetails> = L"Windows.Devices.Printers.Extensions.IPrintNotificationEventDetails";
template <> inline constexpr auto& name_v<Windows::Devices::Printers::Extensions::IPrintTaskConfiguration> = L"Windows.Devices.Printers.Extensions.IPrintTaskConfiguration";
template <> inline constexpr auto& name_v<Windows::Devices::Printers::Extensions::IPrintTaskConfigurationSaveRequest> = L"Windows.Devices.Printers.Extensions.IPrintTaskConfigurationSaveRequest";
template <> inline constexpr auto& name_v<Windows::Devices::Printers::Extensions::IPrintTaskConfigurationSaveRequestedDeferral> = L"Windows.Devices.Printers.Extensions.IPrintTaskConfigurationSaveRequestedDeferral";
template <> inline constexpr auto& name_v<Windows::Devices::Printers::Extensions::IPrintTaskConfigurationSaveRequestedEventArgs> = L"Windows.Devices.Printers.Extensions.IPrintTaskConfigurationSaveRequestedEventArgs";
template <> inline constexpr guid guid_v<Windows::Devices::Printers::Extensions::IPrint3DWorkflow>{ 0xC56F74BD,0x3669,0x4A66,{ 0xAB,0x42,0xC8,0x15,0x19,0x30,0xCD,0x34 } }; // C56F74BD-3669-4A66-AB42-C8151930CD34
template <> inline constexpr guid guid_v<Windows::Devices::Printers::Extensions::IPrint3DWorkflow2>{ 0xA2A6C54F,0x8AC1,0x4918,{ 0x97,0x41,0xE3,0x4F,0x30,0x04,0x23,0x9E } }; // A2A6C54F-8AC1-4918-9741-E34F3004239E
template <> inline constexpr guid guid_v<Windows::Devices::Printers::Extensions::IPrint3DWorkflowPrintRequestedEventArgs>{ 0x19F8C858,0x5AC8,0x4B55,{ 0x8A,0x5F,0xE6,0x15,0x67,0xDA,0xFB,0x4D } }; // 19F8C858-5AC8-4B55-8A5F-E61567DAFB4D
template <> inline constexpr guid guid_v<Windows::Devices::Printers::Extensions::IPrint3DWorkflowPrinterChangedEventArgs>{ 0x45226402,0x95FC,0x4847,{ 0x93,0xB3,0x13,0x4D,0xBF,0x5C,0x60,0xF7 } }; // 45226402-95FC-4847-93B3-134DBF5C60F7
template <> inline constexpr guid guid_v<Windows::Devices::Printers::Extensions::IPrintExtensionContextStatic>{ 0xE70D9FC1,0xFF79,0x4AA4,{ 0x8C,0x9B,0x0C,0x93,0xAE,0xDF,0xDE,0x8A } }; // E70D9FC1-FF79-4AA4-8C9B-0C93AEDFDE8A
template <> inline constexpr guid guid_v<Windows::Devices::Printers::Extensions::IPrintNotificationEventDetails>{ 0xE00E4C8A,0x4828,0x4DA1,{ 0x8B,0xB8,0x86,0x72,0xDF,0x85,0x15,0xE7 } }; // E00E4C8A-4828-4DA1-8BB8-8672DF8515E7
template <> inline constexpr guid guid_v<Windows::Devices::Printers::Extensions::IPrintTaskConfiguration>{ 0xE3C22451,0x3AA4,0x4885,{ 0x92,0x40,0x31,0x1F,0x5F,0x8F,0xBE,0x9D } }; // E3C22451-3AA4-4885-9240-311F5F8FBE9D
template <> inline constexpr guid guid_v<Windows::Devices::Printers::Extensions::IPrintTaskConfigurationSaveRequest>{ 0xEEAF2FCB,0x621E,0x4B62,{ 0xAC,0x77,0xB2,0x81,0xCC,0xE0,0x8D,0x60 } }; // EEAF2FCB-621E-4B62-AC77-B281CCE08D60
template <> inline constexpr guid guid_v<Windows::Devices::Printers::Extensions::IPrintTaskConfigurationSaveRequestedDeferral>{ 0xE959D568,0xF729,0x44A4,{ 0x87,0x1D,0xBD,0x06,0x28,0x69,0x6A,0x33 } }; // E959D568-F729-44A4-871D-BD0628696A33
template <> inline constexpr guid guid_v<Windows::Devices::Printers::Extensions::IPrintTaskConfigurationSaveRequestedEventArgs>{ 0xE06C2879,0x0D61,0x4938,{ 0x91,0xD0,0x96,0xA4,0x5B,0xEE,0x84,0x79 } }; // E06C2879-0D61-4938-91D0-96A45BEE8479
template <> struct default_interface<Windows::Devices::Printers::Extensions::Print3DWorkflow>{ using type = Windows::Devices::Printers::Extensions::IPrint3DWorkflow; };
template <> struct default_interface<Windows::Devices::Printers::Extensions::Print3DWorkflowPrintRequestedEventArgs>{ using type = Windows::Devices::Printers::Extensions::IPrint3DWorkflowPrintRequestedEventArgs; };
template <> struct default_interface<Windows::Devices::Printers::Extensions::Print3DWorkflowPrinterChangedEventArgs>{ using type = Windows::Devices::Printers::Extensions::IPrint3DWorkflowPrinterChangedEventArgs; };
template <> struct default_interface<Windows::Devices::Printers::Extensions::PrintNotificationEventDetails>{ using type = Windows::Devices::Printers::Extensions::IPrintNotificationEventDetails; };
template <> struct default_interface<Windows::Devices::Printers::Extensions::PrintTaskConfiguration>{ using type = Windows::Devices::Printers::Extensions::IPrintTaskConfiguration; };
template <> struct default_interface<Windows::Devices::Printers::Extensions::PrintTaskConfigurationSaveRequest>{ using type = Windows::Devices::Printers::Extensions::IPrintTaskConfigurationSaveRequest; };
template <> struct default_interface<Windows::Devices::Printers::Extensions::PrintTaskConfigurationSaveRequestedDeferral>{ using type = Windows::Devices::Printers::Extensions::IPrintTaskConfigurationSaveRequestedDeferral; };
template <> struct default_interface<Windows::Devices::Printers::Extensions::PrintTaskConfigurationSaveRequestedEventArgs>{ using type = Windows::Devices::Printers::Extensions::IPrintTaskConfigurationSaveRequestedEventArgs; };
template <> struct abi<Windows::Devices::Printers::Extensions::IPrint3DWorkflow>
{
struct __declspec(novtable) type : inspectable_abi
{
virtual int32_t __stdcall get_DeviceID(void**) noexcept = 0;
virtual int32_t __stdcall GetPrintModelPackage(void**) noexcept = 0;
virtual int32_t __stdcall get_IsPrintReady(bool*) noexcept = 0;
virtual int32_t __stdcall put_IsPrintReady(bool) noexcept = 0;
virtual int32_t __stdcall add_PrintRequested(void*, winrt::event_token*) noexcept = 0;
virtual int32_t __stdcall remove_PrintRequested(winrt::event_token) noexcept = 0;
};
};
template <> struct abi<Windows::Devices::Printers::Extensions::IPrint3DWorkflow2>
{
struct __declspec(novtable) type : inspectable_abi
{
virtual int32_t __stdcall add_PrinterChanged(void*, winrt::event_token*) noexcept = 0;
virtual int32_t __stdcall remove_PrinterChanged(winrt::event_token) noexcept = 0;
};
};
template <> struct abi<Windows::Devices::Printers::Extensions::IPrint3DWorkflowPrintRequestedEventArgs>
{
struct __declspec(novtable) type : inspectable_abi
{
virtual int32_t __stdcall get_Status(int32_t*) noexcept = 0;
virtual int32_t __stdcall SetExtendedStatus(int32_t) noexcept = 0;
virtual int32_t __stdcall SetSource(void*) noexcept = 0;
virtual int32_t __stdcall SetSourceChanged(bool) noexcept = 0;
};
};
template <> struct abi<Windows::Devices::Printers::Extensions::IPrint3DWorkflowPrinterChangedEventArgs>
{
struct __declspec(novtable) type : inspectable_abi
{
virtual int32_t __stdcall get_NewDeviceId(void**) noexcept = 0;
};
};
template <> struct abi<Windows::Devices::Printers::Extensions::IPrintExtensionContextStatic>
{
struct __declspec(novtable) type : inspectable_abi
{
virtual int32_t __stdcall FromDeviceId(void*, void**) noexcept = 0;
};
};
template <> struct abi<Windows::Devices::Printers::Extensions::IPrintNotificationEventDetails>
{
struct __declspec(novtable) type : inspectable_abi
{
virtual int32_t __stdcall get_PrinterName(void**) noexcept = 0;
virtual int32_t __stdcall get_EventData(void**) noexcept = 0;
virtual int32_t __stdcall put_EventData(void*) noexcept = 0;
};
};
template <> struct abi<Windows::Devices::Printers::Extensions::IPrintTaskConfiguration>
{
struct __declspec(novtable) type : inspectable_abi
{
virtual int32_t __stdcall get_PrinterExtensionContext(void**) noexcept = 0;
virtual int32_t __stdcall add_SaveRequested(void*, winrt::event_token*) noexcept = 0;
virtual int32_t __stdcall remove_SaveRequested(winrt::event_token) noexcept = 0;
};
};
template <> struct abi<Windows::Devices::Printers::Extensions::IPrintTaskConfigurationSaveRequest>
{
struct __declspec(novtable) type : inspectable_abi
{
virtual int32_t __stdcall Cancel() noexcept = 0;
virtual int32_t __stdcall Save(void*) noexcept = 0;
virtual int32_t __stdcall GetDeferral(void**) noexcept = 0;
virtual int32_t __stdcall get_Deadline(int64_t*) noexcept = 0;
};
};
template <> struct abi<Windows::Devices::Printers::Extensions::IPrintTaskConfigurationSaveRequestedDeferral>
{
struct __declspec(novtable) type : inspectable_abi
{
virtual int32_t __stdcall Complete() noexcept = 0;
};
};
template <> struct abi<Windows::Devices::Printers::Extensions::IPrintTaskConfigurationSaveRequestedEventArgs>
{
struct __declspec(novtable) type : inspectable_abi
{
virtual int32_t __stdcall get_Request(void**) noexcept = 0;
};
};
template <typename D>
struct consume_Windows_Devices_Printers_Extensions_IPrint3DWorkflow
{
[[nodiscard]] WINRT_IMPL_AUTO(hstring) DeviceID() const;
WINRT_IMPL_AUTO(Windows::Foundation::IInspectable) GetPrintModelPackage() const;
[[nodiscard]] WINRT_IMPL_AUTO(bool) IsPrintReady() const;
WINRT_IMPL_AUTO(void) IsPrintReady(bool value) const;
WINRT_IMPL_AUTO(winrt::event_token) PrintRequested(Windows::Foundation::TypedEventHandler<Windows::Devices::Printers::Extensions::Print3DWorkflow, Windows::Devices::Printers::Extensions::Print3DWorkflowPrintRequestedEventArgs> const& eventHandler) const;
using PrintRequested_revoker = impl::event_revoker<Windows::Devices::Printers::Extensions::IPrint3DWorkflow, &impl::abi_t<Windows::Devices::Printers::Extensions::IPrint3DWorkflow>::remove_PrintRequested>;
[[nodiscard]] PrintRequested_revoker PrintRequested(auto_revoke_t, Windows::Foundation::TypedEventHandler<Windows::Devices::Printers::Extensions::Print3DWorkflow, Windows::Devices::Printers::Extensions::Print3DWorkflowPrintRequestedEventArgs> const& eventHandler) const;
WINRT_IMPL_AUTO(void) PrintRequested(winrt::event_token const& eventCookie) const noexcept;
};
template <> struct consume<Windows::Devices::Printers::Extensions::IPrint3DWorkflow>
{
template <typename D> using type = consume_Windows_Devices_Printers_Extensions_IPrint3DWorkflow<D>;
};
template <typename D>
struct consume_Windows_Devices_Printers_Extensions_IPrint3DWorkflow2
{
WINRT_IMPL_AUTO(winrt::event_token) PrinterChanged(Windows::Foundation::TypedEventHandler<Windows::Devices::Printers::Extensions::Print3DWorkflow, Windows::Devices::Printers::Extensions::Print3DWorkflowPrinterChangedEventArgs> const& eventHandler) const;
using PrinterChanged_revoker = impl::event_revoker<Windows::Devices::Printers::Extensions::IPrint3DWorkflow2, &impl::abi_t<Windows::Devices::Printers::Extensions::IPrint3DWorkflow2>::remove_PrinterChanged>;
[[nodiscard]] PrinterChanged_revoker PrinterChanged(auto_revoke_t, Windows::Foundation::TypedEventHandler<Windows::Devices::Printers::Extensions::Print3DWorkflow, Windows::Devices::Printers::Extensions::Print3DWorkflowPrinterChangedEventArgs> const& eventHandler) const;
WINRT_IMPL_AUTO(void) PrinterChanged(winrt::event_token const& eventCookie) const noexcept;
};
template <> struct consume<Windows::Devices::Printers::Extensions::IPrint3DWorkflow2>
{
template <typename D> using type = consume_Windows_Devices_Printers_Extensions_IPrint3DWorkflow2<D>;
};
template <typename D>
struct consume_Windows_Devices_Printers_Extensions_IPrint3DWorkflowPrintRequestedEventArgs
{
[[nodiscard]] WINRT_IMPL_AUTO(Windows::Devices::Printers::Extensions::Print3DWorkflowStatus) Status() const;
WINRT_IMPL_AUTO(void) SetExtendedStatus(Windows::Devices::Printers::Extensions::Print3DWorkflowDetail const& value) const;
WINRT_IMPL_AUTO(void) SetSource(Windows::Foundation::IInspectable const& source) const;
WINRT_IMPL_AUTO(void) SetSourceChanged(bool value) const;
};
template <> struct consume<Windows::Devices::Printers::Extensions::IPrint3DWorkflowPrintRequestedEventArgs>
{
template <typename D> using type = consume_Windows_Devices_Printers_Extensions_IPrint3DWorkflowPrintRequestedEventArgs<D>;
};
template <typename D>
struct consume_Windows_Devices_Printers_Extensions_IPrint3DWorkflowPrinterChangedEventArgs
{
[[nodiscard]] WINRT_IMPL_AUTO(hstring) NewDeviceId() const;
};
template <> struct consume<Windows::Devices::Printers::Extensions::IPrint3DWorkflowPrinterChangedEventArgs>
{
template <typename D> using type = consume_Windows_Devices_Printers_Extensions_IPrint3DWorkflowPrinterChangedEventArgs<D>;
};
template <typename D>
struct consume_Windows_Devices_Printers_Extensions_IPrintExtensionContextStatic
{
WINRT_IMPL_AUTO(Windows::Foundation::IInspectable) FromDeviceId(param::hstring const& deviceId) const;
};
template <> struct consume<Windows::Devices::Printers::Extensions::IPrintExtensionContextStatic>
{
template <typename D> using type = consume_Windows_Devices_Printers_Extensions_IPrintExtensionContextStatic<D>;
};
template <typename D>
struct consume_Windows_Devices_Printers_Extensions_IPrintNotificationEventDetails
{
[[nodiscard]] WINRT_IMPL_AUTO(hstring) PrinterName() const;
[[nodiscard]] WINRT_IMPL_AUTO(hstring) EventData() const;
WINRT_IMPL_AUTO(void) EventData(param::hstring const& value) const;
};
template <> struct consume<Windows::Devices::Printers::Extensions::IPrintNotificationEventDetails>
{
template <typename D> using type = consume_Windows_Devices_Printers_Extensions_IPrintNotificationEventDetails<D>;
};
template <typename D>
struct consume_Windows_Devices_Printers_Extensions_IPrintTaskConfiguration
{
[[nodiscard]] WINRT_IMPL_AUTO(Windows::Foundation::IInspectable) PrinterExtensionContext() const;
WINRT_IMPL_AUTO(winrt::event_token) SaveRequested(Windows::Foundation::TypedEventHandler<Windows::Devices::Printers::Extensions::PrintTaskConfiguration, Windows::Devices::Printers::Extensions::PrintTaskConfigurationSaveRequestedEventArgs> const& eventHandler) const;
using SaveRequested_revoker = impl::event_revoker<Windows::Devices::Printers::Extensions::IPrintTaskConfiguration, &impl::abi_t<Windows::Devices::Printers::Extensions::IPrintTaskConfiguration>::remove_SaveRequested>;
[[nodiscard]] SaveRequested_revoker SaveRequested(auto_revoke_t, Windows::Foundation::TypedEventHandler<Windows::Devices::Printers::Extensions::PrintTaskConfiguration, Windows::Devices::Printers::Extensions::PrintTaskConfigurationSaveRequestedEventArgs> const& eventHandler) const;
WINRT_IMPL_AUTO(void) SaveRequested(winrt::event_token const& eventCookie) const noexcept;
};
template <> struct consume<Windows::Devices::Printers::Extensions::IPrintTaskConfiguration>
{
template <typename D> using type = consume_Windows_Devices_Printers_Extensions_IPrintTaskConfiguration<D>;
};
template <typename D>
struct consume_Windows_Devices_Printers_Extensions_IPrintTaskConfigurationSaveRequest
{
WINRT_IMPL_AUTO(void) Cancel() const;
WINRT_IMPL_AUTO(void) Save(Windows::Foundation::IInspectable const& printerExtensionContext) const;
WINRT_IMPL_AUTO(Windows::Devices::Printers::Extensions::PrintTaskConfigurationSaveRequestedDeferral) GetDeferral() const;
[[nodiscard]] WINRT_IMPL_AUTO(Windows::Foundation::DateTime) Deadline() const;
};
template <> struct consume<Windows::Devices::Printers::Extensions::IPrintTaskConfigurationSaveRequest>
{
template <typename D> using type = consume_Windows_Devices_Printers_Extensions_IPrintTaskConfigurationSaveRequest<D>;
};
template <typename D>
struct consume_Windows_Devices_Printers_Extensions_IPrintTaskConfigurationSaveRequestedDeferral
{
WINRT_IMPL_AUTO(void) Complete() const;
};
template <> struct consume<Windows::Devices::Printers::Extensions::IPrintTaskConfigurationSaveRequestedDeferral>
{
template <typename D> using type = consume_Windows_Devices_Printers_Extensions_IPrintTaskConfigurationSaveRequestedDeferral<D>;
};
template <typename D>
struct consume_Windows_Devices_Printers_Extensions_IPrintTaskConfigurationSaveRequestedEventArgs
{
[[nodiscard]] WINRT_IMPL_AUTO(Windows::Devices::Printers::Extensions::PrintTaskConfigurationSaveRequest) Request() const;
};
template <> struct consume<Windows::Devices::Printers::Extensions::IPrintTaskConfigurationSaveRequestedEventArgs>
{
template <typename D> using type = consume_Windows_Devices_Printers_Extensions_IPrintTaskConfigurationSaveRequestedEventArgs<D>;
};
}
#endif
| [
"garrett1168@outlook.com"
] | garrett1168@outlook.com |
f2e3ddb197c589bb0b8bb55b3bf0ca2c565f4d14 | 8903cb76cedac12995249e2e613af65365be7cf2 | /ares/sfc/coprocessor/hitachidsp/hitachidsp.cpp | 1ec99441125ed8230eed89c1815cfe4c47f9ce9f | [
"ISC"
] | permissive | kirwinia/ares-emu-v121 | 0c1e21e073f291741406cd1ed01acca43acd56d7 | 722aa227caf943a4a64f1678c1bdd07b38b15caa | refs/heads/main | 2023-06-09T15:28:23.665934 | 2021-06-28T06:10:46 | 2021-06-28T06:10:46 | 380,923,321 | 0 | 0 | ISC | 2021-06-28T06:05:04 | 2021-06-28T06:05:04 | null | UTF-8 | C++ | false | false | 736 | cpp | HitachiDSP hitachidsp;
#include "memory.cpp"
#include "debugger.cpp"
#include "serialization.cpp"
auto HitachiDSP::load(Node::Object parent) -> void {
node = parent->append<Node::Object>("Hitachi");
debugger.load(node);
}
auto HitachiDSP::unload() -> void {
node = {};
debugger = {};
rom.reset();
ram.reset();
cpu.coprocessors.removeByValue(this);
Thread::destroy();
}
auto HitachiDSP::step(u32 clocks) -> void {
HG51B::step(clocks);
Thread::step(clocks);
Thread::synchronize(cpu);
}
auto HitachiDSP::halt() -> void {
HG51B::halt();
if(io.irq == 0) cpu.irq(r.i = 1);
}
auto HitachiDSP::power() -> void {
HG51B::power();
Thread::create(Frequency, [&] { main(); });
cpu.coprocessors.append(this);
}
| [
"ecallaghan@protonmail.com"
] | ecallaghan@protonmail.com |
407605ff8c7a206138caf552f29b0089da19642f | 772d932a0e5f6849227a38cf4b154fdc21741c6b | /CPP_Joc_Windows_Android/SH_Client_Win_Cpp_Cmake/App/src/graphics/material/attributeTypes/MACastColor.cpp | 5c589684d02b17b002a41f003050e26e5c743169 | [] | no_license | AdrianNostromo/CodeSamples | 1a7b30fb6874f2059b7d03951dfe529f2464a3c0 | a0307a4b896ba722dd520f49d74c0f08c0e0042c | refs/heads/main | 2023-02-16T04:18:32.176006 | 2021-01-11T17:47:45 | 2021-01-11T17:47:45 | 328,739,437 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 872 | cpp | #include "MACastColor.h"
#include <base/opengl/util/GLUtil.h>
#include <graphics/shader/program/ShaderProgram.h>
#include <graphics/attribute/IAttributesList.h>
#include <graphics/material/attributeTypes/MAShadowMapLight3D.h>
#include <graphics/camera/OrthographicCamera.h>
#include <base/MM.h>
using namespace graphics;
std::string MACastColor::Alias = "castColor";
long MACastColor::TypeBitGroup = registerAttribute(Alias);
MACastColor::MACastColor()
: super(TypeBitGroup)
{
rawSubclassPointer = this;
}
void MACastColor::bind(IAttributesList* attributesList, ShaderProgram* shaderProgram) {
super::bind(attributesList, shaderProgram);
//void
}
MACastColor* MACastColor::clone(Attribute* _o) {
if (_o != nullptr) {
throw LogicException(LOC);
}
MACastColor* o = newt MACastColor();
super::clone(o);
return o;
}
MACastColor::~MACastColor() {
//void
}
| [
"adriannostromo@gmail.com"
] | adriannostromo@gmail.com |
51ba3ad91aefeebf524c78c396c711538cde3f6f | 74fc7c5d39baa6c30aa929e629ff60bf40500c61 | /test/unit-tests/meta_file_intf/mock_file_intf_mock.h | ecadb995ed98f20948331ef4a90f08623238f845 | [
"BSD-3-Clause"
] | permissive | jhyunleehi/poseidonos | e472be680d0e85dc62f0e2c0d7356dbee74a3bd6 | 1d90e4320855d61742ff37af8c0148da579d95d4 | refs/heads/develop | 2023-07-13T03:37:29.754509 | 2021-08-23T15:26:08 | 2021-08-23T15:26:08 | 393,203,347 | 0 | 0 | BSD-3-Clause | 2021-08-20T00:04:14 | 2021-08-06T00:30:35 | C | UTF-8 | C++ | false | false | 935 | h | #include <gmock/gmock.h>
#include <list>
#include <string>
#include <vector>
#include "src/meta_file_intf/mock_file_intf.h"
namespace pos
{
class MockMockFileIntf : public MockFileIntf
{
public:
using MockFileIntf::MockFileIntf;
MOCK_METHOD(int, Create, (uint64_t fileSize, StorageOpt storageOpt), (override));
MOCK_METHOD(bool, DoesFileExist, (), (override));
MOCK_METHOD(int, Delete, (), (override));
MOCK_METHOD(uint64_t, GetFileSize, (), (override));
MOCK_METHOD(int, AsyncIO, (AsyncMetaFileIoCtx * ctx), (override));
MOCK_METHOD(int, CheckIoDoneStatus, (void* data), (override));
MOCK_METHOD(int, Open, (), (override));
MOCK_METHOD(int, Close, (), (override));
MOCK_METHOD(int, _Read, (int fd, uint64_t fileOffset, uint64_t length, char* buffer), (override));
MOCK_METHOD(int, _Write, (int fd, uint64_t fileOffset, uint64_t length, char* buffer), (override));
};
} // namespace pos
| [
"kyuho.son@samsung.com"
] | kyuho.son@samsung.com |
56cca96d83fc5600b57303a191f85d93f5cf0cef | fca6056231f476f018a96149c6c6e83e60a8f379 | /Source/Voxel/Private/VoxelRender/Private/VoxelRender.cpp | 0963409ef83fe14eee9013ce8e3432a9800b004c | [
"MIT"
] | permissive | getnamo/Voxel | dc9c179a267e2e801e8a694bcc0fb86e8ce0167b | cdafa2f6abd602ddfe5c7131832d92147f8d03fe | refs/heads/master | 2021-08-10T15:14:08.274759 | 2017-11-12T14:49:25 | 2017-11-12T14:49:25 | 110,459,942 | 0 | 0 | null | 2017-11-12T18:57:27 | 2017-11-12T18:57:26 | null | UTF-8 | C++ | false | false | 8,117 | cpp | // Copyright 2017 Phyronnaz
#include "VoxelPrivatePCH.h"
#include "VoxelRender.h"
#include "VoxelChunkComponent.h"
#include "ChunkOctree.h"
DECLARE_CYCLE_STAT(TEXT("VoxelRender ~ ApplyUpdates"), STAT_ApplyUpdates, STATGROUP_Voxel);
DECLARE_CYCLE_STAT(TEXT("VoxelRender ~ UpdateLOD"), STAT_UpdateLOD, STATGROUP_Voxel);
FVoxelRender::FVoxelRender(AVoxelWorld* World, AActor* ChunksParent, FVoxelData* Data, uint32 MeshThreadCount, uint32 HighPriorityMeshThreadCount, uint32 FoliageThreadCount)
: World(World)
, ChunksParent(ChunksParent)
, Data(Data)
, MeshThreadPool(FQueuedThreadPool::Allocate())
, HighPriorityMeshThreadPool(FQueuedThreadPool::Allocate())
, FoliageThreadPool(FQueuedThreadPool::Allocate())
, TimeSinceFoliageUpdate(0)
, TimeSinceLODUpdate(0)
{
// Add existing chunks
for (auto Component : ChunksParent->GetComponentsByClass(UVoxelChunkComponent::StaticClass()))
{
UVoxelChunkComponent* ChunkComponent = Cast<UVoxelChunkComponent>(Component);
if (ChunkComponent)
{
ChunkComponent->SetProcMeshSection(0, FVoxelProcMeshSection());
ChunkComponent->SetVoxelMaterial(World->GetVoxelMaterial());
InactiveChunks.push_front(ChunkComponent);
}
}
// Delete existing grass components
for (auto Component : ChunksParent->GetComponentsByClass(UHierarchicalInstancedStaticMeshComponent::StaticClass()))
{
Component->DestroyComponent();
}
MeshThreadPool->Create(MeshThreadCount, 64 * 1024);
HighPriorityMeshThreadPool->Create(HighPriorityMeshThreadCount, 64 * 1024, TPri_AboveNormal);
FoliageThreadPool->Create(FoliageThreadCount, 32 * 1024);
MainOctree = MakeShareable(new FChunkOctree(this, FIntVector::ZeroValue, Data->Depth, FOctree::GetTopIdFromDepth(Data->Depth)));
}
FVoxelRender::~FVoxelRender()
{
check(ActiveChunks.Num() == 0);
check(InactiveChunks.empty());
}
void FVoxelRender::Tick(float DeltaTime)
{
check(ChunksToCheckForTransitionChange.Num() == 0);
TimeSinceFoliageUpdate += DeltaTime;
TimeSinceLODUpdate += DeltaTime;
if (TimeSinceLODUpdate > 1 / World->GetLODUpdateFPS())
{
check(ChunksToCheckForTransitionChange.Num() == 0);
UpdateLOD();
// See Init and Unload functions of AVoxelChunk
for (auto Chunk : ChunksToCheckForTransitionChange)
{
Chunk->CheckTransitions();
}
ChunksToCheckForTransitionChange.Empty();
TimeSinceLODUpdate = 0;
}
ApplyUpdates();
if (TimeSinceFoliageUpdate > 1 / World->GetFoliageFPS())
{
for (auto Chunk : FoliageUpdateNeeded)
{
Chunk->UpdateFoliage();
}
FoliageUpdateNeeded.Empty();
TimeSinceFoliageUpdate = 0;
}
// Apply new meshes and new foliages
{
FScopeLock Lock(&ChunksToApplyNewMeshLock);
for (auto Chunk : ChunksToApplyNewMesh)
{
Chunk->ApplyNewMesh();
}
ChunksToApplyNewMesh.Empty();
}
{
FScopeLock Lock(&ChunksToApplyNewFoliageLock);
for (auto Chunk : ChunksToApplyNewFoliage)
{
Chunk->ApplyNewFoliage();
}
ChunksToApplyNewFoliage.Empty();
}
// Chunks to delete
for (FChunkToDelete& ChunkToDelete : ChunksToDelete)
{
ChunkToDelete.TimeLeft -= DeltaTime;
if (ChunkToDelete.TimeLeft < 0)
{
auto Chunk = ChunkToDelete.Chunk;
check(!FoliageUpdateNeeded.Contains(Chunk));
check(!ChunksToApplyNewMesh.Contains(Chunk));
check(!ChunksToApplyNewFoliage.Contains(Chunk));
Chunk->Delete();
ActiveChunks.Remove(Chunk);
InactiveChunks.push_front(Chunk);
}
}
ChunksToDelete.remove_if([](FChunkToDelete ChunkToDelete) { return ChunkToDelete.TimeLeft < 0; });
}
void FVoxelRender::AddInvoker(TWeakObjectPtr<UVoxelInvokerComponent> Invoker)
{
VoxelInvokerComponents.push_front(Invoker);
}
UVoxelChunkComponent* FVoxelRender::GetInactiveChunk()
{
UVoxelChunkComponent* Chunk;
if (InactiveChunks.empty())
{
Chunk = NewObject<UVoxelChunkComponent>(ChunksParent, NAME_None, RF_Transient | RF_NonPIEDuplicateTransient);
Chunk->SetupAttachment(ChunksParent->GetRootComponent(), NAME_None);
Chunk->RegisterComponent();
Chunk->SetVoxelMaterial(World->GetVoxelMaterial());
}
else
{
Chunk = InactiveChunks.front();
InactiveChunks.pop_front();
}
ActiveChunks.Add(Chunk);
check(Chunk->IsValidLowLevel());
return Chunk;
}
void FVoxelRender::UpdateChunk(TWeakPtr<FChunkOctree> Chunk, bool bAsync)
{
if (Chunk.IsValid())
{
ChunksToUpdate.Add(Chunk);
if (!bAsync)
{
IdsOfChunksToUpdateSynchronously.Add(Chunk.Pin().Get()->Id);
}
}
}
void FVoxelRender::UpdateChunksAtPosition(FIntVector Position, bool bAsync)
{
check(Data->IsInWorld(Position.X, Position.Y, Position.Z));
UpdateChunksOverlappingBox(FVoxelBox(Position, Position), bAsync);
}
void FVoxelRender::UpdateChunksOverlappingBox(FVoxelBox Box, bool bAsync)
{
Box.Min -= FIntVector(2, 2, 2); // For normals
Box.Max += FIntVector(2, 2, 2); // For normals
std::forward_list<TWeakPtr<FChunkOctree>> OverlappingLeafs;
MainOctree->GetLeafsOverlappingBox(Box, OverlappingLeafs);
for (auto Chunk : OverlappingLeafs)
{
UpdateChunk(Chunk, bAsync);
}
}
void FVoxelRender::ApplyUpdates()
{
SCOPE_CYCLE_COUNTER(STAT_ApplyUpdates);
std::forward_list<TWeakPtr<FChunkOctree>> Failed;
for (auto& Chunk : ChunksToUpdate)
{
TSharedPtr<FChunkOctree> LockedChunk(Chunk.Pin());
if (LockedChunk.IsValid() && LockedChunk->GetVoxelChunk())
{
bool bAsync = !IdsOfChunksToUpdateSynchronously.Contains(LockedChunk->Id);
bool bSuccess = LockedChunk->GetVoxelChunk()->Update(bAsync);
/*if (!bSuccess)
{
UE_LOG(VoxelLog, Warning, TEXT("Chunk already updating"));
}*/
}
}
ChunksToUpdate.Reset();
IdsOfChunksToUpdateSynchronously.Reset();
}
void FVoxelRender::UpdateAll(bool bAsync)
{
for (auto Chunk : ActiveChunks)
{
Chunk->Update(bAsync);
}
}
void FVoxelRender::UpdateLOD()
{
SCOPE_CYCLE_COUNTER(STAT_UpdateLOD);
// Clean
std::forward_list<TWeakObjectPtr<UVoxelInvokerComponent>> Temp;
for (auto Invoker : VoxelInvokerComponents)
{
if (Invoker.IsValid())
{
Temp.push_front(Invoker);
}
}
VoxelInvokerComponents = Temp;
MainOctree->UpdateLOD(VoxelInvokerComponents);
}
void FVoxelRender::AddFoliageUpdate(UVoxelChunkComponent* Chunk)
{
FoliageUpdateNeeded.Add(Chunk);
}
void FVoxelRender::AddTransitionCheck(UVoxelChunkComponent* Chunk)
{
ChunksToCheckForTransitionChange.Add(Chunk);
}
void FVoxelRender::ScheduleDeletion(UVoxelChunkComponent* Chunk)
{
// Cancel any pending update
RemoveFromQueues(Chunk);
// Schedule deletion
ChunksToDelete.push_front(FChunkToDelete(Chunk, World->GetDeletionDelay()));
}
void FVoxelRender::ChunkHasBeenDestroyed(UVoxelChunkComponent* Chunk)
{
RemoveFromQueues(Chunk);
ChunksToDelete.remove_if([Chunk](FChunkToDelete ChunkToDelete) { return ChunkToDelete.Chunk == Chunk; });
InactiveChunks.remove(Chunk);
ActiveChunks.Remove(Chunk);
}
void FVoxelRender::AddApplyNewMesh(UVoxelChunkComponent* Chunk)
{
FScopeLock Lock(&ChunksToApplyNewMeshLock);
ChunksToApplyNewMesh.Add(Chunk);
}
void FVoxelRender::AddApplyNewFoliage(UVoxelChunkComponent* Chunk)
{
FScopeLock Lock(&ChunksToApplyNewFoliageLock);
ChunksToApplyNewFoliage.Add(Chunk);
}
void FVoxelRender::RemoveFromQueues(UVoxelChunkComponent* Chunk)
{
FoliageUpdateNeeded.Remove(Chunk);
{
FScopeLock Lock(&ChunksToApplyNewMeshLock);
ChunksToApplyNewMesh.Remove(Chunk);
}
{
FScopeLock Lock(&ChunksToApplyNewFoliageLock);
ChunksToApplyNewFoliage.Remove(Chunk);
}
}
TWeakPtr<FChunkOctree> FVoxelRender::GetChunkOctreeAt(FIntVector Position) const
{
check(Data->IsInWorld(Position.X, Position.Y, Position.Z));
return MainOctree->GetLeaf(Position);
}
int FVoxelRender::GetDepthAt(FIntVector Position) const
{
return GetChunkOctreeAt(Position).Pin()->Depth;
}
void FVoxelRender::Destroy()
{
MeshThreadPool->Destroy();
HighPriorityMeshThreadPool->Destroy();
FoliageThreadPool->Destroy();
for (auto Chunk : ActiveChunks)
{
if (!Chunk->IsPendingKill())
{
Chunk->Delete();
}
else
{
Chunk->ResetRender();
}
}
ActiveChunks.Empty();
InactiveChunks.resize(0);
}
FVector FVoxelRender::GetGlobalPosition(FIntVector LocalPosition)
{
return World->LocalToGlobal(LocalPosition) + ChunksParent->GetActorLocation() - World->GetActorLocation();
}
| [
"phyronnaz@gmail.com"
] | phyronnaz@gmail.com |
a546029de30ff01dfeac57001b49c3308c39821a | 4a238068e29a1f6871cc049a0486b20b27e781de | /Supermicro/benchmarks/dlrm/implementations/hugectr_J/test/utest/layers/fully_connected_layer_test.cpp | cb461eba4030a8391fc181ecb6a7f5d53b2e6981 | [
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | Pixelz-Inc/training_results_v1.0 | 61b4555ad482b189d1966be3edd127858addd628 | c507130c4e04c1f274a9ae8b7284aac79f26325a | refs/heads/master | 2023-08-18T22:46:13.316503 | 2021-10-22T04:01:57 | 2021-10-22T04:01:57 | 399,047,712 | 0 | 0 | NOASSERTION | 2021-08-23T09:37:25 | 2021-08-23T09:37:25 | null | UTF-8 | C++ | false | false | 6,809 | cpp | /*
* Copyright (c) 2020, NVIDIA CORPORATION.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "HugeCTR/include/layers/fully_connected_layer.hpp"
#include <cmath>
#include <cstdlib>
#include <vector>
#include "utest/test_utils.h"
using namespace std;
using namespace HugeCTR;
static bool check_cpu_gpu(float *cpu_p, float *gpu_p, int len, float tol) {
float *cpu_tmp = (float *)malloc(sizeof(float) * len);
CK_CUDA_THROW_(cudaMemcpy(cpu_tmp, gpu_p, sizeof(float) * len, cudaMemcpyDeviceToHost));
float max_diff = fabs(cpu_p[0] - cpu_tmp[0]);
bool flag = true;
for (int i = 0; i < len; ++i) {
if (fabs(cpu_p[i] - cpu_tmp[i]) >= tol) flag = false;
max_diff = max(max_diff, fabs(cpu_p[i] - cpu_tmp[i]));
}
free(cpu_tmp);
return flag;
}
static void cpu_mm(float *a, float *b, float *c, int m, int k, int n) {
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n; ++j) {
c[i * n + j] = 0.0f;
for (int kk = 0; kk < k; ++kk) c[i * n + j] += a[i * k + kk] * b[kk * n + j];
}
}
}
static void cpu_add_bias(float *out, float *bias, int m, int n) {
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n; ++j) {
out[i * n + j] += bias[j];
}
}
}
static void transpose(float *a, int m, int n) {
std::unique_ptr<float[]> tmp(new float[m * n]);
for (int i = 0; i < m; ++i)
for (int j = 0; j < n; ++j) tmp[j * m + i] = a[i * n + j];
for (int i = 0; i < m * n; ++i) a[i] = tmp[i];
}
static void fully_connected_layer_test(size_t m, size_t n, size_t k, float tol = 1e-3,
bool enable_tf32_compute = false) {
std::shared_ptr<GeneralBuffer2<CudaAllocator>> blobs_buff =
GeneralBuffer2<CudaAllocator>::create();
std::shared_ptr<BufferBlock2<float>> weight_buff = blobs_buff->create_block<float>();
std::shared_ptr<BufferBlock2<float>> wgrad_buff = blobs_buff->create_block<float>();
Tensor2<float> in_tensor;
blobs_buff->reserve({m, k}, &in_tensor);
Tensor2<float> out_tensor;
blobs_buff->reserve({m, n}, &out_tensor);
FullyConnectedLayer fully_connected_layer(weight_buff, wgrad_buff, in_tensor, out_tensor,
test::get_default_gpu(), false, enable_tf32_compute);
// Initialize tensors to 0 and choose cublas algorithms
blobs_buff->allocate();
fully_connected_layer.initialize();
// fully_connected_layer.search_algorithm();
// Reset tensors to 0 to ensure all the data are the same as original utest(clear the side effect
// of optimize)
Tensor2<float> weight = weight_buff->as_tensor();
Tensor2<float> wgrad = wgrad_buff->as_tensor();
CK_CUDA_THROW_(cudaMemset(weight.get_ptr(), 0, weight.get_size_in_bytes()));
CK_CUDA_THROW_(cudaMemset(wgrad.get_ptr(), 0, wgrad.get_size_in_bytes()));
// TODO: result check
float *d_weight = weight.get_ptr();
float *d_weight_grad = wgrad.get_ptr();
float *d_in = in_tensor.get_ptr();
float *d_out = out_tensor.get_ptr();
std::unique_ptr<float[]> h_weight(new float[test::align_to_even(n * k)]);
std::unique_ptr<float[]> h_weight_grad(new float[n * k]);
std::unique_ptr<float[]> h_bias_grad(new float[n]);
std::unique_ptr<float[]> h_in(new float[test::align_to_even(k * m)]);
std::unique_ptr<float[]> h_out(new float[test::align_to_even(n * m)]);
std::unique_ptr<float[]> h_bias(new float[test::align_to_even(n)]);
test::GaussianDataSimulator simulator(0.0f, 1.0f);
simulator.fill(h_weight.get(), test::align_to_even(k * n));
simulator.fill(h_in.get(), test::align_to_even(m * k));
simulator.fill(h_bias.get(), test::align_to_even(n));
// cpu fprop
cpu_mm(h_in.get(), h_weight.get(), h_out.get(), m, k, n);
cpu_add_bias(h_out.get(), h_bias.get(), m, n);
CK_CUDA_THROW_(
cudaMemcpy(d_weight, h_weight.get(), sizeof(float) * k * n, cudaMemcpyHostToDevice));
CK_CUDA_THROW_(
cudaMemcpy(d_weight + k * n, h_bias.get(), sizeof(float) * n, cudaMemcpyHostToDevice));
CK_CUDA_THROW_(cudaMemcpy(d_in, h_in.get(), sizeof(float) * m * k, cudaMemcpyHostToDevice));
CK_CUDA_THROW_(cudaDeviceSynchronize());
fully_connected_layer.fprop(true);
CK_CUDA_THROW_(cudaDeviceSynchronize());
ASSERT_EQ(true, check_cpu_gpu(h_out.get(), d_out, m * n, tol))
<< "fprop cross_check result fail" << endl;
simulator.fill(h_out.get(), test::align_to_even(m * n));
for (size_t i = 0; i < n; ++i) h_bias_grad[i] = 0.0f;
for (size_t i = 0; i < m; ++i) {
for (size_t j = 0; j < n; ++j) h_bias_grad[j] += h_out[i * n + j];
}
// CPU bprop
transpose(h_weight.get(), k, n);
transpose(h_in.get(), m, k);
cpu_mm(h_in.get(), h_out.get(), h_weight_grad.get(), k, m, n);
cpu_mm(h_out.get(), h_weight.get(), h_in.get(), m, n, k);
CK_CUDA_THROW_(cudaMemcpy(d_out, h_out.get(), sizeof(float) * m * n, cudaMemcpyHostToDevice));
CK_CUDA_THROW_(cudaDeviceSynchronize());
fully_connected_layer.bprop();
CK_CUDA_THROW_(cudaDeviceSynchronize());
ASSERT_EQ(true, check_cpu_gpu(h_in.get(), d_in, m * k, tol))
<< " bprop cross_check input_grad fail" << endl;
ASSERT_EQ(true, check_cpu_gpu(h_weight_grad.get(), d_weight_grad, k * n, tol))
<< " bprop cross_check weight_grad fail" << endl;
ASSERT_EQ(true, check_cpu_gpu(h_bias_grad.get(), d_weight_grad + k * n, n, tol))
<< " bprop cross_check bias_grad fail" << endl;
}
TEST(fully_connected_layer, fp32_1024x1024x1024) { fully_connected_layer_test(1024, 1024, 1024); }
TEST(fully_connected_layer, fp32_2048x2048x2048) { fully_connected_layer_test(2048, 2048, 2048); }
TEST(fully_connected_layer, fp32_1x1024x1024) { fully_connected_layer_test(1, 1024, 1024); }
TEST(fully_connected_layer, fp32_1024x1x1024) { fully_connected_layer_test(1024, 1, 1024); }
TEST(fully_connected_layer, fp32_1024x1024x1) { fully_connected_layer_test(1024, 1024, 1); }
TEST(fully_connected_layer, fp32_1x1x1) { fully_connected_layer_test(1, 1, 1); }
TEST(fully_connected_layer, fp32_256x512x1024) { fully_connected_layer_test(256, 512, 1024); }
TEST(fully_connected_layer, fp32_251x511x1023) { fully_connected_layer_test(251, 511, 1023); }
TEST(fully_connected_layer, tf32_256x512x1024) {
fully_connected_layer_test(256, 512, 1024, 5e-0, true);
}
TEST(fully_connected_layer, tf32_251x511x1023) {
fully_connected_layer_test(251, 511, 1023, 5e-0, true);
}
| [
"vsb@fb.com"
] | vsb@fb.com |
ebdf599188e6d4bf593482e66b03b882c30bcf69 | e0d753aee00dd0f4a5defe5c42b8da74f01cd8b3 | /core/input/CapturedMouseController.cpp | 9b6b18739fa7d37f137f6ac7e2d6a23833cf3c26 | [] | no_license | gulbanana/musa | 05ea7e636ee73109d08c124cd865f24258ec453a | 5925d23e109422a38a0a6e917094fe0a3194fcfd | refs/heads/master | 2016-09-05T12:20:11.966246 | 2014-04-21T17:48:21 | 2014-04-21T17:48:21 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,039 | cpp | #include <core/stdafx.h>
#include "CapturedMouseController.h"
using namespace std;
CapturedMouseController::CapturedMouseController()
{
SDL_SetRelativeMouseMode(SDL_TRUE);
}
void CapturedMouseController::handle(SDL_Event& event)
{
/*switch (event.type)
{
case SDL_MOUSEMOTION:
{
//XXX change this to an init message
//XXX2 what does that mean? message as in "sent by the engine to the system?"
if (!_inited)
{
_inited = true;
SDL_EventState(SDL_MOUSEMOTION, SDL_IGNORE);
SDL_WarpMouse(500, 500);
SDL_WM_GrabInput(SDL_GRAB_ON);
SDL_EnableKeyRepeat(0, 0); //disable
SDL_ShowCursor(SDL_DISABLE);
SDL_EventState(SDL_MOUSEMOTION, SDL_ENABLE);
disabled = true;
return;
}
//move the cursor somewhere it can't bother us
SDL_EventState(SDL_MOUSEMOTION, SDL_IGNORE);
SDL_WarpMouse(500, 500);
SDL_EventState(SDL_MOUSEMOTION, SDL_ENABLE);
disabled = false;
}
}*/
} | [
"castiglione@gmail.com"
] | castiglione@gmail.com |
89f74514e8ca1bb93f600d5b4088003774a86671 | 1be66b32b55baeef9dff49bafc04a26dce301192 | /Components/BSSelectableComponent.cpp | 497735869cb9251927d86206002ec4ed735b6ced | [] | no_license | LarssonSv/HordeHavoc | d66c622814d0794ad08c076af9d441ac311aa407 | a2435f09ef0018995497b9cf1def7f573f7fd491 | refs/heads/master | 2020-08-05T00:36:29.716542 | 2019-10-23T07:34:50 | 2019-10-23T07:34:50 | 212,334,305 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,382 | cpp | #include "BSSelectableComponent.h"
#include <GameFramework/Actor.h>
#include <Components/StaticMeshComponent.h>
#include "Core/BSPlayerController.h"
UBSSelectableComponent::UBSSelectableComponent()
{
PrimaryComponentTick.bCanEverTick = true;
}
void UBSSelectableComponent::BeginPlay()
{
Super::BeginPlay();
TargetLocation = GetOwner()->GetActorLocation();
canBeSelectedValue = CanBeSelected;
}
void UBSSelectableComponent::TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction)
{
Super::TickComponent(DeltaTime, TickType, ThisTickFunction);
if (canBeSelectedValue != CanBeSelected)
{
canBeSelectedValue = CanBeSelected;
if (!canBeSelectedValue)
{
ABSPlayerController* playerController = Cast<ABSPlayerController>(GetWorld()->GetFirstPlayerController());
playerController->Deselect();
}
}
const FVector delta = TargetLocation - GetOwner()->GetActorLocation();
if(delta.Size() > StopDistance)
GetOwner()->AddActorWorldOffset(delta.GetSafeNormal() * Speed * DeltaTime);
}
void UBSSelectableComponent::Deactivate()
{
CanBeSelected = false;
canBeSelectedValue = false;
}
void UBSSelectableComponent::ReActivate()
{
CanBeSelected = true;
canBeSelectedValue = true;
}
void UBSSelectableComponent::TempMove(FVector location)
{
TargetLocation = location;
}
| [
"noreply@github.com"
] | LarssonSv.noreply@github.com |
15547b25577cf9d2637c7dd89a9f1efc735e6a44 | 820913c9f783ff4642ee69b92789044549bbdb4a | /src/StdHeaders.cpp | 91153831878ce150234ea94845649bc55aec80cf | [] | no_license | opticyclic/npp-puppet-lint | 8d6d993efca298d9495664615732c1ac5ac79a5d | 0524ec0ebcbb81f68f6caa85fbd5989bca69fe27 | refs/heads/master | 2021-01-10T05:54:55.150632 | 2016-04-02T18:17:29 | 2016-04-02T18:17:29 | 36,915,588 | 4 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 842 | cpp | //This file is part of JSLint Plugin for Notepad++
//Copyright (C) 2010 Martin Vladic <martin.vladic@gmail.com>
//
//This program is free software; you can redistribute it and/or
//modify it under the terms of the GNU General Public License
//as published by the Free Software Foundation; either
//version 2 of the License, or (at your option) any later version.
//
//This program is distributed in the hope that it will be useful,
//but WITHOUT ANY WARRANTY; without even the implied warranty of
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//GNU General Public License for more details.
//
//You should have received a copy of the GNU General Public License
//along with this program; if not, write to the Free Software
//Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
#include "StdHeaders.h" | [
"mvladic@users.sourceforge.net"
] | mvladic@users.sourceforge.net |
a5524cce8173d961a0960a14989952a3c85d507f | 7538f30404c0eb74c17d5b982eae689b754e227e | /13.5/PrivateFrameworks/TextInput.framework/CDStructures.h | a7d0416fd49b38d80ba41d0ecaf77bb1c38c0bf6 | [] | no_license | xybp888/iOS-Header | cdb31acaa22236818917245619fe4f4b90d62d30 | 0c23e5a9242f1d8fd04d376c22e88d2ec74c3374 | refs/heads/master | 2022-11-18T22:35:35.676837 | 2022-10-29T23:47:18 | 2022-10-29T23:47:18 | 204,074,346 | 156 | 63 | null | null | null | null | UTF-8 | C++ | false | false | 1,577 | h | //
// Generated by class-dump 3.5 (64 bit).
//
// Copyright (C) 1997-2019 Steve Nygard.
//
#pragma mark Blocks
typedef void (^CDUnknownBlockType)(void); // return type and parameters are unknown
#pragma mark Named Structures
struct CGPoint {
double x;
double y;
};
struct CGRect {
struct CGPoint origin;
struct CGSize size;
};
struct CGSize {
double width;
double height;
};
struct _NSRange {
unsigned long long location;
unsigned long long length;
};
struct _ShortRect {
short _field1;
short _field2;
short _field3;
short _field4;
};
struct _img {
unsigned long long _field1;
unsigned long long _field2;
unsigned long long _field3;
unsigned long long _field4;
unsigned char _field5;
unsigned char _field6[4];
};
struct vector<TIHandwritingPoint, std::__1::allocator<TIHandwritingPoint>>;
struct vector<std::__1::vector<TIHandwritingPoint, std::__1::allocator<TIHandwritingPoint>>, std::__1::allocator<std::__1::vector<TIHandwritingPoint, std::__1::allocator<TIHandwritingPoint>>>> {
struct vector<TIHandwritingPoint, std::__1::allocator<TIHandwritingPoint>> *__begin_;
struct vector<TIHandwritingPoint, std::__1::allocator<TIHandwritingPoint>> *__end_;
struct __compressed_pair<std::__1::vector<TIHandwritingPoint, std::__1::allocator<TIHandwritingPoint>>*, std::__1::allocator<std::__1::vector<TIHandwritingPoint, std::__1::allocator<TIHandwritingPoint>>>> {
struct vector<TIHandwritingPoint, std::__1::allocator<TIHandwritingPoint>> *__value_;
} __end_cap_;
};
| [
"8657156@qq.com"
] | 8657156@qq.com |
e0e47ad782d0ecf5940f022a3fae0496640cfeb9 | d6cdd85ce4ed49613951dbab233a5d473f073cab | /UsbEmulationServer/VirtualBulkDevice.h | a92e02f7aaae8ca7de553165305e8967d6b4468b | [] | no_license | L-proger/SoftUsb | 17ae66f9d7fc23dc0cdf41acab7d10f6f247065a | f0156a5e0ce1a7ba28f45b85c059f244cab209cd | refs/heads/master | 2021-09-07T06:59:38.631082 | 2018-02-19T08:00:49 | 2018-02-19T08:00:49 | 115,264,572 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 259 | h | #ifndef VIRTUALBULKDEVICE_H
#define VIRTUALBULKDEVICE_H
#include <lframework/USB/USBDevice.h>
class VirtualBulkDevice : public LFramework::USB::UsbDevice<>
{
public:
VirtualBulkDevice::VirtualBulkDevice()
{
}
};
#endif // VIRTUALBULKDEVICE_H
| [
"l-proger@yandex.ru"
] | l-proger@yandex.ru |
4aaf41400b41f3f27a0eb2e866788559a88109a9 | e70a21a634146df96af6500901c3af001b2524b3 | /Lab9/Lab9/isDigit.cpp | 0ad8a55a3c97bb26d3e3d477531d3a33c197b248 | [] | no_license | yangellen/Introduction_to_Computer_Science | c6009593f58994f71eb7b4cbd845cc6e891e55f0 | 1edb576a652b5e756293296ad18c09286c1ff3dc | refs/heads/master | 2021-01-07T20:27:03.321018 | 2020-09-09T19:11:47 | 2020-09-09T19:11:47 | 241,811,936 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,654 | cpp | /*********************************************************************
** Program name: Lab3_Yang_Ellen.zip
** Author: Ellen Yang
** Date: Oct 10, 2018
** Description: A function that takes a string to check if it's all digits
** and return bool
*********************************************************************/
#include "isDigit.hpp"
#include <string>
using std::string;
using std::isdigit;
/*********************************************************************
** isDigit(string)
** Description: This function takes a string to check if it contains all
** digits and return a boolean.
*********************************************************************/
bool isDigit(string choice)
{
int count = 0;
bool integer = true;
for (int i = 0; i < choice.length(); i++) //for each char in string
{
if (isdigit(choice[i]))
{
count += 1;
}
if (count == choice.length())
{
integer = true; //all digits
}
else if (count != choice.length()) //not all digits
{
integer = false;
}
}
return integer;
}
//take a string to check if it's all letters and return bool
bool isLetter(string choice)
{
int count = 0;
bool letter = true;
for (int i = 0; i < choice.length(); i++) //for each char in string
{
if (isalpha(choice[i]))
{
count += 1;
}
if (count == choice.length())
{
letter = true; //all letters
}
else if (count != choice.length()) //not all letter
{
letter = false;
}
}
return letter;
}
| [
"49252706+yangellen@users.noreply.github.com"
] | 49252706+yangellen@users.noreply.github.com |
cea62196d0c203f43c899114e25fe4d51def7b23 | 5e90bfd76149789b2242382ecea0c2a43a1e5807 | /sources/Reconstruction/SAMURAI/include/TArtNeuLANDPla.hh | 8303ab60020a5b30178cff75ee8b94376582126d | [] | no_license | Phystam/anashikiroot | fcf9b6c2eabff2695f842d6b45e0691ed37786eb | eff1c1a75816e2b7017c5d1f65a52fd86262eb7c | refs/heads/master | 2021-01-02T09:03:56.958863 | 2018-06-21T11:16:27 | 2018-06-21T11:16:27 | 99,131,998 | 0 | 0 | null | 2017-11-07T10:06:59 | 2017-08-02T15:23:01 | C++ | UTF-8 | C++ | false | false | 4,801 | hh | #ifndef _TARTNEULANDPLA_H_
#define _TARTNEULANDPLA_H_
#include "TString.h"
#include <TRandom3.h>
#include <iostream>
#include "TArtDataObject.hh"
class TArtNeuLANDPla : public TArtDataObject
{
public:
TArtNeuLANDPla()
: TArtDataObject(),
fLayer(-1), fBarID(-1), fPos(-1), fZPos(-1)
{
for(int i=0;i<2;i++){
fQRaw[i] = -1;
fQPed[i] = -1;
fQCal[i] = -1;
fTac[i] = -1;
fTacCal[i] = -1;
fTacRefCal[i] = -1;
fTCycle[i] = -1;
fTRaw[i] = -1;
fTCal[i] = -1;
isFired[i] = kFALSE;
}
}
virtual ~TArtNeuLANDPla(){}
virtual void SetLayer(Int_t val){fLayer = val;}
virtual void SetBarID(Int_t val){fBarID = val;}
virtual void SetQRaw(Int_t i, Int_t val){fQRaw[i] = val;}
virtual void SetQPed(Int_t i, Double_t val){fQPed[i] = val;}
virtual void SetQCal(Int_t i, Double_t val){fQCal[i] = val;}
virtual void SetTCycle(Int_t i, Int_t val){fTCycle[i] = val;}
virtual void SetTac(Int_t i, Int_t val){fTac[i] = val;}
virtual void SetTacCal(Int_t i, Double_t val){fTacCal[i] = val;}
virtual void SetTacRefCal(Int_t i, Double_t val){fTacRefCal[i] = val;}
virtual void SetTacRef(Int_t i, Int_t val){fTacRef[i] = val;}
virtual void SetTRaw(Int_t i, Double_t val){fTRaw[i] = val;}
virtual void SetTCal(Int_t i, Double_t val){fTCal[i] = val;}
virtual void SetTacquilaID(Int_t sam, Int_t gtb, Int_t mod, Int_t ch) {
fsam = sam;
fgtb = gtb;
fmod = mod;
fch = ch;
}
virtual void SetFired(int i) {isFired[i] = kTRUE;}
virtual void SetPos(Double_t val){fPos = val;}
virtual void SetZPos(Double_t val){fZPos = val;}
virtual Int_t GetLayer() const {return fLayer;}
virtual Int_t GetBarID() const {return fBarID;}
virtual Int_t GetQRaw (Int_t i) const {return fQRaw[i];}
virtual Double_t GetQPed (Int_t i) const {return fQPed[i];}
virtual Double_t GetQAvePed() const {return (fQPed[0]+fQPed[1])/2.;}
virtual Double_t GetQCal (Int_t i) const {return fQCal[i];}
virtual Int_t GetTCycle(Int_t i) const {return fTCycle[i];}
virtual Int_t GetTac (Int_t i) const {return fTac[i];}
virtual Double_t GetTacCal(Int_t i) const {return fTacCal[i];}
virtual Double_t GetTacRefCal(Int_t i) const {return fTacRefCal[i];}
virtual Int_t GetTacRef(Int_t i) const {return fTacRef[i];}
virtual Double_t GetTRaw (Int_t i) const {return fTRaw[i];}
virtual Double_t GetTAveRaw () const {return (fTRaw[0]+fTRaw[1])/2.;}
virtual Double_t GetTCal (Int_t i) const {return fTCal[i];}
virtual Double_t GetTAveCal () const {return (fTCal[0]+fTCal[1])/2.;}
virtual void GetTacquilaID(Int_t &sam, Int_t >b, Int_t &mod, Int_t &ch) {
sam = fsam;
gtb = fgtb;
mod = fmod;
ch = fch;
}
virtual Bool_t GetFired(int i) const {return isFired[i];}
virtual Bool_t GetBothFired() const {return isFired[0] && isFired[1];}
virtual Double_t GetPos() const {return fPos;}
// position in 2d, size of bar is 5x5x250 cm3
virtual Double_t GetX() const {return fLayer%2 == 0 ? fPos : (fBarID-24.5)*50;}
virtual Double_t GetY() const {return fLayer%2 == 1 ? fPos : (fBarID-24.5)*50;}
// virtual Double_t GetZ() const {return fZPos+gRandom->Uniform(-25,25);}
virtual Double_t GetZ() const {return fZPos;}
virtual void PrintData(){
std::cout << "Layer: " << fLayer << std::endl;
std::cout << "Bar ID: " << fBarID << std::endl;
for(int i=0;i<2;i++){
std::cout << "QRaw"<<i<<": " << fQRaw[i] << std::endl;
std::cout << "QPed"<<i<<": " << fQPed[i] << std::endl;
std::cout << "QCal"<<i<<": " << fQCal[i] << std::endl;
std::cout << "Tac"<<i<<": " << fTac[i] << std::endl;
std::cout << "TacRef"<<i<<": " << fTacRef[i] << std::endl;
std::cout << "TacCal"<<i<<": " << fTacCal[i] << std::endl;
std::cout << "TacRefCal"<<i<<": " << fTacRefCal[i] << std::endl;
std::cout << "TCycle"<<i<<": " << fTCycle[i] << std::endl;
std::cout << "TRaw"<<i<<": " << fTRaw[i] << std::endl;
std::cout << "TCal"<<i<<": " << fTCal[i] << std::endl;
}
std::cout << "Pos: " << fPos << std::endl;
std::cout << std::endl;
return;
}
private:
Int_t fLayer;
Int_t fBarID;
Int_t fQRaw[2];
Int_t fQPed[2];
Double_t fQCal[2];
Int_t fTac[2];
Int_t fTacRef[2]; // reference tac, Tac 16
Double_t fTacCal[2];
Double_t fTacRefCal[2]; // reference tac, Tac 16
Int_t fTCycle[2];
Double_t fTRaw[2]; // traw = tac1 (calibrated in ns) + 25*cnt - t17 (calibrated in ns)
Double_t fTCal[2];
Bool_t isFired[2];
Double_t fPos;
Double_t fZPos;
Int_t fsam;
Int_t fgtb;
Int_t fmod;
Int_t fch;
ClassDef(TArtNeuLANDPla,1);
};
#endif
| [
"tomai@mail.nucl.ap.titech.ac.jp"
] | tomai@mail.nucl.ap.titech.ac.jp |
7f931d7a3a01e9b9787abaf021bf07e298456fbe | 2f57510287c1c4e0ec6b9a6d8335c3495c8251a3 | /cpp/unittest/testcode/source/testcase/SimpleRPCTest.cpp | 5ccd694a370013f823e0795889b7f23d24c14cf0 | [
"MIT",
"LicenseRef-scancode-unknown-license-reference",
"BSD-3-Clause",
"BSL-1.0",
"Apache-2.0"
] | permissive | jhhe66/MyTars | e0fa5fb52ba070acbd9202496f064ba34f95296b | 7a439c50760f8626011e0add47e8fbb0cde8579c | refs/heads/master | 2022-10-14T08:09:48.074518 | 2019-12-04T06:09:30 | 2019-12-04T06:09:30 | 223,847,863 | 0 | 1 | NOASSERTION | 2022-10-04T23:54:56 | 2019-11-25T02:44:14 | C++ | UTF-8 | C++ | false | false | 2,538 | cpp | /**
* Tencent is pleased to support the open source community by making Tars available.
*
* Copyright (C) 2016THL A29 Limited, a Tencent company. All rights reserved.
*
* Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
* in compliance with the License. You may obtain a copy of the License at
*
* https://opensource.org/licenses/BSD-3-Clause
*
* Unless required by applicable law or agreed to in writing, software distributed
* under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
#include "gtest/gtest.h"
#include<vector>
#include "servant/Application.h"
#include "TarsServantName.h"
#include "TarsTest/UnitTest/AServant.h"
USING_NS_STD
USING_NS_TARS
using namespace TarsTest;
/****************************************************
Tars典型测试
校验返回值
****************************************************/
struct SimpleRpcTest : public ::testing::Test
{
SimpleRpcTest()
{
_comm = Application::getCommunicator();
}
protected:
CommunicatorPtr _comm;
};
class SimpleRpcObjCallback: public AServantPrxCallback
{
public:
virtual void callback_queryTest(tars::Int32 ret, const vector<TarsTest::RspInfo>& vRsp)
{
int iSize=vRsp.size();
EXPECT_EQ(iSize, 1);
}
};
typedef tars::TC_AutoPtr<SimpleRpcObjCallback> SimpleRpcObjCallbackPtr;
TEST_F(SimpleRpcTest, should_response_rpc_when_client_sync_call_server_by_ip)
{
int64_t tBegin = TC_TimeProvider::getInstance()->getNowMs();
AServantPrx prx = _comm->stringToProxy<AServantPrx> (ASERVANT_ENDPOINT);
ReqInfo stReq;
stReq.sServerName="AServer";
stReq.sDate="20181106";
stReq.sStartTime="0000";
stReq.sEndTime="2360";
stReq.uInterval=1;
vector<RspInfo> vRsp;
int iRet = prx->queryTest(stReq,vRsp);
EXPECT_EQ(iRet, 0);
TLOGDEBUG("Simple RPC test time cost: "<< " | " << TC_TimeProvider::getInstance()->getNowMs() - tBegin << "(ms)" << endl);
}
TEST_F(SimpleRpcTest, should_response_rpc_when_client_async_call_server_by_ip)
{
AServantPrx prx = _comm->stringToProxy<AServantPrx> (ASERVANT_ENDPOINT);
ReqInfo stReq;
stReq.sServerName="AServer";
stReq.sDate="20181106";
stReq.sStartTime="0000";
stReq.sEndTime="2360";
stReq.uInterval=1;
SimpleRpcObjCallbackPtr cbp = new SimpleRpcObjCallback();
prx -> async_queryTest(cbp,stReq);
sleep(1);
}
| [
"nnd1686@163.com"
] | nnd1686@163.com |
26ef28df0342274616b8f1a8f823fe8d3cc83295 | 68504653348fbee0b87cfe7fe907dc79e9d2aa66 | /Texture.hpp | 50cabbd757934dcc40323f9b71f42034831cb770 | [] | no_license | tmcol/gameengine2 | b823b2ccaa2005111acc053798cb01f24f056a5a | c1aefdde6c156757787fa133231b3514e267a932 | refs/heads/master | 2016-09-08T00:43:13.546678 | 2015-08-09T20:27:59 | 2015-08-09T20:27:59 | 40,449,254 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,172 | hpp | #ifndef TEXTURE_H
#define TEXTURE_H
#include <GL/glew.h>
#include <string>
#include <array>
#include <vector>
class Texture
{
GLuint textureID;
bool inited = false;
public:
Texture(GLenum type, std::string fname);
Texture(GLenum type, std::string fname, std::vector<std::array<GLenum, 2> >);
Texture(GLenum type, std::string fname, bool fail);
Texture(GLenum type, std::string fname, std::vector<std::array<GLenum, 2> >, bool fail);
Texture(const Texture&) = delete;
Texture& operator = (const Texture&) = delete;
Texture(Texture&&);
Texture& operator = (Texture&&);
void init(GLenum type, std::string fname);
void init(GLenum type, std::string fname, std::vector<std::array<GLenum, 2> >);
void initFail(GLenum type, std::string fname);
void initFail(GLenum type, std::string fname, std::vector<std::array<GLenum, 2> >);
~Texture();
GLuint operator * ()
{
return textureID;
}
bool getInit()
{
return inited;
}
};
#endif
| [
"thomas.collingwood13@imperial.ac.uk"
] | thomas.collingwood13@imperial.ac.uk |
1e72d5e6a4b17112b050245001e8b553204bd60b | 0ffc1b87e74dbce62f399191bcd4278b3677543f | /Day9/Day9/Scene.h | 7a96e7904bbb11daa7274a0ceb9b1616ac703f00 | [] | no_license | ParkHD/school | 7b5cba8fca83fd81fb7cf079251988c0891cf780 | 98fcb43d79aa048b0bcd72882b14dff0587d6a1a | refs/heads/main | 2023-03-18T00:17:48.751346 | 2021-03-10T08:53:01 | 2021-03-10T08:53:01 | 337,343,304 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 194 | h | #pragma once
#include "Include.h"
class Scene
{
public:
virtual void Initialize() PURE;
virtual void Progress() PURE;
virtual void Render() PURE;
virtual void Release() PURE;
};
| [
"noreply@github.com"
] | ParkHD.noreply@github.com |
85cc2f7b0adaea6b15d4a18d4327bd0e4249fb92 | 857aa84e31e4d1eca2f6f4e663d4797c645b9a20 | /A7-3-810197520/server/server.cpp | d643680ebe1e806b65ccd24da8de2cf0fd1e63e7 | [
"MIT"
] | permissive | zamanimatin/FinalProject | d82545f0911183bf6a1a49a05191b5243bf9e5e2 | f462d4a382317a4e27c1deb7c76187eccf70c378 | refs/heads/master | 2020-05-26T21:01:51.181831 | 2019-06-06T11:27:48 | 2019-06-06T11:27:48 | 188,372,272 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 11,222 | cpp | #include "server.hpp"
#include "../utils/utilities.hpp"
#include <algorithm>
#include <dirent.h>
#include <errno.h>
#include <fstream>
#include <iostream>
#include <limits.h>
#include <map>
#include <netinet/in.h>
#include <sstream>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
using namespace std;
class NotFoundHandler : public RequestHandler {
string notFoundErrPage;
public:
NotFoundHandler(string notFoundErrPage = "")
: notFoundErrPage(notFoundErrPage) {}
Response *callback(Request *req) {
Response *res = new Response(404);
if (!notFoundErrPage.empty()) {
res->setHeader("Content-Type", "text/" + getExtension(notFoundErrPage));
res->setBody(readFile(notFoundErrPage.c_str()));
}
return res;
}
};
class ServerErrorHandler {
public:
static Response *callback(string msg) {
Response *res = new Response(500);
res->setHeader("Content-Type", "application/json");
res->setBody("{ \"code\": \"500\", \"message\": \"" + msg + "\" }\n");
return res;
}
};
void split(string str, string separator, int max, vector<string> &results) {
int i = 0;
size_t found = str.find_first_of(separator);
while (found != string::npos) {
if (found > 0)
results.push_back(str.substr(0, found));
str = str.substr(found + 1);
found = str.find_first_of(separator);
if (max > -1 && ++i == max)
break;
}
if (str.length() > 0)
results.push_back(str);
}
Request *parseRawReq(char *headersRaw, size_t length) {
Request *req;
string boundary;
string lastFieldKey;
string lastFieldValue;
bool shouldBeEmpty;
try {
enum State { REQ, HEADER, BODY, BODY_HEADER, BODY_BODY };
State state = REQ;
vector<string> headers = split(string(headersRaw), "\r\n", false);
for (size_t i = 0; i < length; i++) {
if (!headersRaw[i])
throw Server::Exception("Unsupported binary data in request.");
}
size_t realBodySize =
string(headersRaw).size() -
split(string(headersRaw), "\r\n\r\n", false)[0].size() -
string("\r\n\r\n").size();
for (size_t headerIndex = 0; headerIndex < headers.size(); headerIndex++) {
string line = headers[headerIndex];
switch (state) {
case REQ: {
vector<string> R = split(line, " ", false);
if (R.size() != 3) {
throw Server::Exception("Invalid header (request line)");
}
req = new Request(R[0]);
req->setPath(R[1]);
size_t pos = req->getPath().find('?');
if (pos != string::npos && pos != req->getPath().size() - 1) {
vector<string> Q1 = split(req->getPath().substr(pos + 1), "&", false);
for (vector<string>::size_type q = 0; q < Q1.size(); q++) {
vector<string> Q2 = split(Q1[q], "=", false);
if (Q2.size() == 2)
req->setQueryParam(Q2[0], Q2[1], false);
else
throw Server::Exception("Invalid query");
}
}
req->setPath(req->getPath().substr(0, pos));
state = HEADER;
} break;
case HEADER: {
if (line == "") {
state = BODY;
if (req->getHeader("Content-Type")
.substr(0, string("multipart/form-data").size()) ==
"multipart/form-data") {
boundary =
req->getHeader("Content-Type")
.substr(req->getHeader("Content-Type").find("boundary=") +
string("boundary=").size());
}
break;
}
vector<string> R = split(line, ": ", false);
if (R.size() != 2)
throw Server::Exception("Invalid header");
req->setHeader(R[0], R[1], false);
if (toLowerCase(R[0]) == toLowerCase("Content-Length"))
if (realBodySize != (size_t)atol(R[1].c_str()))
return NULL;
} break;
case BODY: {
if (req->getHeader("Content-Type") == "") {
} else if (req->getHeader("Content-Type") ==
"application/x-www-form-urlencoded") {
vector<string> body = split(line, "&", false);
for (size_t i = 0; i < body.size(); i++) {
vector<string> field = split(body[i], "=", false);
if (field.size() == 2)
req->setBodyParam(field[0], field[1], false);
else if (field.size() == 1)
req->setBodyParam(field[0], "", false);
else
throw Server::Exception("Invalid body");
}
} else if (req->getHeader("Content-Type")
.substr(0, string("multipart/form-data").size()) ==
"multipart/form-data") {
if (line == "--" + boundary || line == "--" + boundary + "--") {
lastFieldKey = "";
lastFieldValue = "";
shouldBeEmpty = false;
state = BODY_HEADER;
}
} else {
throw Server::Exception("Unsupported body type: " +
req->getHeader("Content-Type"));
}
} break;
case BODY_HEADER: {
if (line == "") {
state = BODY_BODY;
break;
}
vector<string> R = split(line, ": ", false);
if (R.size() != 2)
throw Server::Exception("Invalid header");
if (toLowerCase(R[0]) == toLowerCase("Content-Disposition")) {
vector<string> A = split(R[1], "; ", false);
for (size_t i = 0; i < A.size(); i++) {
vector<string> attr = split(A[i], "=", false);
if (attr.size() == 2) {
if (toLowerCase(attr[0]) == toLowerCase("name")) {
lastFieldKey = attr[1].substr(1, attr[1].size() - 2);
}
} else if (attr.size() == 1) {
} else
throw Server::Exception("Invalid body attribute");
}
} else if (toLowerCase(R[0]) == toLowerCase("Content-Type")) {
if (toLowerCase(R[1]) == toLowerCase("application/octet-stream"))
shouldBeEmpty = true;
else if (toLowerCase(R[1].substr(0, R[1].find("/"))) !=
toLowerCase("text"))
throw Server::Exception("Unsupported file type: " + R[1]);
}
} break;
case BODY_BODY: {
if (line == "--" + boundary || line == "--" + boundary + "--") {
req->setBodyParam(lastFieldKey,
lastFieldValue.substr(string("\r\n").size()),
false);
lastFieldKey = "";
lastFieldValue = "";
state = BODY_HEADER;
shouldBeEmpty = false;
} else if (shouldBeEmpty && !line.empty())
throw Server::Exception("Unsupported file type: " +
string("application/octet-stream"));
else
lastFieldValue += "\r\n" + line;
} break;
}
}
} catch (Server::Exception) {
throw;
} catch (...) {
throw Server::Exception("Error on parsing request");
}
return req;
}
Server::Server(int _port) : port(_port) {
notFoundHandler = new NotFoundHandler();
sc = socket(AF_INET, SOCK_STREAM, 0);
int sc_option = 1;
setsockopt(sc, SOL_SOCKET, SO_REUSEADDR, &sc_option, sizeof(sc_option));
if (sc < 0)
throw Exception("Error on opening socket: " + string(strerror(errno)));
struct sockaddr_in serv_addr;
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = INADDR_ANY;
serv_addr.sin_port = htons(port);
if (::bind(sc, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) != 0) {
throw Exception("Error on binding: " + string(strerror(errno)));
}
}
void Server::get(string path, RequestHandler *handler) {
Route *route = new Route(GET, path);
route->setHandler(handler);
routes.push_back(route);
}
void Server::post(string path, RequestHandler *handler) {
Route *route = new Route(POST, path);
route->setHandler(handler);
routes.push_back(route);
}
void Server::run() {
::listen(sc, 10);
struct sockaddr_in cli_addr;
socklen_t clilen;
clilen = sizeof(cli_addr);
int newsc;
while (true) {
newsc = ::accept(sc, (struct sockaddr *)&cli_addr, &clilen);
if (newsc < 0)
throw Exception("Error on accept: " + string(strerror(errno)));
Response *res = NULL;
try {
char data[BUFSIZE + 1];
size_t recv_len, recv_total_len = 0;
Request *req = NULL;
while (!req) {
recv_len =
recv(newsc, data + recv_total_len, BUFSIZE - recv_total_len, 0);
if (recv_len > 0) {
recv_total_len += recv_len;
data[recv_total_len >= 0 ? recv_total_len : 0] = 0;
req = parseRawReq(data, recv_total_len);
} else
break;
}
if (!recv_total_len) {
::close(newsc);
continue;
}
req->log();
res = new Response();
size_t i = 0;
for (; i < routes.size(); i++) {
if (routes[i]->isMatch(req->getMethod(), req->getPath())) {
res = routes[i]->handle(req);
break;
}
}
if (i == routes.size() && notFoundHandler) {
res = notFoundHandler->callback(req);
}
delete req;
} catch (Exception exc) {
delete res;
res = ServerErrorHandler::callback(exc.getMessage());
}
int si;
res->log();
string res_data = res->print(si);
delete res;
int wr = send(newsc, res_data.c_str(), si, 0);
if (wr != si)
throw Exception("Send error: " + string(strerror(errno)));
::close(newsc);
}
}
Server::~Server() {
if (sc >= 0)
::close(sc);
delete notFoundHandler;
for (size_t i = 0; i < routes.size(); ++i)
delete routes[i];
}
Server::Exception::Exception(const string msg) { message = msg; }
string Server::Exception::getMessage() { return message; }
ShowFile::ShowFile(string _filePath, string _fileType) {
filePath = _filePath;
fileType = _fileType;
}
Response *ShowFile::callback(Request *req) {
Response *res = new Response;
res->setHeader("Content-Type", fileType);
res->setBody(readFile(filePath.c_str()));
return res;
}
ShowPage::ShowPage(string filePath)
: ShowFile(filePath, "text/" + getExtension(filePath)) {}
ShowImage::ShowImage(string filePath)
: ShowFile(filePath, "image/" + getExtension(filePath)) {}
void Server::setNotFoundErrPage(std::string notFoundErrPage) {
delete notFoundHandler;
notFoundHandler = new NotFoundHandler(notFoundErrPage);
}
RequestHandler::~RequestHandler() {}
TemplateHandler::TemplateHandler(string _filePath) {
filePath = _filePath;
parser = new TemplateParser(filePath);
}
Response *TemplateHandler::callback(Request *req) {
map<string, string> context;
context = this->handle(req);
Response *res = new Response;
res->setHeader("Content-Type", "text/html");
res->setBody(parser->getHtml(context));
return res;
}
map<string, string> TemplateHandler::handle(Request *req) {
map<string, string> context;
return context;
}
map<int, int> RequestHandler::map_user_and_sessionId(map<int,int>& users_map,int user_id,int session_id)
{
users_map.insert({session_id,user_id});
return users_map;
} | [
"noreply@github.com"
] | zamanimatin.noreply@github.com |
9d0a9c3461e5d3929f4ed3dbccc0b5c64500ed7f | 536656cd89e4fa3a92b5dcab28657d60d1d244bd | /third_party/blink/renderer/bindings/core/v8/v0_custom_element_constructor_builder.cc | 35937f6e29d86fccd1fc0256132e267a74af1306 | [
"LGPL-2.0-or-later",
"GPL-1.0-or-later",
"MIT",
"Apache-2.0",
"BSD-3-Clause",
"LicenseRef-scancode-warranty-disclaimer",
"LGPL-2.1-only",
"GPL-2.0-only",
"LGPL-2.0-only",
"BSD-2-Clause",
"LicenseRef-scancode-other-copyleft"
] | permissive | ECS-251-W2020/chromium | 79caebf50443f297557d9510620bf8d44a68399a | ac814e85cb870a6b569e184c7a60a70ff3cb19f9 | refs/heads/master | 2022-08-19T17:42:46.887573 | 2020-03-18T06:08:44 | 2020-03-18T06:08:44 | 248,141,336 | 7 | 8 | BSD-3-Clause | 2022-07-06T20:32:48 | 2020-03-18T04:52:18 | null | UTF-8 | C++ | false | false | 15,789 | cc | /*
* Copyright (C) 2013 Google Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "third_party/blink/renderer/bindings/core/v8/v0_custom_element_constructor_builder.h"
#include "third_party/blink/renderer/bindings/core/v8/string_or_element_creation_options.h"
#include "third_party/blink/renderer/bindings/core/v8/v8_binding_for_core.h"
#include "third_party/blink/renderer/bindings/core/v8/v8_document.h"
#include "third_party/blink/renderer/bindings/core/v8/v8_element_registration_options.h"
#include "third_party/blink/renderer/bindings/core/v8/v8_html_element.h"
#include "third_party/blink/renderer/bindings/core/v8/v8_svg_element.h"
#include "third_party/blink/renderer/core/dom/document.h"
#include "third_party/blink/renderer/core/frame/web_feature.h"
#include "third_party/blink/renderer/core/html/custom/v0_custom_element_definition.h"
#include "third_party/blink/renderer/core/html/custom/v0_custom_element_descriptor.h"
#include "third_party/blink/renderer/core/html/custom/v0_custom_element_exception.h"
#include "third_party/blink/renderer/core/html/custom/v0_custom_element_processing_stack.h"
#include "third_party/blink/renderer/core/html_names.h"
#include "third_party/blink/renderer/core/svg_names.h"
#include "third_party/blink/renderer/platform/bindings/dom_wrapper_world.h"
#include "third_party/blink/renderer/platform/bindings/exception_state.h"
#include "third_party/blink/renderer/platform/bindings/v0_custom_element_binding.h"
#include "third_party/blink/renderer/platform/bindings/v8_per_context_data.h"
#include "third_party/blink/renderer/platform/bindings/v8_private_property.h"
#include "third_party/blink/renderer/platform/heap/heap.h"
#include "third_party/blink/renderer/platform/instrumentation/use_counter.h"
#include "third_party/blink/renderer/platform/wtf/assertions.h"
namespace blink {
const V8PrivateProperty::SymbolKey kPrivatePropertyDocument;
const V8PrivateProperty::SymbolKey kPrivatePropertyIsInterfacePrototypeObject;
const V8PrivateProperty::SymbolKey kPrivatePropertyNamespaceURI;
const V8PrivateProperty::SymbolKey kPrivatePropertyTagName;
const V8PrivateProperty::SymbolKey kPrivatePropertyType;
static void ConstructCustomElement(const v8::FunctionCallbackInfo<v8::Value>&);
V0CustomElementConstructorBuilder::V0CustomElementConstructorBuilder(
ScriptState* script_state,
const ElementRegistrationOptions* options)
: script_state_(script_state), options_(options), callbacks_(nullptr) {
DCHECK(script_state_->GetContext() ==
script_state_->GetIsolate()->GetCurrentContext());
}
bool V0CustomElementConstructorBuilder::IsFeatureAllowed() const {
return script_state_->World().IsMainWorld();
}
bool V0CustomElementConstructorBuilder::ValidateOptions(
const AtomicString& type,
QualifiedName& tag_name,
ExceptionState& exception_state) {
DCHECK(prototype_.IsEmpty());
v8::TryCatch try_catch(script_state_->GetIsolate());
if (!script_state_->PerContextData()) {
// FIXME: This should generate an InvalidContext exception at a later point.
V0CustomElementException::ThrowException(
V0CustomElementException::kContextDestroyedCheckingPrototype, type,
exception_state);
try_catch.ReThrow();
return false;
}
if (options_->hasPrototype()) {
DCHECK(options_->prototype().IsObject());
prototype_ = options_->prototype().V8Value().As<v8::Object>();
} else {
prototype_ = v8::Object::New(script_state_->GetIsolate());
v8::Local<v8::Object> base_prototype =
script_state_->PerContextData()->PrototypeForType(
V8HTMLElement::GetWrapperTypeInfo());
if (!base_prototype.IsEmpty()) {
bool set_prototype;
if (!prototype_->SetPrototype(script_state_->GetContext(), base_prototype)
.To(&set_prototype) ||
!set_prototype) {
return false;
}
}
}
AtomicString namespace_uri = html_names::xhtmlNamespaceURI;
if (HasValidPrototypeChainFor(V8SVGElement::GetWrapperTypeInfo()))
namespace_uri = svg_names::kNamespaceURI;
DCHECK(!try_catch.HasCaught());
AtomicString local_name;
if (options_->hasExtends()) {
local_name = AtomicString(options_->extends().DeprecatedLower());
if (!Document::IsValidName(local_name)) {
V0CustomElementException::ThrowException(
V0CustomElementException::kExtendsIsInvalidName, type,
exception_state);
try_catch.ReThrow();
return false;
}
if (V0CustomElement::IsValidName(local_name)) {
V0CustomElementException::ThrowException(
V0CustomElementException::kExtendsIsCustomElementName, type,
exception_state);
try_catch.ReThrow();
return false;
}
} else {
if (namespace_uri == svg_names::kNamespaceURI) {
V0CustomElementException::ThrowException(
V0CustomElementException::kExtendsIsInvalidName, type,
exception_state);
try_catch.ReThrow();
return false;
}
local_name = type;
}
DCHECK(!try_catch.HasCaught());
tag_name = QualifiedName(g_null_atom, local_name, namespace_uri);
return true;
}
V0CustomElementLifecycleCallbacks*
V0CustomElementConstructorBuilder::CreateCallbacks() {
DCHECK(!prototype_.IsEmpty());
v8::TryCatch exception_catcher(script_state_->GetIsolate());
exception_catcher.SetVerbose(true);
v8::MaybeLocal<v8::Function> created = RetrieveCallback("createdCallback");
v8::MaybeLocal<v8::Function> attached = RetrieveCallback("attachedCallback");
v8::MaybeLocal<v8::Function> detached = RetrieveCallback("detachedCallback");
v8::MaybeLocal<v8::Function> attribute_changed =
RetrieveCallback("attributeChangedCallback");
callbacks_ = MakeGarbageCollected<V8V0CustomElementLifecycleCallbacks>(
script_state_, prototype_, created, attached, detached,
attribute_changed);
return callbacks_;
}
v8::MaybeLocal<v8::Function>
V0CustomElementConstructorBuilder::RetrieveCallback(const char* name) {
v8::Local<v8::Value> value;
if (!prototype_
->Get(script_state_->GetContext(),
V8AtomicString(script_state_->GetIsolate(), name))
.ToLocal(&value) ||
!value->IsFunction())
return v8::MaybeLocal<v8::Function>();
return v8::MaybeLocal<v8::Function>(value.As<v8::Function>());
}
bool V0CustomElementConstructorBuilder::CreateConstructor(
Document* document,
V0CustomElementDefinition* definition,
ExceptionState& exception_state) {
DCHECK(!prototype_.IsEmpty());
DCHECK(constructor_.IsEmpty());
DCHECK(document);
v8::Isolate* isolate = script_state_->GetIsolate();
v8::Local<v8::Context> context = script_state_->GetContext();
if (!PrototypeIsValid(definition->Descriptor().GetType(), exception_state))
return false;
const V0CustomElementDescriptor& descriptor = definition->Descriptor();
v8::Local<v8::String> v8_tag_name = V8String(isolate, descriptor.LocalName());
v8::Local<v8::Value> v8_type;
if (descriptor.IsTypeExtension())
v8_type = V8String(isolate, descriptor.GetType());
else
v8_type = v8::Null(isolate);
v8::Local<v8::Object> data = v8::Object::New(isolate);
V8PrivateProperty::GetSymbol(isolate, kPrivatePropertyDocument)
.Set(data, ToV8(document, context->Global(), isolate));
V8PrivateProperty::GetSymbol(isolate, kPrivatePropertyNamespaceURI)
.Set(data, V8String(isolate, descriptor.NamespaceURI()));
V8PrivateProperty::GetSymbol(isolate, kPrivatePropertyTagName)
.Set(data, v8_tag_name);
V8PrivateProperty::GetSymbol(isolate, kPrivatePropertyType)
.Set(data, v8_type);
v8::Local<v8::FunctionTemplate> constructor_template =
v8::FunctionTemplate::New(isolate);
constructor_template->SetCallHandler(ConstructCustomElement, data);
if (!constructor_template->GetFunction(context).ToLocal(&constructor_)) {
V0CustomElementException::ThrowException(
V0CustomElementException::kContextDestroyedRegisteringDefinition,
definition->Descriptor().GetType(), exception_state);
return false;
}
constructor_->SetName(v8_type->IsNull() ? v8_tag_name
: v8_type.As<v8::String>());
v8::Local<v8::String> prototype_key = V8AtomicString(isolate, "prototype");
bool has_own_property;
if (!constructor_->HasOwnProperty(context, prototype_key)
.To(&has_own_property) ||
!has_own_property) {
return false;
}
// This sets the property *value*; calling Set is safe because
// "prototype" is a non-configurable data property so there can be
// no side effects.
bool set_prototype_key;
if (!constructor_->Set(context, prototype_key, prototype_)
.To(&set_prototype_key) ||
!set_prototype_key) {
return false;
}
// This *configures* the property. DefineOwnProperty of a function's
// "prototype" does not affect the value, but can reconfigure the
// property.
bool configured_prototype;
if (!constructor_
->DefineOwnProperty(
context, prototype_key, prototype_,
v8::PropertyAttribute(v8::ReadOnly | v8::DontEnum |
v8::DontDelete))
.To(&configured_prototype) ||
!configured_prototype) {
return false;
}
v8::Local<v8::String> constructor_key =
V8AtomicString(isolate, "constructor");
v8::Local<v8::Value> constructor_prototype;
if (!prototype_->Get(context, constructor_key)
.ToLocal(&constructor_prototype)) {
return false;
}
bool set_prototype;
if (!constructor_->SetPrototype(context, constructor_prototype)
.To(&set_prototype) ||
!set_prototype) {
return false;
}
V8PrivateProperty::GetSymbol(isolate,
kPrivatePropertyIsInterfacePrototypeObject)
.Set(prototype_, v8::True(isolate));
bool configured_constructor;
if (!prototype_
->DefineOwnProperty(context, constructor_key, constructor_,
v8::DontEnum)
.To(&configured_constructor) ||
!configured_constructor) {
return false;
}
return true;
}
bool V0CustomElementConstructorBuilder::PrototypeIsValid(
const AtomicString& type,
ExceptionState& exception_state) const {
v8::Isolate* isolate = script_state_->GetIsolate();
v8::Local<v8::Context> context = script_state_->GetContext();
if (prototype_->InternalFieldCount() ||
V8PrivateProperty::GetSymbol(isolate,
kPrivatePropertyIsInterfacePrototypeObject)
.HasValue(prototype_)) {
V0CustomElementException::ThrowException(
V0CustomElementException::kPrototypeInUse, type, exception_state);
return false;
}
v8::PropertyAttribute property_attribute;
if (!prototype_
->GetPropertyAttributes(context,
V8AtomicString(isolate, "constructor"))
.To(&property_attribute) ||
(property_attribute & v8::DontDelete)) {
V0CustomElementException::ThrowException(
V0CustomElementException::kConstructorPropertyNotConfigurable, type,
exception_state);
return false;
}
return true;
}
bool V0CustomElementConstructorBuilder::DidRegisterDefinition() const {
DCHECK(!constructor_.IsEmpty());
return callbacks_->SetBinding(std::make_unique<V0CustomElementBinding>(
script_state_->GetIsolate(), prototype_));
}
ScriptValue V0CustomElementConstructorBuilder::BindingsReturnValue() const {
return ScriptValue(script_state_->GetIsolate(), constructor_);
}
bool V0CustomElementConstructorBuilder::HasValidPrototypeChainFor(
const WrapperTypeInfo* type) const {
v8::Local<v8::Object> element_prototype =
script_state_->PerContextData()->PrototypeForType(type);
if (element_prototype.IsEmpty())
return false;
v8::Local<v8::Value> chain = prototype_;
while (!chain.IsEmpty() && chain->IsObject()) {
if (chain == element_prototype)
return true;
chain = chain.As<v8::Object>()->GetPrototype();
}
return false;
}
static void ConstructCustomElement(
const v8::FunctionCallbackInfo<v8::Value>& info) {
v8::Isolate* isolate = info.GetIsolate();
if (!info.IsConstructCall()) {
V8ThrowException::ThrowTypeError(
isolate, "DOM object constructor cannot be called as a function.");
return;
}
if (info.Length() > 0) {
V8ThrowException::ThrowTypeError(
isolate, "This constructor should be called without arguments.");
return;
}
v8::Local<v8::Object> data = v8::Local<v8::Object>::Cast(info.Data());
v8::Local<v8::Value> document_value;
if (!V8PrivateProperty::GetSymbol(isolate, kPrivatePropertyDocument)
.GetOrUndefined(data)
.ToLocal(&document_value)) {
return;
}
Document* document = V8Document::ToImpl(document_value.As<v8::Object>());
v8::Local<v8::Value> namespace_uri_value;
if (!V8PrivateProperty::GetSymbol(isolate, kPrivatePropertyNamespaceURI)
.GetOrUndefined(data)
.ToLocal(&namespace_uri_value) ||
namespace_uri_value->IsUndefined()) {
return;
}
TOSTRING_VOID(V8StringResource<>, namespace_uri, namespace_uri_value);
v8::Local<v8::Value> tag_name_value;
if (!V8PrivateProperty::GetSymbol(isolate, kPrivatePropertyTagName)
.GetOrUndefined(data)
.ToLocal(&tag_name_value) ||
tag_name_value->IsUndefined()) {
return;
}
TOSTRING_VOID(V8StringResource<>, tag_name, tag_name_value);
v8::Local<v8::Value> maybe_type;
if (!V8PrivateProperty::GetSymbol(isolate, kPrivatePropertyType)
.GetOrUndefined(data)
.ToLocal(&maybe_type) ||
maybe_type->IsUndefined()) {
return;
}
TOSTRING_VOID(V8StringResource<kTreatNullAsNullString>, type, maybe_type);
ExceptionState exception_state(isolate, ExceptionState::kConstructionContext,
"CustomElement");
V0CustomElementProcessingStack::CallbackDeliveryScope delivery_scope;
Element* element = document->createElementNS(
namespace_uri, tag_name, StringOrElementCreationOptions::FromString(type),
exception_state);
if (element) {
UseCounter::Count(document, WebFeature::kV0CustomElementsConstruct);
}
V8SetReturnValueFast(info, element, document);
}
} // namespace blink
| [
"pcding@ucdavis.edu"
] | pcding@ucdavis.edu |
2ea2a4b772f35db54ab6698a347d97050cc0ad6e | b5a9d42f7ea5e26cd82b3be2b26c324d5da79ba1 | /tensorflow/compiler/xla/service/hlo_get_dimension_size_rewriter.cc | c575903581d106122194c8ec6b9fcf76d4998710 | [
"Apache-2.0"
] | permissive | uve/tensorflow | e48cb29f39ed24ee27e81afd1687960682e1fbef | e08079463bf43e5963acc41da1f57e95603f8080 | refs/heads/master | 2020-11-29T11:30:40.391232 | 2020-01-11T13:43:10 | 2020-01-11T13:43:10 | 230,088,347 | 0 | 0 | Apache-2.0 | 2019-12-25T10:49:15 | 2019-12-25T10:49:14 | null | UTF-8 | C++ | false | false | 2,954 | cc | /* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/
#include "tensorflow/compiler/xla/service/hlo_get_dimension_size_rewriter.h"
#include "absl/algorithm/container.h"
#include "tensorflow/compiler/xla/literal_util.h"
#include "tensorflow/compiler/xla/service/dynamic_dimension_inference.h"
#include "tensorflow/compiler/xla/service/hlo_instruction.h"
#include "tensorflow/compiler/xla/service/hlo_opcode.h"
#include "tensorflow/compiler/xla/service/shape_inference.h"
namespace xla {
namespace {
StatusOr<bool> ReplaceGetSize(
HloInstruction* instr,
const DynamicDimensionInference* dynamic_dimension_inference) {
if (instr->opcode() != HloOpcode::kGetDimensionSize) {
return false;
}
HloComputation* computation = instr->parent();
TF_ASSIGN_OR_RETURN(auto legal_shape,
ShapeInference::InferGetDimensionSizeShape(
instr->operand(0)->shape(), instr->dimension()));
TF_RET_CHECK(ShapeUtil::Equal(instr->shape(), legal_shape));
TF_RET_CHECK(ShapeUtil::HasPrimitiveType(instr->shape(), U32));
HloInstruction* operand = instr->mutable_operand(0);
int64 dim = instr->dimension();
HloInstruction* dynamic_size =
dynamic_dimension_inference->GetDynamicSize(operand, {}, dim);
if (dynamic_size != nullptr) {
TF_RETURN_IF_ERROR(instr->ReplaceAllUsesWith(dynamic_size));
} else {
uint32 size = instr->operand(0)->shape().dimensions(dim);
HloInstruction* new_instr = computation->AddInstruction(
HloInstruction::CreateConstant(LiteralUtil::CreateR0<uint32>(size)));
TF_RETURN_IF_ERROR(instr->ReplaceAllUsesWith(new_instr));
}
return true;
}
} // namespace
StatusOr<bool> HloGetDimensionSizeRewriter::Run(HloModule* module) {
bool changed = false;
HloProto proto;
TF_ASSIGN_OR_RETURN(DynamicDimensionInference inference,
DynamicDimensionInference::Run(module));
*proto.mutable_hlo_module() = module->ToProto();
for (auto* computation : module->computations()) {
for (auto instruction : computation->instructions()) {
TF_ASSIGN_OR_RETURN(bool replaced,
ReplaceGetSize(instruction, &inference));
changed = changed || replaced;
}
}
return changed;
}
} // namespace xla
| [
"v-grniki@microsoft.com"
] | v-grniki@microsoft.com |
acd3df9b2b143a1e5e53453799170d56396c4305 | cf7ae4ac2644daa52e0f7c5ae30c72b66d15fc7f | /dependence/opcode/OPC_MeshInterface.h | c12f5559aff1b5af1384adaf9207b4478e770834 | [] | no_license | ZHOURUIH/GameEditor | 13cebb5037a46d1c414c944b4f0229b26d859fb5 | eb391bd8c2bec8976c29047183722f90d75af361 | refs/heads/master | 2023-08-21T10:56:59.318660 | 2023-08-10T16:33:40 | 2023-08-10T16:33:40 | 133,002,663 | 18 | 21 | null | null | null | null | UTF-8 | C++ | false | false | 9,748 | h | ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*
* OPCODE - Optimized Collision Detection
* Copyright (C) 2001 Pierre Terdiman
* Homepage: http://www.codercorner.com/Opcode.htm
*/
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Contains a mesh interface.
* \file OPC_MeshInterface.h
* \author Pierre Terdiman
* \date November, 27, 2002
*/
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Include Guard
#ifndef __OPC_MESHINTERFACE_H__
#define __OPC_MESHINTERFACE_H__
struct VertexPointers
{
const Point* Vertex[3];
bool BackfaceCulling(const Point& source)
{
const Point& p0 = *Vertex[0];
const Point& p1 = *Vertex[1];
const Point& p2 = *Vertex[2];
// Compute normal direction
Point Normal = (p2 - p1)^(p0 - p1);
// Backface culling
return (Normal | (source - p0)) >= 0.0f;
}
};
#ifdef OPC_USE_CALLBACKS
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* User-callback, called by OPCODE to request vertices from the app.
* \param triangle_index [in] face index for which the system is requesting the vertices
* \param triangle [out] triangle's vertices (must be provided by the user)
* \param user_data [in] user-defined data from SetCallback()
*/
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
typedef void (*RequestCallback) (udword triangle_index, VertexPointers& triangle, void* user_data);
#endif
class OPCODE_API MeshInterface
{
public:
// Constructor / Destructor
MeshInterface();
~MeshInterface();
// Common settings
inline_ udword GetNbTriangles() const { return mNbTris; }
inline_ udword GetNbVertices() const { return mNbVerts; }
inline_ void SetNbTriangles(udword nb) { mNbTris = nb; }
inline_ void SetNbVertices(udword nb) { mNbVerts = nb; }
#ifdef OPC_USE_CALLBACKS
// Callback settings
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Callback control: setups object callback. Must provide triangle-vertices for a given triangle index.
* \param callback [in] user-defined callback
* \param user_data [in] user-defined data
* \return true if success
*/
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool SetCallback(RequestCallback callback, void* user_data);
inline_ void* GetUserData() const { return mUserData; }
inline_ RequestCallback GetCallback() const { return mObjCallback; }
#else
// Pointers settings
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Pointers control: setups object pointers. Must provide access to faces and vertices for a given object.
* \param tris [in] pointer to triangles
* \param verts [in] pointer to vertices
* \return true if success
*/
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool SetPointers(const IndexedTriangle* tris, const Point* verts);
inline_ const IndexedTriangle* GetTris() const { return mTris; }
inline_ const Point* GetVerts() const { return mVerts; }
#ifdef OPC_USE_STRIDE
// Strides settings
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Strides control
* \param tri_stride [in] size of a triangle in bytes. The first sizeof(IndexedTriangle) bytes are used to get vertex indices.
* \param vertex_stride [in] size of a vertex in bytes. The first sizeof(Point) bytes are used to get vertex position.
* \return true if success
*/
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool SetStrides(udword tri_stride=sizeof(IndexedTriangle), udword vertex_stride=sizeof(Point));
inline_ udword GetTriStride() const { return mTriStride; }
inline_ udword GetVertexStride() const { return mVertexStride; }
#endif
#endif
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Fetches a triangle given a triangle index.
* \param vp [out] required triangle's vertex pointers
* \param index [in] triangle index
*/
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
inline_ void GetTriangle(VertexPointers& vp, udword index) const
{
#ifdef OPC_USE_CALLBACKS
(mObjCallback)(index, vp, mUserData);
#else
#ifdef OPC_USE_STRIDE
const IndexedTriangle* T = (const IndexedTriangle*)(((ubyte*)mTris) + index * mTriStride);
vp.Vertex[0] = (const Point*)(((ubyte*)mVerts) + T->mVRef[0] * mVertexStride);
vp.Vertex[1] = (const Point*)(((ubyte*)mVerts) + T->mVRef[1] * mVertexStride);
vp.Vertex[2] = (const Point*)(((ubyte*)mVerts) + T->mVRef[2] * mVertexStride);
#else
const IndexedTriangle* T = &mTris[index];
vp.Vertex[0] = &mVerts[T->mVRef[0]];
vp.Vertex[1] = &mVerts[T->mVRef[1]];
vp.Vertex[2] = &mVerts[T->mVRef[2]];
#endif
#endif
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Remaps client's mesh according to a permutation.
* \param nb_indices [in] number of indices in the permutation (will be checked against number of triangles)
* \param permutation [in] list of triangle indices
* \return true if success
*/
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
inline_ bool RemapClient(udword nb_indices, const udword* permutation) const;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Checks the mesh interface is valid, i.e. things have been setup correctly.
* \return true if valid
*/
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool IsValid() const;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Checks the mesh itself is valid.
* Currently we only look for degenerate faces.
* \return number of degenerate faces
*/
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
udword CheckTopology() const;
private:
udword mNbTris; //!< Number of triangles in the input model
udword mNbVerts; //!< Number of vertices in the input model
#ifdef OPC_USE_CALLBACKS
// User callback
void* mUserData; //!< User-defined data sent to callback
RequestCallback mObjCallback; //!< Object callback
#else
// User pointers
const IndexedTriangle* mTris; //!< Array of indexed triangles
const Point* mVerts; //!< Array of vertices
#ifdef OPC_USE_STRIDE
udword mTriStride; //!< Possible triangle stride in bytes [Opcode 1.3]
udword mVertexStride; //!< Possible vertex stride in bytes [Opcode 1.3]
#endif
#endif
};
#endif //__OPC_MESHINTERFACE_H__ | [
"12345678@qq.com"
] | 12345678@qq.com |
f1239b9032615104ff496061b47aded38018ec9d | 53d94215d42c7433295ec6a5638950f10859151d | /sdaver/CSU_Base-1.2-Linux/src/csu/base/ui/abstract_ui_evaluator/evaluators/basic_evaluators/basic_container_evaluator.h | efe5f9b3c405da44c7c771da24e34e1dd4dbf8c8 | [] | no_license | pedromateo/sdaver_qtlua_v2 | d8f7cd4ed6fa7f6cd528e2848cfd5338328114d4 | 81f719f1cc34edeb625cdf473806b774712bc4fa | refs/heads/master | 2016-09-05T12:32:29.287095 | 2015-01-28T10:41:50 | 2015-01-28T10:41:50 | 16,796,732 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,721 | h | // -*- mode: c++; c-basic-offset: 4; c-basic-style: bsd; -*-
/*
* This program is free software; you can redistribute it and/or
* modify
* it under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 3.0 of
* the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
* 02111-1307 USA
*
* This file is part of the OHTu-Open Usability Evaluation Framework,
* http://sourceforge.net/projects/ohtu/
*
*/
#ifndef BASIC_CONTAINER_EVALUATOR_H
#define BASIC_CONTAINER_EVALUATOR_H
#include <csu/base/ui/abstract_ui_datamodel/abs_ui_datamodel.h>
#include <csu/base/ui/abstract_ui_evaluator/abs_ui_evaluator.h>
namespace csu {
namespace base {
namespace ui{
namespace abstract_ui_evaluator {
namespace evaluators{
namespace basic_evaluators {
using namespace csu::base::ui::abstract_ui_datamodel;
class BasicContainerEvaluator : public AbstractUIEvaluator {
public:
//Constructor
BasicContainerEvaluator();
virtual ~BasicContainerEvaluator();
//Evaluation Methods
virtual void evaluate(AbstractWidget * , AbstractUI *);
};
} //basic_evaluators
} //evaluators
} //abstract_ui_evaluator
} //ui
} //base
} //csu
#endif //BASIC_CONTAINER_EVALUATOR_H
| [
"pedromateo@um.es"
] | pedromateo@um.es |
ca135790fc1ac78fd30a15057461bba105a9e24b | 1e0ca22adee1f8c18d3a46ddea03f3e35e78cda2 | /include/graphics_engine/IGraphicsLight.h | fd1240f7059110ce9f48aaca291bb553d979857c | [] | no_license | OsipovDmitry/FreeWorldEngine | 197561d0514e9e2d0cfecaecec5394c27ee96e28 | b8a19dd7c553f12f59f7946b4f067ec8813b58df | refs/heads/master | 2020-04-17T00:55:38.739237 | 2017-08-08T13:21:11 | 2017-08-08T13:21:11 | 66,136,564 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,133 | h | #ifndef __IGRAPHICSLIGHT__
#define __IGRAPHICSLIGHT__
#include <3rdparty/glm/vec2.hpp>
#include <3rdparty/glm/vec3.hpp>
#include "IGraphicsResource.h"
namespace FreeWorldEngine {
namespace GraphicsEngine {
class IGraphicsScene;
class IGraphicsLight : public IGraphicsResource {
public:
virtual ~IGraphicsLight() {}
virtual IGraphicsScene *scene() const = 0;
enum Type {
Type_None,
Type_Diectional,
Type_Point,
Type_Spot,
Type_Count
};
virtual Type type() const = 0;
virtual glm::vec3 position() const = 0;
virtual void setPosition(const glm::vec3& value) = 0;
virtual glm::vec3 direction() const = 0;
virtual void setDirection(const glm::vec3& value) = 0;
virtual glm::vec2 attenuationRadius() const = 0;
virtual void setAttenuationRadius(const float innerRadius, const float outerRadius) = 0;
virtual glm::vec3 color() const = 0;
virtual void setColor(const glm::vec3& value) = 0;
virtual glm::vec2 spotAngles() const = 0;
virtual void setSpotAngles(const float innerAngle, const float outerAngle) = 0;
}; // class IGraphicsLight
} // namespace
} // namespace
#endif // __IGRAPHICSLIGHT__
| [
"dmitry1992osipov@yandex.ru"
] | dmitry1992osipov@yandex.ru |
c07d0a77c604c5bb70b6fcdcdb12f73a79fa063d | b633e0b76c8f0e14d83d9ec346aea2549fe2bed2 | /include/asio-httpd/posthandler.h | 0907c2a7b1ce85ee408b39b3bbc21d7cb594696b | [] | no_license | guidow/asio-httpd | 23a34d8673ace1d55df89b1b1c8b3a7f5ff754da | e3d1d9bca80c9ebdefcfc29375a25941cc7d3297 | refs/heads/master | 2020-11-28T09:35:11.270711 | 2019-12-29T14:11:08 | 2019-12-29T14:11:08 | 229,771,742 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,053 | h | #ifndef _ASIOHTTPD_POSTHANDLER_H_
#define _ASIOHTTPD_POSTHANDLER_H_
#include "handlerbase.h"
namespace asio_httpd {
class PostHandler : public HandlerBase
{
public:
PostHandler(boost::asio::io_service& io) : HandlerBase(io) {}
virtual ~PostHandler() {}
// Override the following (always both, never just one!) if you know the content length
virtual bool content_length_known();
virtual uint64_t content_length();
// Override the following if at all possible
virtual std::string content_type();
virtual bool charset_known();
virtual std::string charset();
// The default implementation will append all blocks to m_payload
// This involves copying of data and is not too efficient
// TODO: Allow handlers to provide their own buffers
virtual void add_payloadblock(std::shared_ptr<std::vector<uint8_t>> block);
// Will be called after all payload blocks have been added
virtual void set_payload_complete() = 0;
protected:
std::vector<uint8_t> m_payload;
};
}
#endif
| [
"guido@unknownsite.de"
] | guido@unknownsite.de |
1ed4c693d7287b0121d30edbe48bc57ebb742db0 | 1f17c16f3c492cc8061b4a6fa911c8897c2094c3 | /Settings.cpp | d6918ccda834a2f8558c7636777064768e0e2f34 | [] | no_license | misakshoyan/MovingDetection | 235f0d5ec36a57a3ada0c52746f76adb34ed9afe | 426d3080e8ae441a6efbc573a0da4e81a574b149 | refs/heads/master | 2020-12-26T19:24:30.997698 | 2020-02-01T12:49:45 | 2020-02-01T12:49:45 | 237,613,811 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 221 | cpp | #include "Settings.h"
#include <iostream>
Settings* Settings::s_instance = NULL;
Settings* Settings::createSettings()
{
if (s_instance == NULL) {
s_instance = new Settings();
}
return s_instance;
}
| [
"misakshoyan@gmail.com"
] | misakshoyan@gmail.com |
5adde68ba682ec9683d7b65c3814c15f49fd16e6 | d6e3150e58f78ef0c2c08f5ef4493b9951c8bb7d | /Chapter05/Practice5_1/MainFrm.cpp | 83b9d482ea53e151d361487dbbd6eaed0efcc76f | [] | no_license | SuperNova911/MFC-Class | fdba15bc6c456322bd6b758de397cebd4f305f7c | 02d53bc34626f6991ea89ce4eb6c341574a5498a | refs/heads/master | 2021-04-15T15:37:15.289858 | 2018-06-15T03:29:58 | 2018-06-15T03:29:58 | 126,199,036 | 0 | 0 | null | null | null | null | UHC | C++ | false | false | 9,207 | cpp |
// MainFrm.cpp : CMainFrame 클래스의 구현
//
#include "stdafx.h"
#include "Practice5_1.h"
#include "MainFrm.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#endif
// CMainFrame
IMPLEMENT_DYNCREATE(CMainFrame, CFrameWndEx)
const int iMaxUserToolbars = 10;
const UINT uiFirstUserToolBarId = AFX_IDW_CONTROLBAR_FIRST + 40;
const UINT uiLastUserToolBarId = uiFirstUserToolBarId + iMaxUserToolbars - 1;
BEGIN_MESSAGE_MAP(CMainFrame, CFrameWndEx)
ON_WM_CREATE()
ON_COMMAND(ID_VIEW_CUSTOMIZE, &CMainFrame::OnViewCustomize)
ON_REGISTERED_MESSAGE(AFX_WM_CREATETOOLBAR, &CMainFrame::OnToolbarCreateNew)
ON_COMMAND_RANGE(ID_VIEW_APPLOOK_WIN_2000, ID_VIEW_APPLOOK_WINDOWS_7, &CMainFrame::OnApplicationLook)
ON_UPDATE_COMMAND_UI_RANGE(ID_VIEW_APPLOOK_WIN_2000, ID_VIEW_APPLOOK_WINDOWS_7, &CMainFrame::OnUpdateApplicationLook)
END_MESSAGE_MAP()
static UINT indicators[] =
{
ID_SEPARATOR, // 상태 줄 표시기
ID_INDICATOR_POINT,
ID_INDICATOR_CAPS,
ID_INDICATOR_NUM,
ID_INDICATOR_SCRL,
};
// CMainFrame 생성/소멸
CMainFrame::CMainFrame()
{
// TODO: 여기에 멤버 초기화 코드를 추가합니다.
theApp.m_nAppLook = theApp.GetInt(_T("ApplicationLook"), ID_VIEW_APPLOOK_OFF_2003);
}
CMainFrame::~CMainFrame()
{
}
int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
if (CFrameWndEx::OnCreate(lpCreateStruct) == -1)
return -1;
BOOL bNameValid;
if (!m_wndMenuBar.Create(this))
{
TRACE0("메뉴 모음을 만들지 못했습니다.\n");
return -1; // 만들지 못했습니다.
}
m_wndMenuBar.SetPaneStyle(m_wndMenuBar.GetPaneStyle() | CBRS_SIZE_DYNAMIC | CBRS_TOOLTIPS | CBRS_FLYBY);
// 메뉴 모음을 활성화해도 포커스가 이동하지 않게 합니다.
CMFCPopupMenu::SetForceMenuFocus(FALSE);
if (!m_wndToolBar.CreateEx(this, TBSTYLE_FLAT, WS_CHILD | WS_VISIBLE | CBRS_TOP | CBRS_GRIPPER | CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC) ||
!m_wndToolBar.LoadToolBar(theApp.m_bHiColorIcons ? IDR_MAINFRAME_256 : IDR_MAINFRAME))
{
TRACE0("도구 모음을 만들지 못했습니다.\n");
return -1; // 만들지 못했습니다.
}
CString strToolBarName;
bNameValid = strToolBarName.LoadString(IDS_TOOLBAR_STANDARD);
ASSERT(bNameValid);
m_wndToolBar.SetWindowText(strToolBarName);
CString strCustomize;
bNameValid = strCustomize.LoadString(IDS_TOOLBAR_CUSTOMIZE);
ASSERT(bNameValid);
m_wndToolBar.EnableCustomizeButton(TRUE, ID_VIEW_CUSTOMIZE, strCustomize);
// 사용자 정의 도구 모음 작업을 허용합니다.
InitUserToolbars(NULL, uiFirstUserToolBarId, uiLastUserToolBarId);
if (!m_wndStatusBar.Create(this))
{
TRACE0("상태 표시줄을 만들지 못했습니다.\n");
return -1; // 만들지 못했습니다.
}
m_wndStatusBar.SetIndicators(indicators, sizeof(indicators)/sizeof(UINT));
m_wndStatusBar.SetPaneInfo(1, ID_INDICATOR_POINT, SBPS_NORMAL, 200);
// TODO: 도구 모음 및 메뉴 모음을 도킹할 수 없게 하려면 이 다섯 줄을 삭제하십시오.
m_wndMenuBar.EnableDocking(CBRS_ALIGN_ANY);
m_wndToolBar.EnableDocking(CBRS_ALIGN_ANY);
EnableDocking(CBRS_ALIGN_ANY);
DockPane(&m_wndMenuBar);
DockPane(&m_wndToolBar);
// Visual Studio 2005 스타일 도킹 창 동작을 활성화합니다.
CDockingManager::SetDockingMode(DT_SMART);
// Visual Studio 2005 스타일 도킹 창 자동 숨김 동작을 활성화합니다.
EnableAutoHidePanes(CBRS_ALIGN_ANY);
// 도구 모음 및 도킹 창 메뉴 바꾸기를 활성화합니다.
EnablePaneMenu(TRUE, ID_VIEW_CUSTOMIZE, strCustomize, ID_VIEW_TOOLBAR);
// 빠른(<Alt> 키를 누른 채 끌기) 도구 모음 사용자 지정을 활성화합니다.
CMFCToolBar::EnableQuickCustomization();
if (CMFCToolBar::GetUserImages() == NULL)
{
// 사용자 정의 도구 모음 이미지를 로드합니다.
if (m_UserImages.Load(_T(".\\UserImages.bmp")))
{
CMFCToolBar::SetUserImages(&m_UserImages);
}
}
// 메뉴 개인 설정을 활성화합니다(가장 최근에 사용한 명령).
// TODO: 사용자의 기본 명령을 정의하여 각 풀다운 메뉴에 하나 이상의 기본 명령을 포함시킵니다.
CList<UINT, UINT> lstBasicCommands;
lstBasicCommands.AddTail(ID_FILE_NEW);
lstBasicCommands.AddTail(ID_FILE_OPEN);
lstBasicCommands.AddTail(ID_FILE_SAVE);
lstBasicCommands.AddTail(ID_FILE_PRINT);
lstBasicCommands.AddTail(ID_APP_EXIT);
lstBasicCommands.AddTail(ID_EDIT_CUT);
lstBasicCommands.AddTail(ID_EDIT_PASTE);
lstBasicCommands.AddTail(ID_EDIT_UNDO);
lstBasicCommands.AddTail(ID_APP_ABOUT);
lstBasicCommands.AddTail(ID_VIEW_STATUS_BAR);
lstBasicCommands.AddTail(ID_VIEW_TOOLBAR);
lstBasicCommands.AddTail(ID_VIEW_APPLOOK_OFF_2003);
lstBasicCommands.AddTail(ID_VIEW_APPLOOK_VS_2005);
lstBasicCommands.AddTail(ID_VIEW_APPLOOK_OFF_2007_BLUE);
lstBasicCommands.AddTail(ID_VIEW_APPLOOK_OFF_2007_SILVER);
lstBasicCommands.AddTail(ID_VIEW_APPLOOK_OFF_2007_BLACK);
lstBasicCommands.AddTail(ID_VIEW_APPLOOK_OFF_2007_AQUA);
lstBasicCommands.AddTail(ID_VIEW_APPLOOK_WINDOWS_7);
CMFCToolBar::SetBasicCommands(lstBasicCommands);
return 0;
}
BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
{
if( !CFrameWndEx::PreCreateWindow(cs) )
return FALSE;
// TODO: CREATESTRUCT cs를 수정하여 여기에서
// Window 클래스 또는 스타일을 수정합니다.
return TRUE;
}
// CMainFrame 진단
#ifdef _DEBUG
void CMainFrame::AssertValid() const
{
CFrameWndEx::AssertValid();
}
void CMainFrame::Dump(CDumpContext& dc) const
{
CFrameWndEx::Dump(dc);
}
#endif //_DEBUG
// CMainFrame 메시지 처리기
void CMainFrame::OnViewCustomize()
{
CMFCToolBarsCustomizeDialog* pDlgCust = new CMFCToolBarsCustomizeDialog(this, TRUE /* 메뉴를 검색합니다. */);
pDlgCust->EnableUserDefinedToolbars();
pDlgCust->Create();
}
LRESULT CMainFrame::OnToolbarCreateNew(WPARAM wp,LPARAM lp)
{
LRESULT lres = CFrameWndEx::OnToolbarCreateNew(wp,lp);
if (lres == 0)
{
return 0;
}
CMFCToolBar* pUserToolbar = (CMFCToolBar*)lres;
ASSERT_VALID(pUserToolbar);
BOOL bNameValid;
CString strCustomize;
bNameValid = strCustomize.LoadString(IDS_TOOLBAR_CUSTOMIZE);
ASSERT(bNameValid);
pUserToolbar->EnableCustomizeButton(TRUE, ID_VIEW_CUSTOMIZE, strCustomize);
return lres;
}
void CMainFrame::OnApplicationLook(UINT id)
{
CWaitCursor wait;
theApp.m_nAppLook = id;
switch (theApp.m_nAppLook)
{
case ID_VIEW_APPLOOK_WIN_2000:
CMFCVisualManager::SetDefaultManager(RUNTIME_CLASS(CMFCVisualManager));
break;
case ID_VIEW_APPLOOK_OFF_XP:
CMFCVisualManager::SetDefaultManager(RUNTIME_CLASS(CMFCVisualManagerOfficeXP));
break;
case ID_VIEW_APPLOOK_WIN_XP:
CMFCVisualManagerWindows::m_b3DTabsXPTheme = TRUE;
CMFCVisualManager::SetDefaultManager(RUNTIME_CLASS(CMFCVisualManagerWindows));
break;
case ID_VIEW_APPLOOK_OFF_2003:
CMFCVisualManager::SetDefaultManager(RUNTIME_CLASS(CMFCVisualManagerOffice2003));
CDockingManager::SetDockingMode(DT_SMART);
break;
case ID_VIEW_APPLOOK_VS_2005:
CMFCVisualManager::SetDefaultManager(RUNTIME_CLASS(CMFCVisualManagerVS2005));
CDockingManager::SetDockingMode(DT_SMART);
break;
case ID_VIEW_APPLOOK_VS_2008:
CMFCVisualManager::SetDefaultManager(RUNTIME_CLASS(CMFCVisualManagerVS2008));
CDockingManager::SetDockingMode(DT_SMART);
break;
case ID_VIEW_APPLOOK_WINDOWS_7:
CMFCVisualManager::SetDefaultManager(RUNTIME_CLASS(CMFCVisualManagerWindows7));
CDockingManager::SetDockingMode(DT_SMART);
break;
default:
switch (theApp.m_nAppLook)
{
case ID_VIEW_APPLOOK_OFF_2007_BLUE:
CMFCVisualManagerOffice2007::SetStyle(CMFCVisualManagerOffice2007::Office2007_LunaBlue);
break;
case ID_VIEW_APPLOOK_OFF_2007_BLACK:
CMFCVisualManagerOffice2007::SetStyle(CMFCVisualManagerOffice2007::Office2007_ObsidianBlack);
break;
case ID_VIEW_APPLOOK_OFF_2007_SILVER:
CMFCVisualManagerOffice2007::SetStyle(CMFCVisualManagerOffice2007::Office2007_Silver);
break;
case ID_VIEW_APPLOOK_OFF_2007_AQUA:
CMFCVisualManagerOffice2007::SetStyle(CMFCVisualManagerOffice2007::Office2007_Aqua);
break;
}
CMFCVisualManager::SetDefaultManager(RUNTIME_CLASS(CMFCVisualManagerOffice2007));
CDockingManager::SetDockingMode(DT_SMART);
}
RedrawWindow(NULL, NULL, RDW_ALLCHILDREN | RDW_INVALIDATE | RDW_UPDATENOW | RDW_FRAME | RDW_ERASE);
theApp.WriteInt(_T("ApplicationLook"), theApp.m_nAppLook);
}
void CMainFrame::OnUpdateApplicationLook(CCmdUI* pCmdUI)
{
pCmdUI->SetRadio(theApp.m_nAppLook == pCmdUI->m_nID);
}
BOOL CMainFrame::LoadFrame(UINT nIDResource, DWORD dwDefaultStyle, CWnd* pParentWnd, CCreateContext* pContext)
{
// 기본 클래스가 실제 작업을 수행합니다.
if (!CFrameWndEx::LoadFrame(nIDResource, dwDefaultStyle, pParentWnd, pContext))
{
return FALSE;
}
// 모든 사용자 도구 모음에 사용자 지정 단추를 활성화합니다.
BOOL bNameValid;
CString strCustomize;
bNameValid = strCustomize.LoadString(IDS_TOOLBAR_CUSTOMIZE);
ASSERT(bNameValid);
for (int i = 0; i < iMaxUserToolbars; i ++)
{
CMFCToolBar* pUserToolbar = GetUserToolBarByIndex(i);
if (pUserToolbar != NULL)
{
pUserToolbar->EnableCustomizeButton(TRUE, ID_VIEW_CUSTOMIZE, strCustomize);
}
}
return TRUE;
}
| [
"suwhan77@naver.com"
] | suwhan77@naver.com |
75e777a79b411cc516f193b280d8230310b408f7 | 0d0e78c6262417fb1dff53901c6087b29fe260a0 | /scf/include/tencentcloud/scf/v20180416/model/PublishVersionResponse.h | 68e0d8757cd097a06d462dea3379a140e6d1fc6e | [
"Apache-2.0"
] | permissive | li5ch/tencentcloud-sdk-cpp | ae35ffb0c36773fd28e1b1a58d11755682ade2ee | 12ebfd75a399ee2791f6ac1220a79ce8a9faf7c4 | refs/heads/master | 2022-12-04T15:33:08.729850 | 2020-07-20T00:52:24 | 2020-07-20T00:52:24 | 281,135,686 | 1 | 0 | Apache-2.0 | 2020-07-20T14:14:47 | 2020-07-20T14:14:46 | null | UTF-8 | C++ | false | false | 6,456 | h | /*
* Copyright (c) 2017-2019 THL A29 Limited, a Tencent company. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef TENCENTCLOUD_SCF_V20180416_MODEL_PUBLISHVERSIONRESPONSE_H_
#define TENCENTCLOUD_SCF_V20180416_MODEL_PUBLISHVERSIONRESPONSE_H_
#include <string>
#include <vector>
#include <map>
#include <tencentcloud/core/AbstractModel.h>
namespace TencentCloud
{
namespace Scf
{
namespace V20180416
{
namespace Model
{
/**
* PublishVersion返回参数结构体
*/
class PublishVersionResponse : public AbstractModel
{
public:
PublishVersionResponse();
~PublishVersionResponse() = default;
CoreInternalOutcome Deserialize(const std::string &payload);
/**
* 获取函数的版本
* @return FunctionVersion 函数的版本
*/
std::string GetFunctionVersion() const;
/**
* 判断参数 FunctionVersion 是否已赋值
* @return FunctionVersion 是否已赋值
*/
bool FunctionVersionHasBeenSet() const;
/**
* 获取代码大小
* @return CodeSize 代码大小
*/
int64_t GetCodeSize() const;
/**
* 判断参数 CodeSize 是否已赋值
* @return CodeSize 是否已赋值
*/
bool CodeSizeHasBeenSet() const;
/**
* 获取最大可用内存
* @return MemorySize 最大可用内存
*/
int64_t GetMemorySize() const;
/**
* 判断参数 MemorySize 是否已赋值
* @return MemorySize 是否已赋值
*/
bool MemorySizeHasBeenSet() const;
/**
* 获取函数的描述
* @return Description 函数的描述
*/
std::string GetDescription() const;
/**
* 判断参数 Description 是否已赋值
* @return Description 是否已赋值
*/
bool DescriptionHasBeenSet() const;
/**
* 获取函数的入口
* @return Handler 函数的入口
*/
std::string GetHandler() const;
/**
* 判断参数 Handler 是否已赋值
* @return Handler 是否已赋值
*/
bool HandlerHasBeenSet() const;
/**
* 获取函数的超时时间
* @return Timeout 函数的超时时间
*/
int64_t GetTimeout() const;
/**
* 判断参数 Timeout 是否已赋值
* @return Timeout 是否已赋值
*/
bool TimeoutHasBeenSet() const;
/**
* 获取函数的运行环境
* @return Runtime 函数的运行环境
*/
std::string GetRuntime() const;
/**
* 判断参数 Runtime 是否已赋值
* @return Runtime 是否已赋值
*/
bool RuntimeHasBeenSet() const;
/**
* 获取函数的命名空间
* @return Namespace 函数的命名空间
*/
std::string GetNamespace() const;
/**
* 判断参数 Namespace 是否已赋值
* @return Namespace 是否已赋值
*/
bool NamespaceHasBeenSet() const;
private:
/**
* 函数的版本
*/
std::string m_functionVersion;
bool m_functionVersionHasBeenSet;
/**
* 代码大小
*/
int64_t m_codeSize;
bool m_codeSizeHasBeenSet;
/**
* 最大可用内存
*/
int64_t m_memorySize;
bool m_memorySizeHasBeenSet;
/**
* 函数的描述
*/
std::string m_description;
bool m_descriptionHasBeenSet;
/**
* 函数的入口
*/
std::string m_handler;
bool m_handlerHasBeenSet;
/**
* 函数的超时时间
*/
int64_t m_timeout;
bool m_timeoutHasBeenSet;
/**
* 函数的运行环境
*/
std::string m_runtime;
bool m_runtimeHasBeenSet;
/**
* 函数的命名空间
*/
std::string m_namespace;
bool m_namespaceHasBeenSet;
};
}
}
}
}
#endif // !TENCENTCLOUD_SCF_V20180416_MODEL_PUBLISHVERSIONRESPONSE_H_
| [
"zhiqiangfan@tencent.com"
] | zhiqiangfan@tencent.com |
ff3bbb92d2d4ef2836795daa7fe1a6acb01c6e02 | c7e688da8112c484c59a1560bfde129637f9abe0 | /Project 1/file_reverse/file_reverse.cpp | 29f202b18115ee9ccb2db791d2a2d4d36774823e | [] | no_license | nichilstewart/CS104-Projects | 024ff775afa960a982004af1af857086b2985882 | 4f03066d1bc419583c1416150dcacdce7a444d17 | refs/heads/master | 2023-01-04T05:20:23.450780 | 2020-10-31T02:56:08 | 2020-10-31T02:56:08 | 250,409,372 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,360 | cpp | #include <iostream>
#include <cstdlib>
#include <cstring>
#include <fstream>
using namespace std;
int main(int argc, char* argv[])
{
if (argc < 2)
{
//Wrong number of arguments
cout << "Please enter correct number of arguments" << endl;
return 1;
}
ifstream in_file;
//stream to open
in_file.open(argv[1]);
//open file
if (in_file.fail())
{
//Failed to read file
cout << "Sorry, file reading failed" << endl;
return 1;
}
int char_count;
in_file >> char_count;
//read character count from file
if (in_file.fail())
{
//Not an integer
cout << "Not an integer!" << endl;
return 1;
}
char* sentence = new char[char_count + 1];
//Dynamically allocate char* array
int i = 0;
//Set increment variable
while(!in_file.eof() && i < char_count + 1)
{
in_file.get(sentence[i]); //Read single character from file to array
i++; //Will also replicate spaces, tabs, linebreaks
}
for(i = char_count; i >= 0; i--)
{
cout << sentence[i];
//Output to terminal
}
delete [] sentence;
//Wipe memory
in_file.close();
//close stream
}
| [
"noreply@github.com"
] | nichilstewart.noreply@github.com |
cd91d3cd6ec937a398680cb816315f30e5e80403 | 16d159d6d3fe69d513717caad3e2c21320f93224 | /AtCoder/ABC/ABC101-150/abc142/abc142d.cpp | e6ebdb66777dc5d9a45efb1ec9d82858cbadabed | [] | no_license | tsushiy/competitive-programming-submissions | d4f068a5157c0de0f1822367e0ca66dd978e43f9 | 9011d855d9252134179cc9cc8f328f6e0ca32407 | refs/heads/master | 2023-04-11T08:34:01.015316 | 2021-04-11T15:16:17 | 2021-04-11T15:17:35 | 175,807,862 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,552 | cpp | #include <bits/stdc++.h>
using namespace std;
#define REP(i,b,e) for(int i=(b);i<(e);++i)
#define RREP(i,b,e) for(int i=(b)-1;i>=e;--i)
#define rep(i,e) for(int i=0;i<(e);++i)
constexpr int MOD = 1000000007;
constexpr int INF = 1LL << 30;
constexpr long long LLINF = 1LL << 60;
constexpr double EPS = 1e-9;
struct Initializer {
Initializer() {
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(15) << boolalpha;
}
} initializer;
template<typename T>
istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec) is >> x;
return is;
}
template<typename T>
ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (auto it = vec.begin(); it != vec.end(); ++it) {
if (it != vec.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template<typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &pa) {
return os << "(" << pa.first << ", " << pa.second << ")";
}
template<typename T>
ostream &operator<<(ostream &os, const set<T> &se) {
os << "{";
for (auto it = se.begin(); it != se.end(); ++it) {
if (it != se.begin()) os << ", ";
os << *it;
}
return os << "}";
}
template<typename T, typename U>
ostream &operator<<(ostream &os, const map<T, U> &ma) {
os << "{";
for (auto it = ma.begin(); it != ma.end(); ++it) {
if (it != ma.begin()) os << ", ";
os << it->first << ": " << it->second;
}
return os << "}";
}
inline void print(void) { cout<<'\n'; }
template<class T> inline void print(const T &x) { cout<<x<<'\n'; }
template<class T, class... U> inline void print(const T &x, const U&... y) { cout<<x<<" "; print(y...); }
#define dump(...) cout<<#__VA_ARGS__<<": [L_"<<__LINE__<<"]"<<'\n'; print(__VA_ARGS__);cout<<'\n';
template<class T, class U>inline bool chmax(T &a, const U &b) { if(a<b){ a=b; return 1; } return 0; }
template<class T, class U>inline bool chmin(T &a, const U &b) { if(b<a){ a=b; return 1; } return 0; }
// naive check O(sqrt(N))
inline bool is_prime(long long x) {
if (x <= 1) return false;
for (long long i = 2; i*i <= x; ++i) if (x % i == 0) return false;
return true;
}
/**
* @brief Sieve of Eratosthenes
* @note List primes O(NloglogN)
*/
vector<int> sieve_of_eratosthenes(int n = 200010) {
vector<bool> is_prime(n+1, true);
is_prime[0] = is_prime[1] = false;
for (int i = 0; i <= n; ++i) if (is_prime[i]) {
for (int j = i+i; j <= n; j+=i) is_prime[j] = false;
}
vector<int> primes;
for (int i = 2; i <= n; ++i) if (is_prime[i]) primes.push_back(i);
return primes;
}
/**
* @brief Prime Factorization
* @note prime table up to sqrt(N) is enough to factorize.
* @note O(sqrt(N))
*/
map<long long, int> prime_factorize(long long n, const vector<int> &primes) {
map<long long, int> prime_factor;
for (int p : primes) {
if (n < (long long) p * p) break;
while (n % p == 0) {
prime_factor[p] += 1;
n /= p;
}
}
if (n != 1) prime_factor[n] += 1;
return prime_factor;
}
/**
* @brief List divisors
*/
vector<long long> calc_divisors(long long n, const map<long long, int> &prime_factor) {
vector<long long> divisors(1, 1);
for (auto it : prime_factor) {
long long p; int k;
tie(p, k) = it;
int size = divisors.size();
for (int i = 0; i < k; ++i) {
for (int j = 0; j < size; ++j) divisors.push_back(divisors[i*size+j] * p);
}
}
sort(divisors.begin(), divisors.end());
return divisors;
}
template<typename T>
T gcd(T a, T b) {
while (a) {
b %= a;
swap(a, b);
}
return b;
}
/**
* @note Be careful of overflow
*/
template<typename T>
T lcm(T a, T b) {
T ret = a / gcd(a, b) * b;
if (b <= numeric_limits<T>::max() / (a / gcd(a, b))) return ret;
else return numeric_limits<T>::max();
}
int main() {
long long a, b; cin>>a>>b;
//print(a, b);
auto primes = sieve_of_eratosthenes(2000000);
auto prime_factor_a = prime_factorize(a, primes);
auto prime_factor_b = prime_factorize(b, primes);
auto divisors_a = calc_divisors(a, prime_factor_a);
auto divisors_b = calc_divisors(b, prime_factor_b);
//print(divisors_a);
//print(divisors_b);
vector<long long> common;
int i = 0, j = 0;
while (i < divisors_a.size() && j < divisors_b.size()) {
if (divisors_a[i] == divisors_b[j]) {
common.push_back(divisors_a[i]);
++i; ++j;
} else if (divisors_a[i] < divisors_b[j]) {
++i;
} else {
++j;
}
}
//print(common);
long long ans = 1;
rep(i, common.size()) if (is_prime(common[i])) ++ans;
print(ans);
return 0;
}
| [
"28962399+tsushiy@users.noreply.github.com"
] | 28962399+tsushiy@users.noreply.github.com |
a349923c0091d25e453ebf582b03ce3f3467ed13 | 4b31f168b85401933b80e4d92eed3d51521b75fd | /lesson-01-hello-world-in-wt/FactoryHelloWorldWebsite.cpp | 4b7be0bced6b23a900496ca6b4c5aeaceb53e8b4 | [] | no_license | lyase/witty-tutorial | 9797ee05a67b0d9efa6951a09be00802b6aa1d62 | 8338d461f803768df20c25e33aa243f0115c2588 | refs/heads/master | 2021-01-16T17:40:35.260662 | 2015-02-11T06:54:11 | 2015-02-11T06:54:11 | 4,239,061 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,872 | cpp | /** \file FactoryHelloWorldWebsite.hpp
*implementation of the HelloFactory factory a Factory that manages a web site saying hello
*\n
*\version 1.0
*\date 31/05/12 10:06:50
* Revision: none
* Compiler: gcc
*
*\author: lyase.d, lyase.d@gmail.com
* Company:
*
* =====================================================================================
*/
#include <Wt/WObject>
#include "FactoryHelloWorldWebsite.hpp"
#include <Wt/WApplication>
#include"IWebPageFactory.h"
#include "InputWindow.hpp"
#include "SayWindow.hpp"
#include "AdminWindow.hpp"
#include "MainWindow.hpp"
#include <iostream>
FactoryHelloWorldWebsite::FactoryHelloWorldWebsite(Wt::WObject* parent) : Wt::WObject(parent)
{
std::cout<< " creating helloFactory a concrete WebPageFactory\n";
}
FactoryHelloWorldWebsite::~FactoryHelloWorldWebsite()
{
std::cout<<"destroying a helloFactory\n";
}
WebPage_codeName FactoryHelloWorldWebsite::hashit (std::string const& inString)
{
if (inString == "/ask") return ask;
if (inString == "/say") return say;
if (inString == "/admin") return admin;
/* default page will be the landing the MainWindow*/
return landing;
}
void FactoryHelloWorldWebsite::createWebPage(const std::string newPath, Wt::WContainerWidget* aroot )
{
// we are using an enum you can add more pages here but best implementation with a Map
// see https://github.com/matiu2/witty-plus/blob/master/wittyPlus/base/URLs.hpp
Wt::WApplication::instance()->log("info") << "Create web page called: " << newPath;
switch (hashit(newPath)) {
case ask:
new InputWindow(aroot);
break;
case say:
new SayWindow(aroot);
break;
case admin:
new AdminWindow(aroot);
break;
case landing:
new MainWindow(aroot);
break;
}
}
| [
"lyase.d@gmail.com"
] | lyase.d@gmail.com |
526624a2d10864693087eb47793f4a6f4330dfb2 | 5edff52141bb25c0fdf8cb55c66f2df71d3f00b9 | /27. 31.03.2021 - Сканирование папок/Home work/Project1/Project1/task2.cpp | 6d23988b2fc203efd4ad61b8bb9d6abe4d61f0c1 | [] | no_license | MikhailGoriachev/C-C | 78e9597e3b5dce6b4086ddf9056545b49af8f462 | 3ef464aa030788c21c49d1d3983a7b5330250b02 | refs/heads/master | 2023-08-25T18:48:26.464614 | 2021-10-20T10:24:20 | 2021-10-20T10:24:20 | 419,278,130 | 0 | 0 | null | null | null | null | WINDOWS-1251 | C++ | false | false | 8,111 | cpp | #define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <io.h>
#include <conio.h>
using namespace std;
// сканирование папок и подпапок
void scanFile(char* dir, unsigned long* min_size, unsigned long* count)
{
// добавка к пути '\'
strcat(dir, "\\");
// указатель на начало имени в пути
char* name = dir + strlen(dir);
// имени присвается маска '*'
strcpy(name, "*");
// список файлов
_finddata_t list;
// указатель на список и создание заполнение списка файлов
long point = _findfirst(dir, &list);
// сканирование списка
do
{
// если файл является папкой с именем "." или ".."
if ((list.attrib & _A_SUBDIR) && (!strcmp(list.name, ".") || !strcmp(list.name, "..")))
continue;
// переменная для счётчика
int* i = new int;
// вывод сивола '>' по числу уровня папки
for (*i = 0; *i < *(count + 9); ++*i)
{
cout << "|";
}
// отчистка памяти
delete i;
// добавка имени текущего файла к пути
strcpy(name, list.name);
// вывод имени файла
cout << list.name << " ";
// если файл является папкой
if (list.attrib & _A_SUBDIR)
{
// вывод атрибута
cout << "<DIR>" << endl;
// увеличение счётчика количества подпапок
++*count;
// увеличение уровня папки
++* (count + 9);
// запуск этой же функции
scanFile(dir, min_size, count);
// уменьшение уровня папки
--* (count + 9);
continue;
}
// если файл
else
{
// вывод размера файла
cout << list.size << endl;
// увеличение счётчика всех файлов
++*(count + 1);
// прибавление размера текущего файла к общей сумме всех файлов
*(count + 2) += list.size;
// если размер файла меньше требуемого минимального размера
if (list.size < *min_size)
{
// увеличение счётчика файлов размер, которых меньше требуемого минимального размера
++*(count + 3);
// прибавление размера текущего файла к общему размеру всех файлов, размер которых меньше
// минимума
++* (count + 4) += list.size;
// удаление файла; если файл удалён неудачно
if (remove(dir) == -1)
{
// увеличение счётчика количетсва неудачно удалённых файлов
++* (count + 7);
// прибавление размера файла к общему размеру всех неудачно удалённых файлов
*(count + 8) += list.size;
continue;
}
// увеличение счётчика количества удачно удалённых файлов
++*(count + 5);
// прибавление размера файла к общему размеру всех удачно удалённых файлов
*(count + 6) += list.size;
}
}
} while (!_findnext(point, &list));
// удаление списка
_findclose(point);
}
void task2()
{
// 2. Пользователь вводит путь к папке и размер файлов,
// программа сканирует папку и подпапки и удаляет все файлы,
// которые меньше указанного размера(использовать функцию remove(filename))
// путь к папке
char* dir = new char[_MAX_PATH];
// ввод пути
cout << "Enter folder path: ";
cin.ignore();
cin.getline(dir, _MAX_PATH);
cout << endl;
// минимальный размер файла
unsigned long* min_size = new unsigned long;
// ввод минимального размера файла
cout << "Enter minimum size: ";
cin >> *min_size;
// ожилание нажатия любой клавиши
cout << "\n\n\n\n\nPRESS ANY KEY TO START...";
// нажатие любой клавиши
_getch();
// отчистка консоли
system("cls");
// счётчики: [0] - всего подпапок; [1] - всего файлов; [2] - общий размер всех фалов;
// [3] - количество файлов меньше минимального размера; [4] - размер файлов меньше
// минимального размера; [5] - количество удачно удалёных файлов; [6] - размер удачно
// удалённых файлов; [7] - количество неудачно удалённых файлов; [8] - размер неудачно
// удалённых файлов; [9] - уровень папки;
unsigned long* count = new unsigned long[10];
// [0] - всего подпапок
*count = 0;
// [1] - всего файлов
*(count + 1) = 0;
// [2] - общий размер всех фалов
*(count + 2) = 0;
// [3] - количество файлов меньше минимального размера
*(count + 3) = 0;
// [4] - размер файлов меньше минимального размера
*(count + 4) = 0;
// [5] - количество удачно удалёных файлов
*(count + 5) = 0;
// [6] - размер удачно удалённых файлов
*(count + 6) = 0;
// [7] - количество неудачно удалённых файлов
*(count + 7) = 0;
// [8] - размер неудачно удалённых файлов
*(count + 8) = 0;
// [9] - уровень папки
*(count + 9) = 0;
// запуск функии сканирования
scanFile(dir, min_size, count);
// ожидание нажатия любой клавиши для вывод отчёта
cout << "\n\n\n\n\nPRESS ANY KEY TO OUTPUT THE REPORT..." << endl;
// ожилание нажатия клавиши
_getch();
// отчистка консоли
system("cls");
// вывод отчёта о выполнении
cout << " REPORT " << endl << endl;
cout << "> Count all subdir: " << *count << endl << endl;
// вывод количетсва всех файлов
cout << "> Count all file: " << *(count + 1) << endl;
// вывод общего размера всех файлов
cout << "> Size all files: " << *(count + 2) << endl << endl;
// вывод количетсва файлов размер, которых меньше минимально требуемого
cout << "> Count files size less minimum: " << *(count + 3) << endl;
// размер всех файлов размер, которых меньше минимально требуемого
cout << "> Size all files size less minimum: " << *(count + 4) << endl << endl;
// количество удачно удалённых файлов
cout << "> Count of successfully delete files: " << *(count + 5) << endl;
// размер удачно удалённых файлов
cout << "> Size all successfully delete files: " << *(count + 6) << endl << endl;
// количество неудачно удалённых файлов
cout << "> Count of unsuccessfully delete files: " << *(count + 7) << endl;
// размер неудачно удалённых файлов
cout << "> Size all unsuccessfully delete files: " << *(count + 8) << endl << endl;
// отчистка памяти
delete[] dir;
delete count;
// ожидание нажатия любой клавиши для выхода из программы
cout << "\n\n\n\n\nPRESS ANY KEY TO EXIT..." << endl;
_getch();
} | [
"mishagor228@gmail.com"
] | mishagor228@gmail.com |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.