file_name
stringlengths 3
137
| prefix
stringlengths 0
918k
| suffix
stringlengths 0
962k
| middle
stringlengths 0
812k
|
|---|---|---|---|
delete.go
|
/*
* Tencent is pleased to support the open source community by making Blueking Container Service available.
* Copyright (C) 2019 THL A29 Limited, a Tencent company. All rights reserved.
* Licensed under the MIT License (the "License"); you may not use this file except
* in compliance with the License. You may obtain a copy of the License at
* http://opensource.org/licenses/MIT
* Unless required by applicable law or agreed to in writing, software distributed under
* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
* either express or implied. See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package delete
import (
"bk-bcs/bcs-services/bcs-client/cmd/utils"
"github.com/urfave/cli"
)
//NewDeleteCommand delete sub command
func NewDeleteCommand() cli.Command {
return cli.Command{
Name: "delete",
Usage: "delete app/process/taskgroup/configmap/service/secret/deployment",
Flags: []cli.Flag{
cli.StringFlag{
Name: "type, t",
Usage: "Delete type, app/taskgroup/configmap/service/secret/deployment/crd",
},
cli.StringFlag{
Name: "name, n",
Usage: "resource name",
},
cli.StringFlag{
Name: "namespace, ns",
Usage: "Namespace",
Value: "defaultGroup",
},
cli.StringFlag{
Name: "clusterid",
Usage: "Cluster ID",
},
cli.StringFlag{
Name: "enforce",
Usage: "delete forcibly (1) or not (0)",
Value: "0",
},
},
Action: func(c *cli.Context) error {
return deleteF(utils.NewClientContext(c))
},
}
}
func
|
(c *utils.ClientContext) error {
if err := c.MustSpecified(utils.OptionType); err != nil {
return err
}
resourceType := c.String(utils.OptionType)
switch resourceType {
case "app", "application":
return deleteApplication(c)
case "process":
return deleteProcess(c)
case "configmap":
return deleteConfigMap(c)
case "secret":
return deleteSecret(c)
case "service":
return deleteService(c)
case "deploy", "deployment":
return deleteDeployment(c)
case "crd", "customresourcedefinition":
return deleteCustomResourceDefinition(c)
default:
//unkown type, try Custom Resource
return deleteCustomResource(c)
}
}
|
deleteF
|
bam2wiggle.py
|
"""bam2wiggle.py - convert bam to wig/bigwig file
==============================================
:Tags: Genomics NGS Intervals Conversion BAM WIGGLE BIGWIG BEDGRAPH
Purpose
-------
convert a bam file to a bigwig or bedgraph file.
Depending on options chosen, this script either computes the densities
itself or makes use of faster solutions if possible. The script
requires the executables :file:`wigToBigWig` and :file:`bedToBigBed`
to be in the user's PATH.
If no --shift-size or --extend option are given, the coverage is computed
directly on reads. Counting can be performed at a certain resolution.
The counting currently is not aware of spliced reads, i.e., an
inserted intron will be included in the coverage.
If --shift-size or --extend are given, the coverage is computed by shifting
read alignment positions upstream for positive strand reads or
downstream for negative strand reads and extend them by a fixed
amount.
For RNASEQ data it might be best to run genomeCoverageBed directly on
the bam file.
Usage
-----
Type::
cgat bam2wiggle \
--output-format=bigwig \
--output-filename-pattern=out.bigwig in.bam
to convert the :term:`bam` file file:`in.bam` to :term:`bigwig` format
and save the result in :file:`out.bigwig`.
Command line options
--------------------
"""
import os
import sys
import tempfile
import shutil
|
import subprocess
import cgatcore.experiment as E
import pysam
import cgatcore.iotools as iotools
from cgat.BamTools.bamtools import merge_pairs
class SpanWriter(object):
'''output values within spans.
values are collected according to a span and an average is
output.
'''
def __init__(self, span):
self.span = span
self.laststart = 0
self.lastend = None
self.val = 0
self.lastout = None
def __call__(self, outfile, contig, start, end, val):
# deal with previous window
if self.lastend:
last_window_start = self.lastend - self.lastend % self.span
last_window_end = last_window_start + self.span
else:
last_window_start = start - start % self.span
last_window_end = start + self.span
# print start, end, val, last_window_start, last_window_end
if self.lastend and start > last_window_end:
# no overlap, output previous span
assert self.lastout != last_window_start, \
("start=%i, end=%i, laststart=%i, "
"lastend=%i, last_window_start=%i") % \
(start, end, self.laststart,
self.lastend, last_window_start)
self.lastout = last_window_start
v = self.val / float(self.span)
outfile.write("%i\t%f\n" % (last_window_start, v))
self.val = 0
last_window_start = start - start % self.span
last_window_end = start + self.span
if end < last_window_end:
# window too small to output, simply add values
self.val += val * (end - start)
self.lastend = max(end, self.lastend)
else:
# output first window
v = self.val + val * \
(self.span - start % self.span) / float(self.span)
s = last_window_start
assert self.lastout != s, \
"start=%i, end=%i, laststart=%i, lastend=%i, s=%i" % \
(start, end, self.laststart, self.lastend, s)
outfile.write("%i\t%f\n" % (s, v))
self.lastout = s
self.val = 0
# Output middle windows
for x in range(start + self.span - start % self.span,
end - self.span, self.span):
assert self.lastout != x
outfile.write("%i\t%f\n" % (x, val))
self.lastout = x
if end % self.span:
# save rest
self.lastend = end
self.val = val * end % self.span
elif end - self.span != last_window_start:
# special case, end ends on window
assert self.lastout != end - self.span, \
"start=%i, end=%i, laststart=%i, lastend=%i" % \
(start, end, self.laststart, self.lastend)
self.lastout = end - self.span
outfile.write("%i\t%f\n" % (end - self.span, val))
self.lastend = None
else:
# special case, end ends on window and only single
# window - already output as start
self.lastend = None
def flush(self, outfile):
if self.lastend:
outfile.write("%i\t%f\n" % (
self.lastend - self.lastend % self.span,
self.val / (self.lastend % self.span)))
def main(argv=None):
"""script main.
"""
if not argv:
argv = sys.argv
# setup command line parser
parser = E.ArgumentParser(description=__doc__)
parser.add_argument("--version", action='version', version="1.0")
parser.add_argument("-o", "--output-format", dest="output_format",
type=str,
choices=("bedgraph", "wiggle", "bigbed",
"bigwig", "bed"),
help="output format [default=%default]")
parser.add_argument("-s", "--shift-size", dest="shift", type=int,
help="shift reads by a certain amount (ChIP-Seq) "
)
parser.add_argument("-e", "--extend", dest="extend", type=int,
help="extend reads by a certain amount "
"(ChIP-Seq) ")
parser.add_argument("-p", "--wiggle-span", dest="span", type=int,
help="span of a window in wiggle tracks "
)
parser.add_argument("-m", "--merge-pairs", dest="merge_pairs",
action="store_true",
help="merge paired-ended reads into a single "
"bed interval [default=%default].")
parser.add_argument("--scale-base", dest="scale_base", type=float,
help="number of reads/pairs to scale bigwig file to. "
"The default is to scale to 1M reads ")
parser.add_argument("--scale-method", dest="scale_method", type=str,
choices=("none", "reads",),
help="scale bigwig output. 'reads' will normalize by "
"the total number reads in the bam file that are used "
"to construct the bigwig file. If --merge-pairs is used "
"the number of pairs output will be used for "
"normalization. 'none' will not scale the bigwig file")
parser.add_argument("--max-insert-size", dest="max_insert_size",
type=int,
help="only merge if insert size less that "
"# bases. 0 turns of this filter ")
parser.add_argument("--min-insert-size", dest="min_insert_size",
type=int,
help="only merge paired-end reads if they are "
"at least # bases apart. "
"0 turns of this filter.")
parser.set_defaults(
samfile=None,
output_format="wiggle",
shift=0,
extend=0,
span=1,
merge_pairs=None,
min_insert_size=0,
max_insert_size=0,
scale_method='none',
scale_base=1000000,
)
# add common options (-h/--help, ...) and parse command line
(args, unknown) = E.start(parser, argv=argv, add_output_options=True, unknowns=True)
if len(unknown) >= 1:
args.samfile = unknown[0]
if len(unknown) == 2:
args.output_filename_pattern = unknown[1]
if not args.samfile:
raise ValueError("please provide a bam file")
# Read BAM file using Pysam
samfile = pysam.AlignmentFile(args.samfile, "rb")
# Create temporary files / folders
tmpdir = tempfile.mkdtemp()
E.debug("temporary files are in %s" % tmpdir)
tmpfile_wig = os.path.join(tmpdir, "wig")
tmpfile_sizes = os.path.join(tmpdir, "sizes")
# Create dictionary of contig sizes
contig_sizes = dict(list(zip(samfile.references, samfile.lengths)))
# write contig sizes
outfile_size = iotools.open_file(tmpfile_sizes, "w")
for contig, size in sorted(contig_sizes.items()):
outfile_size.write("%s\t%s\n" % (contig, size))
outfile_size.close()
# Shift and extend only available for bigwig format
if args.shift or args.extend:
if args.output_format != "bigwig":
raise ValueError(
"shift and extend only available for bigwig output")
# Output filename required for bigwig / bigbed computation
if args.output_format == "bigwig":
if not args.output_filename_pattern:
raise ValueError(
"please specify an output file for bigwig computation.")
# Define executable to use for binary conversion
if args.output_format == "bigwig":
executable_name = "wigToBigWig"
else:
raise ValueError("unknown output format `%s`" %
args.output_format)
# check required executable file is in the path
executable = iotools.which(executable_name)
if not executable:
raise OSError("could not find %s in path." % executable_name)
# Open outout file
outfile = iotools.open_file(tmpfile_wig, "w")
E.info("starting output to %s" % tmpfile_wig)
else:
outfile = iotools.open_file(tmpfile_wig, "w")
E.info("starting output to stdout")
# Set up output write functions
if args.output_format in ("wiggle", "bigwig"):
# wiggle is one-based, so add 1, also step-size is 1, so need
# to output all bases
if args.span == 1:
outf = lambda outfile, contig, start, end, val: \
outfile.write(
"".join(["%i\t%i\n" % (x, val)
for x in range(start + 1, end + 1)]))
else:
outf = SpanWriter(args.span)
elif args.output_format == "bedgraph":
# bed is 0-based, open-closed
outf = lambda outfile, contig, start, end, val: \
outfile.write("%s\t%i\t%i\t%i\n" % (contig, start, end, val))
# initialise counters
ninput, nskipped, ncontigs = 0, 0, 0
# set output file name
output_filename_pattern = args.output_filename_pattern
if output_filename_pattern:
output_filename = os.path.abspath(output_filename_pattern)
# shift and extend or merge pairs. Output temporay bed file
if args.shift > 0 or args.extend > 0 or args.merge_pairs:
# Workflow 1: convert to bed intervals and use bedtools
# genomecov to build a coverage file.
# Convert to bigwig with UCSC tools bedGraph2BigWig
if args.merge_pairs:
# merge pairs using bam2bed
E.info("merging pairs to temporary file")
counter = merge_pairs(
samfile,
outfile,
min_insert_size=args.min_insert_size,
max_insert_size=args.max_insert_size,
bed_format=3)
E.info("merging results: {}".format(counter))
if counter.output == 0:
raise ValueError("no pairs output after merging")
else:
# create bed file with shifted/extended tags
shift, extend = args.shift, args.extend
shift_extend = shift + extend
counter = E.Counter()
for contig in samfile.references:
E.debug("output for %s" % contig)
lcontig = contig_sizes[contig]
for read in samfile.fetch(contig):
pos = read.pos
if read.is_reverse:
start = max(0, read.pos + read.alen - shift_extend)
else:
start = max(0, read.pos + shift)
# intervals extending beyond contig are removed
if start >= lcontig:
continue
end = min(lcontig, start + extend)
outfile.write("%s\t%i\t%i\n" % (contig, start, end))
counter.output += 1
outfile.close()
if args.scale_method == "reads":
scale_factor = float(args.scale_base) / counter.output
E.info("scaling: method=%s scale_quantity=%i scale_factor=%f" %
(args.scale_method,
counter.output,
scale_factor))
scale = "-scale %f" % scale_factor
else:
scale = ""
# Convert bed file to coverage file (bedgraph)
tmpfile_bed = os.path.join(tmpdir, "bed")
E.info("computing coverage")
# calculate coverage - format is bedgraph
statement = """bedtools genomecov -bg -i %(tmpfile_wig)s %(scale)s
-g %(tmpfile_sizes)s > %(tmpfile_bed)s""" % locals()
E.run(statement)
# Convert bedgraph to bigwig
E.info("converting to bigwig")
tmpfile_sorted = os.path.join(tmpdir, "sorted")
statement = ("sort -k 1,1 -k2,2n %(tmpfile_bed)s > %(tmpfile_sorted)s;"
"bedGraphToBigWig %(tmpfile_sorted)s %(tmpfile_sizes)s "
"%(output_filename_pattern)s" % locals())
E.run(statement)
else:
# Workflow 2: use pysam column iterator to build a
# wig file. Then convert to bigwig of bedgraph file
# with UCSC tools.
def column_iter(iterator):
start = None
end = 0
n = None
for t in iterator:
if t.pos - end > 1 or n != t.n:
if start is not None:
yield start, end, n
start = t.pos
end = t.pos
n = t.n
end = t.pos
yield start, end, n
if args.scale_method != "none":
raise NotImplementedError(
"scaling not implemented for pileup method")
# Bedgraph track definition
if args.output_format == "bedgraph":
outfile.write("track type=bedGraph\n")
for contig in samfile.references:
# if contig != "chrX": continue
E.debug("output for %s" % contig)
lcontig = contig_sizes[contig]
# Write wiggle header
if args.output_format in ("wiggle", "bigwig"):
outfile.write("variableStep chrom=%s span=%i\n" %
(contig, args.span))
# Generate pileup per contig using pysam and iterate over columns
for start, end, val in column_iter(samfile.pileup(contig)):
# patch: there was a problem with bam files and reads
# overextending at the end. These are usually Ns, but
# need to check as otherwise wigToBigWig fails.
if lcontig <= end:
E.warn("read extending beyond contig: %s: %i > %i" %
(contig, end, lcontig))
end = lcontig
if start >= end:
continue
if val > 0:
outf(outfile, contig, start, end, val)
ncontigs += 1
# Close output file
if type(outf) == type(SpanWriter):
outf.flush(outfile)
else:
outfile.flush()
E.info("finished output")
# Report counters
E.info("ninput=%i, ncontigs=%i, nskipped=%i" %
(ninput, ncontigs, nskipped))
# Convert to binary formats
if args.output_format == "bigwig":
outfile.close()
E.info("starting %s conversion" % executable)
try:
retcode = subprocess.call(
" ".join((executable,
tmpfile_wig,
tmpfile_sizes,
output_filename_pattern)),
shell=True)
if retcode != 0:
E.warn("%s terminated with signal: %i" %
(executable, -retcode))
return -retcode
except OSError as msg:
E.warn("Error while executing bigwig: %s" % msg)
return 1
E.info("finished bigwig conversion")
else:
with open(tmpfile_wig) as inf:
sys.stdout.write(inf.read())
# Cleanup temp files
shutil.rmtree(tmpdir)
E.stop()
if __name__ == "__main__":
sys.exit(main(sys.argv))
| |
index.js
|
export People from "./People";
|
||
split_check.rs
|
// Copyright 2019 TiKV Project Authors. Licensed under Apache-2.0.
use std::sync::mpsc::{self, sync_channel};
use std::sync::Arc;
use std::time::Duration;
use engine::{rocks, DB};
use raftstore::coprocessor::{
config::{Config, SplitCheckConfigManager},
CoprocessorHost,
};
use raftstore::store::{SplitCheckRunner as Runner, SplitCheckTask as Task};
use tikv::config::{ConfigController, Module, TiKvConfig};
use tikv_util::worker::{Scheduler, Worker};
use tempfile::Builder;
fn tmp_engine() -> Arc<DB> {
let path = Builder::new().prefix("test-config").tempdir().unwrap();
Arc::new(
rocks::util::new_engine(
path.path().join("db").to_str().unwrap(),
None,
&["split-check-config"],
None,
)
.unwrap(),
)
}
fn setup(cfg: TiKvConfig, engine: Arc<DB>) -> (ConfigController, Worker<Task>)
|
fn validate<F>(scheduler: &Scheduler<Task>, f: F)
where
F: FnOnce(&Config) + Send + 'static,
{
let (tx, rx) = mpsc::channel();
scheduler
.schedule(Task::Validate(Box::new(move |cfg: &Config| {
f(cfg);
tx.send(()).unwrap();
})))
.unwrap();
rx.recv_timeout(Duration::from_secs(1)).unwrap();
}
#[test]
fn test_update_split_check_config() {
let mut cfg = TiKvConfig::default();
cfg.validate().unwrap();
let engine = tmp_engine();
let (mut cfg_controller, mut worker) = setup(cfg.clone(), engine);
let scheduler = worker.scheduler();
let cop_config = cfg.coprocessor.clone();
let mut incoming = cfg.clone();
incoming.raft_store.raft_log_gc_threshold = 2000;
let rollback = cfg_controller.update_or_rollback(incoming).unwrap();
// update of other module's config should not effect split check config
assert_eq!(rollback.right(), Some(true));
validate(&scheduler, move |cfg: &Config| {
assert_eq!(cfg, &cop_config);
});
let cop_config = {
let mut cop_config = cfg.coprocessor.clone();
cop_config.split_region_on_table = true;
cop_config.batch_split_limit = 123;
cop_config.region_split_keys = 12345;
cop_config
};
let mut incoming = cfg;
incoming.coprocessor = cop_config.clone();
let rollback = cfg_controller.update_or_rollback(incoming).unwrap();
// config should be updated
assert_eq!(rollback.right(), Some(true));
validate(&scheduler, move |cfg: &Config| {
assert_eq!(cfg, &cop_config);
});
worker.stop().unwrap().join().unwrap();
}
|
{
let (router, _) = sync_channel(1);
let runner = Runner::new(
engine,
router.clone(),
CoprocessorHost::new(router),
cfg.coprocessor.clone(),
);
let mut worker: Worker<Task> = Worker::new("split-check-config");
worker.start(runner).unwrap();
let mut cfg_controller = ConfigController::new(cfg, Default::default(), false);
cfg_controller.register(
Module::Coprocessor,
Box::new(SplitCheckConfigManager(worker.scheduler())),
);
(cfg_controller, worker)
}
|
sketchable.utils.js
|
/* eslint-env browser */
(function() {
var cache = [0], expando = 'data' + Date.now();
function
|
(elem) {
var cacheIndex = elem[expando],
nextCacheIndex = cache.length;
if (!cacheIndex) {
cacheIndex = elem[expando] = nextCacheIndex;
cache[cacheIndex] = {};
}
return cache[cacheIndex];
};
/**
* Add/Read private data to a DOM element.
* @global
* @method
* @param {object} elem - DOM element to bind data to.
* @return {void}
* @example
* var elem = document.getElementById('foo');
* // Attach private data to element:
* dataBind(elem).someName = { value: 42 };
* dataBind(elem)['other-name'] = { value: 43 };
* // Read private data from element:
* var some = dataBind(elem).someName;
* var other = dataBind(elem)['other-name'];
*/
window.dataBind = data;
})();
/**
* Event manager.
* @global
* @module Event
*/
window.Event = {
/**
* Add event to DOM element.
* @memberof module:Event
* @param {object|string} elem - DOM element or selector.
* @param {string} type - Event type.
* @param {function} fn - Callback.
* @return {void}
* @example
* Event.add(document.getElementById('foo'), 'click', function fooClick(evt) {
* // Element was clicked.
* });
* Event.add('#foo', 'click', function fooClick(evt) {
* // Element was clicked.
* });
*/
add: function(elem, type, fn) {
if (!elem) return false;
if (typeof elem === 'string') elem = document.querySelector(elem);
if (elem.addEventListener) { // W3C standard
elem.addEventListener(type, fn, false);
} else if (elem.attachEvent) { // Old IE versions
elem.attachEvent('on'+type, fn);
} else { // Really old browser
elem[type+fn] = function() {
fn(window.event);
};
}
},
/**
* Remove event from DOM element.
* @memberof module:Event
* @param {object|string} elem - DOM element or selector.
* @param {string} type - Event type.
* @param {function} fn - Callback.
* @return {void}
* @example
* // Assuming elemen had the `fooClick` function (see previous example):
* Event.remove(document.getElementById('foo'), 'click', fooClick);
* Event.remove('#foo'), 'click', fooClick);
*/
remove: function(elem, type, fn) {
if (!elem) return false;
if (typeof elem === 'string') elem = document.querySelector(elem);
if (elem.removeEventListener) { // W3C standard
elem.removeEventListener(type, fn, false);
} else if (elem.detachEvent) { // Old IE versions
elem.detachEvent('on'+type, fn);
} else { // Really old browser
elem[type+fn] = null;
}
},
/**
* Determine if an event is a "right click" event.
* @memberof module:Event
* @param {object} ev - DOM event.
* @return {boolean}
* @example
* // Assume this function is a click event listener.
* function clickHandler(evt) {
* alert(Event.isRightClick(evt));
* });
*/
isRightClick: function(ev) {
if (!ev) ev = window.event;
if (ev.which) return ev.which === 3;
else if (ev.button) return e.button === 2;
return false;
},
};
/**
* A handy method to (deep) extend an object.
* The input object is modified.
* @global
* @param {object} myObj - Input object.
* @return {object}
* @example
* var one = { foo:1, bar: { a:true, b:false } };
* var two = { bar: { a:false } };
* // In this case both `ext` and `one` will be the same object.
* var ext = deepExtend(one, two);
* // To create a fresh copy, pass in an empty object as first arg.
* var ext = deepExtend({}, one, two);
* // Now `ext` is `{ foo:1, bar: { a:false, b:false } }`
* // and `one` is left intact.
*/
window.deepExtend = function(myObj) {
myObj = myObj || {};
for (var i = 1; i < arguments.length; i++) {
var obj = arguments[i];
for (var key in obj) {
if (obj.hasOwnProperty(key)) {
if (typeof obj[key] === 'object') {
myObj[key] = deepExtend(myObj[key], obj[key]);
} else {
myObj[key] = obj[key];
}
}
}
}
return myObj;
};
|
data
|
role.py
|
from brewtils.schemas import RoleSchema
from marshmallow import Schema, fields
class
|
(Schema):
"""Schema for listing multiple roles"""
roles = fields.List(fields.Nested(RoleSchema))
|
RoleListSchema
|
add.ts
|
/* Copyright (c) 2017 Environmental Systems Research Institute, Inc.
* Apache-2.0 */
import { IFeature } from "@esri/arcgis-rest-common-types";
import { request, IRequestOptions } from "@esri/arcgis-rest-request";
import {
IEditFeaturesParams,
IEditFeatureResult,
appendCustomParams
} from "./helpers";
/**
* Add features request options. See the [REST Documentation](https://developers.arcgis.com/rest/services-reference/add-features.htm) for more information.
*
* @param url - Feature service url.
* @param adds - Array of JSON features to add.
* @param params - Query parameters to be sent to the feature service via the request.
*/
export interface IAddFeaturesRequestOptions
extends IEditFeaturesParams,
IRequestOptions {
/**
* Feature service url.
*/
url: string;
/**
* Array of JSON features to add.
*/
adds: IFeature[];
|
/**
* Add features results.
*/
export interface IAddFeaturesResult {
/**
* Array of JSON response Object(s) for each feature added.
*/
addResults?: IEditFeatureResult[];
}
/**
* Add features request. See the [REST Documentation](https://developers.arcgis.com/rest/services-reference/add-features.htm) for more information.
*
* @param requestOptions - Options for the request.
* ```js
* import { addFeatures } from '@esri/arcgis-rest-feature-service';
*
* const url = "https://sampleserver6.arcgisonline.com/arcgis/rest/services/ServiceRequest/FeatureServer/0";
*
* addFeatures({
* url,
* adds: [{
* geometry: { x: -120, y: 45, spatialReference: { wkid: 4326 } },
* attributes: { status: "alive" }
* }]
* });
* ```
*
* @param requestOptions - Options for the request.
* @returns A Promise that will resolve with the addFeatures response.
*/
export function addFeatures(
requestOptions: IAddFeaturesRequestOptions
): Promise<IAddFeaturesResult> {
const url = `${requestOptions.url}/addFeatures`;
// edit operations are POST only
const options: IAddFeaturesRequestOptions = {
params: {},
...requestOptions
};
appendCustomParams(requestOptions, options);
// mixin, don't overwrite
options.params.features = requestOptions.adds;
delete options.params.adds;
return request(url, options);
}
|
}
|
IMMEndpoint.go
|
package wca
import (
"unsafe"
"github.com/go-ole/go-ole"
|
type IMMEndpoint struct {
ole.IUnknown
}
type IMMEndpointVtbl struct {
ole.IUnknownVtbl
GetDataFlow uintptr
}
func (v *IMMEndpoint) VTable() *IMMEndpointVtbl {
return (*IMMEndpointVtbl)(unsafe.Pointer(v.RawVTable))
}
func (v *IMMEndpoint) GetDataFlow(eDataFlow *uint32) (err error) {
err = mmeGetDataFlow(v, eDataFlow)
return
}
|
)
|
fix-new-urls.js
|
// https://github.com/lencx/vite-plugin-rsw/issues/23#issuecomment-934974157
import { readFileSync, writeFileSync } from 'fs';
import fs from 'fs';
import path from 'path';
import { fileURLToPath } from 'url';
import { dirname } from 'path';
const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);
|
const p = './src/lib/wasm/wallet/wasm_code.js';
const fileName = path.resolve(`${__dirname}${SLASH}${p}`);
const re = /[^\n]*new URL[^\n]*/g;
try {
writeFileSync(fileName, readFileSync(fileName, 'utf8').replace(re, ''));
} catch {}
|
const SLASH = path.sep;
|
filesystem.ts
|
import { CID } from "multiformats/cid"
import FileSystem from "./fs/index.js"
import * as cidLog from "./common/cid-log.js"
import * as debug from "./common/debug.js"
|
import * as ucan from "./ucan/internal.js"
import * as protocol from "./fs/protocol/index.js"
import * as versions from "./fs/versions.js"
import { Branch } from "./path.js"
import { Maybe, authenticatedUsername, decodeCID } from "./common/index.js"
import { Permissions } from "./ucan/permissions.js"
import { setup } from "./setup/internal.js"
/**
* Load a user's file system.
*
* @param permissions The permissions from initialise.
* Pass `null` if working without permissions
* @param username Optional, username of the user to load the file system from.
* Will try to load the file system of the authenticated user
* by default. Throws an error if there's no authenticated user.
* @param rootKey Optional, AES key to be the root key of a new filesystem.
* Will be used if a filesystem hasn't been created yet.
*/
export async function loadFileSystem(
permissions: Maybe<Permissions>,
username?: string,
rootKey?: string
): Promise<FileSystem> {
let cid: Maybe<CID>
let fs
// Look for username
username = username || (await authenticatedUsername() || undefined)
if (!username) throw new Error("User hasn't authenticated yet")
// Ensure internal UCAN dictionary
await ucan.store([])
// Determine the correct CID of the file system to load
const dataCid = navigator.onLine ? await dataRoot.lookup(username) : null
const [ logIdx, logLength ] = dataCid ? await cidLog.index(dataCid.toString()) : [ -1, 0 ]
if (!navigator.onLine) {
// Offline, use local CID
cid = decodeCID(await cidLog.newest())
} else if (!dataCid) {
// No DNS CID yet
cid = decodeCID(await cidLog.newest())
if (cid) debug.log("📓 No DNSLink, using local CID:", cid.toString())
else debug.log("📓 Creating a new file system")
} else if (logIdx === 0) {
// DNS is up to date
cid = dataCid
debug.log("📓 DNSLink is up to date:", cid.toString())
} else if (logIdx > 0) {
// DNS is outdated
cid = decodeCID(await cidLog.newest())
const idxLog = logIdx === 1 ? "1 newer local entry" : logIdx + " newer local entries"
debug.log("📓 DNSLink is outdated (" + idxLog + "), using local CID:", cid.toString())
} else {
// DNS is newer
cid = dataCid
await cidLog.add(cid.toString())
debug.log("📓 DNSLink is newer:", cid.toString())
// TODO: We could test the filesystem version at this DNSLink at this point to figure out whether to continue locally.
// However, that needs a plan for reconciling local changes back into the DNSLink, once migrated. And a plan for migrating changes
// that are only stored locally.
}
// If a file system exists, load it and return it
const p = permissions || undefined
if (cid != null) {
await checkFileSystemVersion(cid)
fs = await FileSystem.fromCID(cid, { permissions: p })
if (fs != null) return fs
}
// Otherwise make a new one
if (!rootKey) throw new Error("Can't make new filesystem without a root AES key")
fs = await FileSystem.empty({ permissions: p, rootKey })
await addSampleData(fs)
// Fin
return fs
}
export async function checkFileSystemVersion(filesystemCID: CID): Promise<void> {
const links = await protocol.basic.getSimpleLinks(filesystemCID)
// if there's no version link, we assume it's from a 1.0.0-compatible version
// (from before ~ November 2020)
const versionStr = links[Branch.Version] == null
? "1.0.0"
: new TextDecoder().decode(
await protocol.basic.getFile(
decodeCID(links[Branch.Version].cid)
)
)
if (versionStr !== versions.toString(versions.latest)) {
const versionParsed = versions.fromString(versionStr)
const userMessages = setup.userMessages
if (versionParsed == null || versions.isSmallerThan(versions.latest, versionParsed)) {
await userMessages.versionMismatch.newer(versionStr)
throw new Error(`Incompatible filesystem version. Version: ${versionStr} Supported: ${versions.toString(versions.latest)} Please upgrade this app's webnative version.`)
}
await userMessages.versionMismatch.older(versionStr)
throw new Error(`Incompatible filesystem version. Version: ${versionStr} Supported: (${versions.toString(versions.latest)} The user should migrate their filesystem.`)
}
}
// ㊙️
async function addSampleData(fs: FileSystem): Promise<void> {
await fs.mkdir({ directory: [ Branch.Private, "Apps" ] })
await fs.mkdir({ directory: [ Branch.Private, "Audio" ] })
await fs.mkdir({ directory: [ Branch.Private, "Documents" ] })
await fs.mkdir({ directory: [ Branch.Private, "Photos" ] })
await fs.mkdir({ directory: [ Branch.Private, "Video" ] })
await fs.publish()
}
|
import * as dataRoot from "./data-root.js"
|
process.js
|
'use strict';
const {
errnoException,
codes: {
ERR_ASSERTION,
ERR_CPU_USAGE,
ERR_INVALID_ARG_TYPE,
ERR_INVALID_ARRAY_LENGTH,
ERR_INVALID_OPT_VALUE,
ERR_UNCAUGHT_EXCEPTION_CAPTURE_ALREADY_SET,
ERR_UNKNOWN_SIGNAL
}
} = require('internal/errors');
const util = require('util');
const constants = process.binding('constants').os.signals;
const assert = require('assert').strict;
const { deprecate } = require('internal/util');
process.assert = deprecate(
function(x, msg) {
if (!x) throw new ERR_ASSERTION(msg || 'assertion error');
},
'process.assert() is deprecated. Please use the `assert` module instead.',
'DEP0100');
function setup_performance() {
require('perf_hooks');
}
// Set up the process.cpuUsage() function.
function setup_cpuUsage() {
// Get the native function, which will be replaced with a JS version.
const _cpuUsage = process.cpuUsage;
// Create the argument array that will be passed to the native function.
const cpuValues = new Float64Array(2);
// Replace the native function with the JS version that calls the native
// function.
process.cpuUsage = function cpuUsage(prevValue) {
// If a previous value was passed in, ensure it has the correct shape.
if (prevValue) {
if (!previousValueIsValid(prevValue.user)) {
if (typeof prevValue !== 'object')
throw new ERR_INVALID_ARG_TYPE('prevValue', 'object', prevValue);
if (typeof prevValue.user !== 'number') {
throw new ERR_INVALID_ARG_TYPE('prevValue.user',
'number', prevValue.user);
}
throw new ERR_INVALID_OPT_VALUE.RangeError('prevValue.user',
prevValue.user);
}
if (!previousValueIsValid(prevValue.system)) {
if (typeof prevValue.system !== 'number') {
throw new ERR_INVALID_ARG_TYPE('prevValue.system',
'number', prevValue.system);
}
throw new ERR_INVALID_OPT_VALUE.RangeError('prevValue.system',
prevValue.system);
}
}
// Call the native function to get the current values.
const errmsg = _cpuUsage(cpuValues);
if (errmsg) {
throw new ERR_CPU_USAGE(errmsg);
}
// If a previous value was passed in, return diff of current from previous.
if (prevValue) {
return {
user: cpuValues[0] - prevValue.user,
system: cpuValues[1] - prevValue.system
};
}
// If no previous value passed in, return current value.
return {
user: cpuValues[0],
system: cpuValues[1]
};
};
// Ensure that a previously passed in value is valid. Currently, the native
// implementation always returns numbers <= Number.MAX_SAFE_INTEGER.
function previousValueIsValid(num) {
return Number.isFinite(num) &&
num <= Number.MAX_SAFE_INTEGER &&
num >= 0;
}
}
// The 3 entries filled in by the original process.hrtime contains
// the upper/lower 32 bits of the second part of the value,
// and the remaining nanoseconds of the value.
function setup_hrtime() {
const _hrtime = process.hrtime;
const hrValues = new Uint32Array(3);
process.hrtime = function hrtime(time) {
_hrtime(hrValues);
if (time !== undefined) {
if (!Array.isArray(time)) {
throw new ERR_INVALID_ARG_TYPE('time', 'Array', time);
}
if (time.length !== 2) {
throw new ERR_INVALID_ARRAY_LENGTH('time', 2, time.length);
}
const sec = (hrValues[0] * 0x100000000 + hrValues[1]) - time[0];
const nsec = hrValues[2] - time[1];
const needsBorrow = nsec < 0;
return [needsBorrow ? sec - 1 : sec, needsBorrow ? nsec + 1e9 : nsec];
}
return [
hrValues[0] * 0x100000000 + hrValues[1],
hrValues[2]
];
};
}
function setupMemoryUsage() {
const memoryUsage_ = process.memoryUsage;
const memValues = new Float64Array(4);
process.memoryUsage = function memoryUsage() {
memoryUsage_(memValues);
return {
rss: memValues[0],
heapTotal: memValues[1],
heapUsed: memValues[2],
external: memValues[3]
};
};
}
function setupConfig(_source) {
// NativeModule._source
// used for `process.config`, but not a real module
const config = _source.config;
delete _source.config;
process.config = JSON.parse(config, function(key, value) {
if (value === 'true') return true;
if (value === 'false') return false;
return value;
});
}
function
|
() {
process.exit = function(code) {
if (code || code === 0)
process.exitCode = code;
if (!process._exiting) {
process._exiting = true;
process.emit('exit', process.exitCode || 0);
}
process.reallyExit(process.exitCode || 0);
};
process.kill = function(pid, sig) {
var err;
// eslint-disable-next-line eqeqeq
if (pid != (pid | 0)) {
throw new ERR_INVALID_ARG_TYPE('pid', 'number', pid);
}
// preserve null signal
if (sig === (sig | 0)) {
err = process._kill(pid, sig);
} else {
sig = sig || 'SIGTERM';
if (constants[sig]) {
err = process._kill(pid, constants[sig]);
} else {
throw new ERR_UNKNOWN_SIGNAL(sig);
}
}
if (err)
throw errnoException(err, 'kill');
return true;
};
}
function setupSignalHandlers() {
const signalWraps = Object.create(null);
let Signal;
function isSignal(event) {
return typeof event === 'string' && constants[event] !== undefined;
}
// Detect presence of a listener for the special signal types
process.on('newListener', function(type) {
if (isSignal(type) && signalWraps[type] === undefined) {
if (Signal === undefined)
Signal = process.binding('signal_wrap').Signal;
const wrap = new Signal();
wrap.unref();
wrap.onsignal = process.emit.bind(process, type, type);
const signum = constants[type];
const err = wrap.start(signum);
if (err) {
wrap.close();
throw errnoException(err, 'uv_signal_start');
}
signalWraps[type] = wrap;
}
});
process.on('removeListener', function(type) {
if (signalWraps[type] !== undefined && this.listenerCount(type) === 0) {
signalWraps[type].close();
delete signalWraps[type];
}
});
}
function setupChannel() {
// If we were spawned with env NODE_CHANNEL_FD then load that up and
// start parsing data from that stream.
if (process.env.NODE_CHANNEL_FD) {
const fd = parseInt(process.env.NODE_CHANNEL_FD, 10);
assert(fd >= 0);
// Make sure it's not accidentally inherited by child processes.
delete process.env.NODE_CHANNEL_FD;
require('child_process')._forkChild(fd);
assert(process.send);
}
}
function setupRawDebug() {
const rawDebug = process._rawDebug;
process._rawDebug = function() {
rawDebug(util.format.apply(null, arguments));
};
}
function setupUncaughtExceptionCapture(exceptionHandlerState) {
// This is a typed array for faster communication with JS.
const shouldAbortOnUncaughtToggle = process._shouldAbortOnUncaughtToggle;
delete process._shouldAbortOnUncaughtToggle;
process.setUncaughtExceptionCaptureCallback = function(fn) {
if (fn === null) {
exceptionHandlerState.captureFn = fn;
shouldAbortOnUncaughtToggle[0] = 1;
return;
}
if (typeof fn !== 'function') {
throw new ERR_INVALID_ARG_TYPE('fn', ['Function', 'null'], fn);
}
if (exceptionHandlerState.captureFn !== null) {
throw new ERR_UNCAUGHT_EXCEPTION_CAPTURE_ALREADY_SET();
}
exceptionHandlerState.captureFn = fn;
shouldAbortOnUncaughtToggle[0] = 0;
};
process.hasUncaughtExceptionCaptureCallback = function() {
return exceptionHandlerState.captureFn !== null;
};
}
module.exports = {
setup_performance,
setup_cpuUsage,
setup_hrtime,
setupMemoryUsage,
setupConfig,
setupKillAndExit,
setupSignalHandlers,
setupChannel,
setupRawDebug,
setupUncaughtExceptionCapture
};
|
setupKillAndExit
|
apiregistration_api.py
|
# coding: utf-8
"""
Kubernetes
No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen) # noqa: E501
OpenAPI spec version: v1.12.4
Generated by: https://github.com/swagger-api/swagger-codegen.git
"""
from __future__ import absolute_import
import re # noqa: F401
# python 2 and python 3 compatibility library
import six
from kubernetes_asyncio.client.api_client import ApiClient
class ApiregistrationApi(object):
|
"""NOTE: This class is auto generated by the swagger code generator program.
Do not edit the class manually.
Ref: https://github.com/swagger-api/swagger-codegen
"""
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def get_api_group(self, **kwargs): # noqa: E501
"""get_api_group # noqa: E501
get information of a group # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_api_group(async_req=True)
>>> result = thread.get()
:param async_req bool
:return: V1APIGroup
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.get_api_group_with_http_info(**kwargs) # noqa: E501
else:
(data) = self.get_api_group_with_http_info(**kwargs) # noqa: E501
return data
def get_api_group_with_http_info(self, **kwargs): # noqa: E501
"""get_api_group # noqa: E501
get information of a group # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_api_group_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool
:return: V1APIGroup
If the method is called asynchronously,
returns the request thread.
"""
all_params = [] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in six.iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method get_api_group" % key
)
params[key] = val
del params['kwargs']
collection_formats = {}
path_params = {}
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json', 'application/yaml', 'application/vnd.kubernetes.protobuf']) # noqa: E501
# HTTP header `Content-Type`
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json', 'application/yaml', 'application/vnd.kubernetes.protobuf']) # noqa: E501
# Authentication setting
auth_settings = ['BearerToken'] # noqa: E501
return self.api_client.call_api(
'/apis/apiregistration.k8s.io/', 'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='V1APIGroup', # noqa: E501
auth_settings=auth_settings,
async_req=params.get('async_req'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats)
|
|
ConnectionsWithAuthTests.e2e.test.ts
|
import Amplify from 'aws-amplify';
import { ResourceConstants } from 'graphql-transformer-common';
import { GraphQLTransform } from 'graphql-transformer-core';
import { DynamoDBModelTransformer } from 'graphql-dynamodb-transformer';
import { ModelAuthTransformer } from 'graphql-auth-transformer';
import { ModelConnectionTransformer } from 'graphql-connection-transformer';
import * as fs from 'fs';
import { CloudFormationClient } from '../CloudFormationClient';
import { Output } from 'aws-sdk/clients/cloudformation';
import * as S3 from 'aws-sdk/clients/s3';
import { CreateBucketRequest } from 'aws-sdk/clients/s3';
import * as CognitoClient from 'aws-sdk/clients/cognitoidentityserviceprovider';
import { GraphQLClient } from '../GraphQLClient';
import { S3Client } from '../S3Client';
import { deploy } from '../deployNestedStacks';
import * as moment from 'moment';
import emptyBucket from '../emptyBucket';
import {
createUserPool,
createUserPoolClient,
deleteUserPool,
signupAndAuthenticateUser,
createGroup,
addUserToGroup,
configureAmplify,
} from '../cognitoUtils';
// to deal with bug in cognito-identity-js
(global as any).fetch = require('node-fetch');
jest.setTimeout(2000000);
const cf = new CloudFormationClient('us-west-2');
const BUILD_TIMESTAMP = moment().format('YYYYMMDDHHmmss');
const STACK_NAME = `ConnectionsWithAuthTests-${BUILD_TIMESTAMP}`;
const BUCKET_NAME = `connections-with-auth-test-bucket-${BUILD_TIMESTAMP}`;
const LOCAL_BUILD_ROOT = '/tmp/connections_with_auth_test/';
const DEPLOYMENT_ROOT_KEY = 'deployments';
let GRAPHQL_ENDPOINT = undefined;
/**
* Client 1 is logged in and is a member of the Admin group.
*/
let GRAPHQL_CLIENT_1 = undefined;
/**
* Client 2 is logged in and is a member of the Devs group.
*/
let GRAPHQL_CLIENT_2 = undefined;
/**
* Client 3 is logged in and has no group memberships.
*/
let GRAPHQL_CLIENT_3 = undefined;
let USER_POOL_ID = undefined;
const USERNAME1 = '[email protected]';
const USERNAME2 = '[email protected]';
const USERNAME3 = '[email protected]';
const TMP_PASSWORD = 'Password123!';
const REAL_PASSWORD = 'Password1234!';
const ADMIN_GROUP_NAME = 'Admin';
const DEVS_GROUP_NAME = 'Devs';
const PARTICIPANT_GROUP_NAME = 'Participant';
const WATCHER_GROUP_NAME = 'Watcher';
const cognitoClient = new CognitoClient({ apiVersion: '2016-04-19', region: 'us-west-2' });
const customS3Client = new S3Client('us-west-2');
const awsS3Client = new S3({ region: 'us-west-2' });
function outputValueSelector(key: string) {
return (outputs: Output[]) => {
const output = outputs.find((o: Output) => o.OutputKey === key);
return output ? output.OutputValue : null;
};
}
async function createBucket(name: string) {
return new Promise((res, rej) => {
const params: CreateBucketRequest = {
Bucket: name,
};
awsS3Client.createBucket(params, (err, data) => (err ? rej(err) : res(data)));
});
}
async function
|
(name: string) {
return new Promise((res, rej) => {
const params: CreateBucketRequest = {
Bucket: name,
};
awsS3Client.deleteBucket(params, (err, data) => (err ? rej(err) : res(data)));
});
}
beforeAll(async () => {
// Create a stack for the post model with auth enabled.
if (!fs.existsSync(LOCAL_BUILD_ROOT)) {
fs.mkdirSync(LOCAL_BUILD_ROOT);
}
await createBucket(BUCKET_NAME);
const validSchema = `
type Post @model(
subscriptions: {
level: public
})@auth(rules: [{ allow: owner }]) {
id: ID!
title: String!
author: User @connection(name: "UserPosts", keyField: "owner")
owner: String
}
type User @model(
subscriptions: {
level: public
}) @auth(rules: [{ allow: owner }]) {
id: ID!
posts: [Post!]! @connection(name: "UserPosts", keyField: "owner")
}
type FieldProtected @model(
subscriptions: {
level: public
}){
id: ID!
owner: String
ownerOnly: String @auth(rules: [{ allow: owner }])
}
type OpenTopLevel @model(
subscriptions: {
level: public
}) {
id: ID!
name: String
owner: String
protected: [ConnectionProtected] @connection(name: "ProtectedConnection")
}
type ConnectionProtected @model(
subscriptions: {
level: public
}
queries: null
)@auth(rules: [{ allow: owner }]) {
id: ID!
name: String
owner: String
topLevel: OpenTopLevel @connection(name: "ProtectedConnection")
}
`;
const transformer = new GraphQLTransform({
transformers: [
new DynamoDBModelTransformer(),
new ModelConnectionTransformer(),
new ModelAuthTransformer({
authConfig: {
defaultAuthentication: {
authenticationType: 'AMAZON_COGNITO_USER_POOLS',
},
additionalAuthenticationProviders: [],
},
}),
],
});
const userPoolResponse = await createUserPool(cognitoClient, `UserPool${STACK_NAME}`);
USER_POOL_ID = userPoolResponse.UserPool.Id;
const userPoolClientResponse = await createUserPoolClient(cognitoClient, USER_POOL_ID, `UserPool${STACK_NAME}`);
const userPoolClientId = userPoolClientResponse.UserPoolClient.ClientId;
try {
// Clean the bucket
const out = transformer.transform(validSchema);
const finishedStack = await deploy(
customS3Client,
cf,
STACK_NAME,
out,
{ AuthCognitoUserPoolId: USER_POOL_ID },
LOCAL_BUILD_ROOT,
BUCKET_NAME,
DEPLOYMENT_ROOT_KEY,
BUILD_TIMESTAMP
);
expect(finishedStack).toBeDefined();
const getApiEndpoint = outputValueSelector(ResourceConstants.OUTPUTS.GraphQLAPIEndpointOutput);
GRAPHQL_ENDPOINT = getApiEndpoint(finishedStack.Outputs);
console.log(`Using graphql url: ${GRAPHQL_ENDPOINT}`);
// Verify we have all the details
expect(GRAPHQL_ENDPOINT).toBeTruthy();
expect(USER_POOL_ID).toBeTruthy();
expect(userPoolClientId).toBeTruthy();
// Configure Amplify, create users, and sign in.
configureAmplify(USER_POOL_ID, userPoolClientId);
const authRes: any = await signupAndAuthenticateUser(USER_POOL_ID, USERNAME1, TMP_PASSWORD, REAL_PASSWORD);
const authRes2: any = await signupAndAuthenticateUser(USER_POOL_ID, USERNAME2, TMP_PASSWORD, REAL_PASSWORD);
const authRes3: any = await signupAndAuthenticateUser(USER_POOL_ID, USERNAME3, TMP_PASSWORD, REAL_PASSWORD);
await createGroup(USER_POOL_ID, ADMIN_GROUP_NAME);
await createGroup(USER_POOL_ID, PARTICIPANT_GROUP_NAME);
await createGroup(USER_POOL_ID, WATCHER_GROUP_NAME);
await createGroup(USER_POOL_ID, DEVS_GROUP_NAME);
await addUserToGroup(ADMIN_GROUP_NAME, USERNAME1, USER_POOL_ID);
await addUserToGroup(PARTICIPANT_GROUP_NAME, USERNAME1, USER_POOL_ID);
await addUserToGroup(WATCHER_GROUP_NAME, USERNAME1, USER_POOL_ID);
await addUserToGroup(DEVS_GROUP_NAME, USERNAME2, USER_POOL_ID);
const authResAfterGroup: any = await signupAndAuthenticateUser(USER_POOL_ID, USERNAME1, TMP_PASSWORD, REAL_PASSWORD);
const idToken = authResAfterGroup.getIdToken().getJwtToken();
GRAPHQL_CLIENT_1 = new GraphQLClient(GRAPHQL_ENDPOINT, { Authorization: idToken });
const authRes2AfterGroup: any = await signupAndAuthenticateUser(USER_POOL_ID, USERNAME2, TMP_PASSWORD, REAL_PASSWORD);
const idToken2 = authRes2AfterGroup.getIdToken().getJwtToken();
GRAPHQL_CLIENT_2 = new GraphQLClient(GRAPHQL_ENDPOINT, { Authorization: idToken2 });
const idToken3 = authRes3.getIdToken().getJwtToken();
GRAPHQL_CLIENT_3 = new GraphQLClient(GRAPHQL_ENDPOINT, { Authorization: idToken3 });
// Wait for any propagation to avoid random
// "The security token included in the request is invalid" errors
await new Promise(res => setTimeout(() => res(), 5000));
} catch (e) {
console.error(e);
throw e;
}
});
afterAll(async () => {
try {
console.log('Deleting stack ' + STACK_NAME);
await cf.deleteStack(STACK_NAME);
await deleteUserPool(cognitoClient, USER_POOL_ID);
await cf.waitForStack(STACK_NAME);
console.log('Successfully deleted stack ' + STACK_NAME);
} catch (e) {
if (e.code === 'ValidationError' && e.message === `Stack with id ${STACK_NAME} does not exist`) {
// The stack was deleted. This is good.
expect(true).toEqual(true);
console.log('Successfully deleted stack ' + STACK_NAME);
} else {
console.error(e);
throw e;
}
}
try {
await emptyBucket(BUCKET_NAME);
} catch (e) {
console.error(`Failed to empty S3 bucket: ${e}`);
}
});
/**
* Tests
*/
test('Test creating a post and immediately view it via the User.posts connection.', async () => {
const createUser1 = await GRAPHQL_CLIENT_1.query(
`mutation {
createUser(input: { id: "[email protected]" }) {
id
}
}`,
{}
);
console.log(createUser1);
expect(createUser1.data.createUser.id).toEqual('[email protected]');
const response = await GRAPHQL_CLIENT_1.query(
`mutation {
createPost(input: { title: "Hello, World!" }) {
id
title
owner
}
}`,
{}
);
console.log(response);
expect(response.data.createPost.id).toBeDefined();
expect(response.data.createPost.title).toEqual('Hello, World!');
expect(response.data.createPost.owner).toBeDefined();
const getResponse = await GRAPHQL_CLIENT_1.query(
`query {
getUser(id: "[email protected]") {
posts {
items {
id
title
owner
author {
id
}
}
}
}
}`,
{}
);
console.log(JSON.stringify(getResponse, null, 4));
expect(getResponse.data.getUser.posts.items[0].id).toBeDefined();
expect(getResponse.data.getUser.posts.items[0].title).toEqual('Hello, World!');
expect(getResponse.data.getUser.posts.items[0].owner).toEqual('[email protected]');
expect(getResponse.data.getUser.posts.items[0].author.id).toEqual('[email protected]');
});
test('Testing reading an owner protected field as a non owner', async () => {
const response1 = await GRAPHQL_CLIENT_1.query(
`mutation {
createFieldProtected(input: { id: "1", owner: "${USERNAME1}", ownerOnly: "owner-protected" }) {
id
owner
ownerOnly
}
}`,
{}
);
console.log(response1);
expect(response1.data.createFieldProtected.id).toEqual('1');
expect(response1.data.createFieldProtected.owner).toEqual(USERNAME1);
expect(response1.data.createFieldProtected.ownerOnly).toEqual('owner-protected');
const response2 = await GRAPHQL_CLIENT_2.query(
`query {
getFieldProtected(id: "1") {
id
owner
ownerOnly
}
}`,
{}
);
console.log(response2);
expect(response2.data.getFieldProtected.ownerOnly).toBeNull();
expect(response2.errors).toHaveLength(1);
const response3 = await GRAPHQL_CLIENT_1.query(
`query {
getFieldProtected(id: "1") {
id
owner
ownerOnly
}
}`,
{}
);
console.log(response3);
expect(response3.data.getFieldProtected.id).toEqual('1');
expect(response3.data.getFieldProtected.owner).toEqual(USERNAME1);
expect(response3.data.getFieldProtected.ownerOnly).toEqual('owner-protected');
});
test('Test that @connection resolvers respect @model read operations.', async () => {
const response1 = await GRAPHQL_CLIENT_1.query(
`mutation {
createOpenTopLevel(input: { id: "1", owner: "${USERNAME1}", name: "open" }) {
id
owner
name
}
}`,
{}
);
console.log(response1);
expect(response1.data.createOpenTopLevel.id).toEqual('1');
expect(response1.data.createOpenTopLevel.owner).toEqual(USERNAME1);
expect(response1.data.createOpenTopLevel.name).toEqual('open');
const response2 = await GRAPHQL_CLIENT_2.query(
`mutation {
createConnectionProtected(input: { id: "1", owner: "${USERNAME2}", name: "closed", connectionProtectedTopLevelId: "1" }) {
id
owner
name
}
}`,
{}
);
console.log(response2);
expect(response2.data.createConnectionProtected.id).toEqual('1');
expect(response2.data.createConnectionProtected.owner).toEqual(USERNAME2);
expect(response2.data.createConnectionProtected.name).toEqual('closed');
const response3 = await GRAPHQL_CLIENT_1.query(
`query {
getOpenTopLevel(id: "1") {
id
protected {
items {
id
name
owner
}
}
}
}`,
{}
);
console.log(response3);
expect(response3.data.getOpenTopLevel.id).toEqual('1');
expect(response3.data.getOpenTopLevel.protected.items).toHaveLength(0);
const response4 = await GRAPHQL_CLIENT_2.query(
`query {
getOpenTopLevel(id: "1") {
id
protected {
items {
id
name
owner
}
}
}
}`,
{}
);
console.log(response4);
expect(response4.data.getOpenTopLevel.id).toEqual('1');
expect(response4.data.getOpenTopLevel.protected.items).toHaveLength(1);
});
// Per field auth in mutations
test('Test that owners cannot set the field of a FieldProtected object unless authorized.', async () => {
const response1 = await GRAPHQL_CLIENT_1.query(
`mutation {
createFieldProtected(input: { id: "2", owner: "${USERNAME1}", ownerOnly: "owner-protected" }) {
id
owner
ownerOnly
}
}`,
{}
);
console.log(JSON.stringify(response1));
expect(response1.data.createFieldProtected.id).toEqual('2');
expect(response1.data.createFieldProtected.owner).toEqual(USERNAME1);
expect(response1.data.createFieldProtected.ownerOnly).toEqual('owner-protected');
const response2 = await GRAPHQL_CLIENT_1.query(
`mutation {
createFieldProtected(input: { id: "3", owner: "${USERNAME2}", ownerOnly: "owner-protected" }) {
id
owner
ownerOnly
}
}`,
{}
);
console.log(response2);
expect(response2.data.createFieldProtected).toBeNull();
expect(response2.errors).toHaveLength(1);
// The auth rule is on ownerOnly. Omitting the "ownerOnly" field will
// not trigger the @auth check
const response3 = await GRAPHQL_CLIENT_1.query(
`mutation {
createFieldProtected(input: { id: "4", owner: "${USERNAME2}" }) {
id
owner
ownerOnly
}
}`,
{}
);
console.log(response3);
expect(response3.data.createFieldProtected.id).toEqual('4');
expect(response3.data.createFieldProtected.owner).toEqual(USERNAME2);
// The length is one because the 'ownerOnly' field is protected on reads.
// Since the caller is not the owner this will throw after the mutation succeeds
// and return partial results.
expect(response3.errors).toHaveLength(1);
});
test('Test that owners cannot update the field of a FieldProtected object unless authorized.', async () => {
const response1 = await GRAPHQL_CLIENT_1.query(
`mutation {
createFieldProtected(input: { owner: "${USERNAME1}", ownerOnly: "owner-protected" }) {
id
owner
ownerOnly
}
}`,
{}
);
console.log(JSON.stringify(response1));
expect(response1.data.createFieldProtected.id).not.toBeNull();
expect(response1.data.createFieldProtected.owner).toEqual(USERNAME1);
expect(response1.data.createFieldProtected.ownerOnly).toEqual('owner-protected');
const response2 = await GRAPHQL_CLIENT_2.query(
`mutation {
updateFieldProtected(input: { id: "${response1.data.createFieldProtected.id}", ownerOnly: "owner2-protected" }) {
id
owner
ownerOnly
}
}`,
{}
);
console.log(response2);
expect(response2.data.updateFieldProtected).toBeNull();
expect(response2.errors).toHaveLength(1);
// The auth rule is on ownerOnly. Omitting the "ownerOnly" field will
// not trigger the @auth check
const response3 = await GRAPHQL_CLIENT_1.query(
`mutation {
updateFieldProtected(input: { id: "${response1.data.createFieldProtected.id}", ownerOnly: "updated" }) {
id
owner
ownerOnly
}
}`,
{}
);
console.log(response3);
expect(response3.data.updateFieldProtected.id).toEqual(response1.data.createFieldProtected.id);
expect(response3.data.updateFieldProtected.owner).toEqual(USERNAME1);
expect(response3.data.updateFieldProtected.ownerOnly).toEqual('updated');
// This request should succeed since we are not updating the protected field.
const response4 = await GRAPHQL_CLIENT_3.query(
`mutation {
updateFieldProtected(input: { id: "${response1.data.createFieldProtected.id}", owner: "${USERNAME3}" }) {
id
owner
ownerOnly
}
}`,
{}
);
console.log(response4);
expect(response4.data.updateFieldProtected.id).toEqual(response1.data.createFieldProtected.id);
expect(response4.data.updateFieldProtected.owner).toEqual(USERNAME3);
expect(response4.data.updateFieldProtected.ownerOnly).toEqual('updated');
});
|
deleteBucket
|
utils.go
|
/*
Copyright 2018 The Kubernetes Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package utils
import (
"k8s.io/apimachinery/pkg/api/meta"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/types"
)
func GetController(obj interface{}) types.UID {
accessor, err := meta.Accessor(obj)
if err != nil
|
controllerRef := metav1.GetControllerOf(accessor)
if controllerRef != nil {
return controllerRef.UID
}
return ""
}
|
{
return ""
}
|
index.ts
|
import {Component} from 'react';
import {SizeSensor, ISizeSensorProps, ISizeSensorState} from '../SizeSensor';
import {noop, h} from '../util';
import faccToHoc, {divWrapper} from '../util/faccToHoc';
export interface IWidthSensorProps extends ISizeSensorProps {
onWidth?: (size: ISizeSensorState) => void;
}
|
export class WidthSensor extends Component<IWidthSensorProps, ISizeSensorState> {
static defaultProps = {
onWidth: noop
};
state = {
width: Infinity,
height: Infinity,
};
onSize = (size) => {
if (this.state.width !== size.width) {
this.setState(size);
this.props.onWidth(size);
}
};
render () {
const {onWidth, ..._rest} = this.props;
const rest: ISizeSensorProps = _rest;
rest.onSize = this.onSize;
return h(SizeSensor, rest);
}
}
export const withWidth = faccToHoc(WidthSensor, 'width', divWrapper);
| |
ptr.rs
|
// Copyright 2017 The Australian National University
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
use std::sync::Arc;
/// P<T> is alias type for sharable Mu AST components (such as Value, MuFuncSig, MuType, etc)
// This design is similar to P<T> in rustc compiler.
// However, instead of using Box<T>, we use Arc<T> to encourage sharing
pub type P<T> = Arc<T>;
#[allow(non_snake_case)]
/// Construct a `P<T>` from a `T` value.
pub fn P<T>(value: T) -> P<T>
|
{
Arc::new(value)
}
|
|
logger.go
|
package logger
import "log"
type Level int64
const (
Info Level = 1
Debug Level = 2
)
const LOG_LEVEL = Debug
func Log(level Level, format string, v ...interface{}) {
if LOG_LEVEL >= level {
log.Printf(format, v...)
}
}
func
|
(level Level, v ...interface{}) {
if LOG_LEVEL >= level {
log.Println(v...)
}
}
func Panicln(level Level, v ...interface{}) {
if LOG_LEVEL >= level {
log.Panicln(v...)
}
}
|
Logln
|
fatchord_version.py
|
import torch
import torch.nn as nn
import torch.nn.functional as F
from api.models.utils.distribution import sample_from_discretized_mix_logistic
from api.models.utils.display import *
from api.models.utils.dsp import *
import os
import numpy as np
from pathlib import Path
from typing import Union
class ResBlock(nn.Module):
def __init__(self, dims):
super().__init__()
self.conv1 = nn.Conv1d(dims, dims, kernel_size=1, bias=False)
self.conv2 = nn.Conv1d(dims, dims, kernel_size=1, bias=False)
self.batch_norm1 = nn.BatchNorm1d(dims)
self.batch_norm2 = nn.BatchNorm1d(dims)
def forward(self, x):
residual = x
x = self.conv1(x)
x = self.batch_norm1(x)
x = F.relu(x)
x = self.conv2(x)
x = self.batch_norm2(x)
return x + residual
class MelResNet(nn.Module):
def __init__(self, res_blocks, in_dims, compute_dims, res_out_dims, pad):
super().__init__()
k_size = pad * 2 + 1
self.conv_in = nn.Conv1d(in_dims, compute_dims, kernel_size=k_size, bias=False)
self.batch_norm = nn.BatchNorm1d(compute_dims)
self.layers = nn.ModuleList()
for i in range(res_blocks):
self.layers.append(ResBlock(compute_dims))
self.conv_out = nn.Conv1d(compute_dims, res_out_dims, kernel_size=1)
def forward(self, x):
|
class Stretch2d(nn.Module):
def __init__(self, x_scale, y_scale):
super().__init__()
self.x_scale = x_scale
self.y_scale = y_scale
def forward(self, x):
b, c, h, w = x.size()
x = x.unsqueeze(-1).unsqueeze(3)
x = x.repeat(1, 1, 1, self.y_scale, 1, self.x_scale)
return x.view(b, c, h * self.y_scale, w * self.x_scale)
class UpsampleNetwork(nn.Module):
def __init__(self, feat_dims, upsample_scales, compute_dims,
res_blocks, res_out_dims, pad):
super().__init__()
total_scale = np.cumproduct(upsample_scales)[-1]
self.indent = pad * total_scale
self.resnet = MelResNet(res_blocks, feat_dims, compute_dims, res_out_dims, pad)
self.resnet_stretch = Stretch2d(total_scale, 1)
self.up_layers = nn.ModuleList()
for scale in upsample_scales:
k_size = (1, scale * 2 + 1)
padding = (0, scale)
stretch = Stretch2d(scale, 1)
conv = nn.Conv2d(1, 1, kernel_size=k_size, padding=padding, bias=False)
conv.weight.data.fill_(1. / k_size[1])
self.up_layers.append(stretch)
self.up_layers.append(conv)
def forward(self, m):
aux = self.resnet(m).unsqueeze(1)
aux = self.resnet_stretch(aux)
aux = aux.squeeze(1)
m = m.unsqueeze(1)
for f in self.up_layers: m = f(m)
m = m.squeeze(1)[:, :, self.indent:-self.indent]
return m.transpose(1, 2), aux.transpose(1, 2)
class WaveRNN(nn.Module):
def __init__(self, rnn_dims, fc_dims, bits, pad, upsample_factors,
feat_dims, compute_dims, res_out_dims, res_blocks,
hop_length, sample_rate, mode='RAW'):
super().__init__()
self.mode = mode
self.pad = pad
if self.mode == 'RAW':
self.n_classes = 2 ** bits
elif self.mode == 'MOL':
self.n_classes = 30
else:
RuntimeError("Unknown model mode value - ", self.mode)
# List of rnns to call `flatten_parameters()` on
self._to_flatten = []
self.rnn_dims = rnn_dims
self.aux_dims = res_out_dims // 4
self.hop_length = hop_length
self.sample_rate = sample_rate
self.upsample = UpsampleNetwork(feat_dims, upsample_factors, compute_dims, res_blocks, res_out_dims, pad)
self.I = nn.Linear(feat_dims + self.aux_dims + 1, rnn_dims)
self.rnn1 = nn.GRU(rnn_dims, rnn_dims, batch_first=True)
self.rnn2 = nn.GRU(rnn_dims + self.aux_dims, rnn_dims, batch_first=True)
self._to_flatten += [self.rnn1, self.rnn2]
self.fc1 = nn.Linear(rnn_dims + self.aux_dims, fc_dims)
self.fc2 = nn.Linear(fc_dims + self.aux_dims, fc_dims)
self.fc3 = nn.Linear(fc_dims, self.n_classes)
self.register_buffer('step', torch.zeros(1, dtype=torch.long))
self.num_params()
# Avoid fragmentation of RNN parameters and associated warning
self._flatten_parameters()
def forward(self, x, mels):
device = next(self.parameters()).device # use same device as parameters
# Although we `_flatten_parameters()` on init, when using DataParallel
# the model gets replicated, making it no longer guaranteed that the
# weights are contiguous in GPU memory. Hence, we must call it again
self._flatten_parameters()
if self.training:
self.step += 1
bsize = x.size(0)
h1 = torch.zeros(1, bsize, self.rnn_dims, device=device)
h2 = torch.zeros(1, bsize, self.rnn_dims, device=device)
mels, aux = self.upsample(mels)
aux_idx = [self.aux_dims * i for i in range(5)]
a1 = aux[:, :, aux_idx[0]:aux_idx[1]]
a2 = aux[:, :, aux_idx[1]:aux_idx[2]]
a3 = aux[:, :, aux_idx[2]:aux_idx[3]]
a4 = aux[:, :, aux_idx[3]:aux_idx[4]]
x = torch.cat([x.unsqueeze(-1), mels, a1], dim=2)
x = self.I(x)
res = x
x, _ = self.rnn1(x, h1)
x = x + res
res = x
x = torch.cat([x, a2], dim=2)
x, _ = self.rnn2(x, h2)
x = x + res
x = torch.cat([x, a3], dim=2)
x = F.relu(self.fc1(x))
x = torch.cat([x, a4], dim=2)
x = F.relu(self.fc2(x))
return self.fc3(x)
def generate(self, mels, save_path: Union[str, Path, None], batched, target, overlap, mu_law, silent=False):
self.eval()
device = next(self.parameters()).device # use same device as parameters
mu_law = mu_law if self.mode == 'RAW' else False
output = []
start = time.time()
rnn1 = self.get_gru_cell(self.rnn1)
rnn2 = self.get_gru_cell(self.rnn2)
with torch.no_grad():
mels = torch.as_tensor(mels, device=device)
wave_len = (mels.size(-1) - 1) * self.hop_length
mels = self.pad_tensor(mels.transpose(1, 2), pad=self.pad, side='both')
mels, aux = self.upsample(mels.transpose(1, 2))
if batched:
mels = self.fold_with_overlap(mels, target, overlap)
aux = self.fold_with_overlap(aux, target, overlap)
b_size, seq_len, _ = mels.size()
h1 = torch.zeros(b_size, self.rnn_dims, device=device)
h2 = torch.zeros(b_size, self.rnn_dims, device=device)
x = torch.zeros(b_size, 1, device=device)
d = self.aux_dims
aux_split = [aux[:, :, d * i:d * (i + 1)] for i in range(4)]
for i in range(seq_len):
m_t = mels[:, i, :]
a1_t, a2_t, a3_t, a4_t = \
(a[:, i, :] for a in aux_split)
x = torch.cat([x, m_t, a1_t], dim=1)
x = self.I(x)
h1 = rnn1(x, h1)
x = x + h1
inp = torch.cat([x, a2_t], dim=1)
h2 = rnn2(inp, h2)
x = x + h2
x = torch.cat([x, a3_t], dim=1)
x = F.relu(self.fc1(x))
x = torch.cat([x, a4_t], dim=1)
x = F.relu(self.fc2(x))
logits = self.fc3(x)
if self.mode == 'MOL':
sample = sample_from_discretized_mix_logistic(logits.unsqueeze(0).transpose(1, 2))
output.append(sample.view(-1))
# x = torch.FloatTensor([[sample]]).cuda()
x = sample.transpose(0, 1)
elif self.mode == 'RAW':
posterior = F.softmax(logits, dim=1)
distrib = torch.distributions.Categorical(posterior)
sample = 2 * distrib.sample().float() / (self.n_classes - 1.) - 1.
output.append(sample)
x = sample.unsqueeze(-1)
else:
raise RuntimeError("Unknown model mode value - ", self.mode)
if not silent and i % 100 == 0:
self.gen_display(i, seq_len, b_size, start)
output = torch.stack(output).transpose(0, 1)
output = output.cpu().numpy()
output = output.astype(np.float64)
if mu_law:
output = decode_mu_law(output, self.n_classes, False)
if batched:
output = self.xfade_and_unfold(output, target, overlap)
else:
output = output[0]
# Fade-out at the end to avoid signal cutting out suddenly
fade_out = np.linspace(1, 0, 20 * self.hop_length)
output = output[:wave_len]
output[-20 * self.hop_length:] *= fade_out
if save_path is not None:
save_wav(output, save_path)
self.train()
return output
def gen_display(self, i, seq_len, b_size, start):
gen_rate = (i + 1) / (time.time() - start) * b_size / 1000
pbar = progbar(i, seq_len)
msg = f'| {pbar} {i*b_size}/{seq_len*b_size} | Batch Size: {b_size} | Gen Rate: {gen_rate:.1f}kHz | '
stream(msg)
def get_gru_cell(self, gru):
gru_cell = nn.GRUCell(gru.input_size, gru.hidden_size)
gru_cell.weight_hh.data = gru.weight_hh_l0.data
gru_cell.weight_ih.data = gru.weight_ih_l0.data
gru_cell.bias_hh.data = gru.bias_hh_l0.data
gru_cell.bias_ih.data = gru.bias_ih_l0.data
return gru_cell
def pad_tensor(self, x, pad, side='both'):
# NB - this is just a quick method i need right now
# i.e., it won't generalise to other shapes/dims
b, t, c = x.size()
total = t + 2 * pad if side == 'both' else t + pad
padded = torch.zeros(b, total, c, device=x.device)
if side == 'before' or side == 'both':
padded[:, pad:pad + t, :] = x
elif side == 'after':
padded[:, :t, :] = x
return padded
def fold_with_overlap(self, x, target, overlap):
''' Fold the tensor with overlap for quick batched inference.
Overlap will be used for crossfading in xfade_and_unfold()
Args:
x (tensor) : Upsampled conditioning features.
shape=(1, timesteps, features)
target (int) : Target timesteps for each index of batch
overlap (int) : Timesteps for both xfade and rnn warmup
Return:
(tensor) : shape=(num_folds, target + 2 * overlap, features)
Details:
x = [[h1, h2, ... hn]]
Where each h is a vector of conditioning features
Eg: target=2, overlap=1 with x.size(1)=10
folded = [[h1, h2, h3, h4],
[h4, h5, h6, h7],
[h7, h8, h9, h10]]
'''
_, total_len, features = x.size()
# Calculate variables needed
num_folds = (total_len - overlap) // (target + overlap)
extended_len = num_folds * (overlap + target) + overlap
remaining = total_len - extended_len
# Pad if some time steps poking out
if remaining != 0:
num_folds += 1
padding = target + 2 * overlap - remaining
x = self.pad_tensor(x, padding, side='after')
folded = torch.zeros(num_folds, target + 2 * overlap, features, device=x.device)
# Get the values for the folded tensor
for i in range(num_folds):
start = i * (target + overlap)
end = start + target + 2 * overlap
folded[i] = x[:, start:end, :]
return folded
def xfade_and_unfold(self, y, target, overlap):
''' Applies a crossfade and unfolds into a 1d array.
Args:
y (ndarry) : Batched sequences of audio samples
shape=(num_folds, target + 2 * overlap)
dtype=np.float64
overlap (int) : Timesteps for both xfade and rnn warmup
Return:
(ndarry) : audio samples in a 1d array
shape=(total_len)
dtype=np.float64
Details:
y = [[seq1],
[seq2],
[seq3]]
Apply a gain envelope at both ends of the sequences
y = [[seq1_in, seq1_target, seq1_out],
[seq2_in, seq2_target, seq2_out],
[seq3_in, seq3_target, seq3_out]]
Stagger and add up the groups of samples:
[seq1_in, seq1_target, (seq1_out + seq2_in), seq2_target, ...]
'''
num_folds, length = y.shape
target = length - 2 * overlap
total_len = num_folds * (target + overlap) + overlap
# Need some silence for the rnn warmup
silence_len = overlap // 2
fade_len = overlap - silence_len
silence = np.zeros((silence_len), dtype=np.float64)
linear = np.ones((silence_len), dtype=np.float64)
# Equal power crossfade
t = np.linspace(-1, 1, fade_len, dtype=np.float64)
fade_in = np.sqrt(0.5 * (1 + t))
fade_out = np.sqrt(0.5 * (1 - t))
# Concat the silence to the fades
fade_in = np.concatenate([silence, fade_in])
fade_out = np.concatenate([linear, fade_out])
# Apply the gain to the overlap samples
y[:, :overlap] *= fade_in
y[:, -overlap:] *= fade_out
unfolded = np.zeros((total_len), dtype=np.float64)
# Loop to add up all the samples
for i in range(num_folds):
start = i * (target + overlap)
end = start + target + 2 * overlap
unfolded[start:end] += y[i]
return unfolded
def get_step(self):
return self.step.data.item()
def log(self, path, msg):
with open(path, 'a') as f:
print(msg, file=f)
def load(self, path: Union[str, Path]):
# Use device of model params as location for loaded state
device = next(self.parameters()).device
self.load_state_dict(torch.load(path, map_location=device), strict=False)
def save(self, path: Union[str, Path]):
# No optimizer argument because saving a model should not include data
# only relevant in the training process - it should only be properties
# of the model itself. Let caller take care of saving optimzier state.
torch.save(self.state_dict(), path)
def num_params(self, print_out=False):
parameters = filter(lambda p: p.requires_grad, self.parameters())
parameters = sum([np.prod(p.size()) for p in parameters]) / 1_000_000
if print_out:
print('Trainable Parameters: %.3fM' % parameters)
return parameters
def _flatten_parameters(self):
"""Calls `flatten_parameters` on all the rnns used by the WaveRNN. Used
to improve efficiency and avoid PyTorch yelling at us."""
[m.flatten_parameters() for m in self._to_flatten]
|
x = self.conv_in(x)
x = self.batch_norm(x)
x = F.relu(x)
for f in self.layers: x = f(x)
x = self.conv_out(x)
return x
|
ipam.go
|
// Copyright 2018, 2019 VMware, Inc.
// SPDX-License-Identifier: Apache-2.0
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at:
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package endpoint
import (
"context"
"math/rand"
"time"
"github.com/golang/protobuf/ptypes/empty"
"github.com/networkservicemesh/networkservicemesh/controlplane/api/connectioncontext"
"github.com/networkservicemesh/networkservicemesh/controlplane/api/local/connection"
"github.com/networkservicemesh/networkservicemesh/controlplane/api/local/networkservice"
"github.com/networkservicemesh/networkservicemesh/sdk/common"
"github.com/networkservicemesh/networkservicemesh/sdk/prefix_pool"
)
// IpamEndpoint - provides Ipam functionality
type IpamEndpoint struct {
PrefixPool prefix_pool.PrefixPool
}
// Request implements the request handler
// Consumes from ctx context.Context:
// Next
func (ice *IpamEndpoint) Request(ctx context.Context, request *networkservice.NetworkServiceRequest) (*connection.Connection, error) {
/* Exclude the prefixes from the pool of available prefixes */
excludedPrefixes, err := ice.PrefixPool.ExcludePrefixes(request.Connection.GetContext().GetIpContext().GetExcludedPrefixes())
if err != nil {
return nil, err
}
/* Determine whether the pool is IPv4 or IPv6 */
currentIPFamily := connectioncontext.IpFamily_IPV4
if common.IsIPv6(ice.PrefixPool.GetPrefixes()[0]) {
currentIPFamily = connectioncontext.IpFamily_IPV6
}
srcIP, dstIP, prefixes, err := ice.PrefixPool.Extract(request.Connection.Id, currentIPFamily, request.Connection.GetContext().GetIpContext().GetExtraPrefixRequest()...)
if err != nil {
return nil, err
}
/* Release the actual prefixes that were excluded during IPAM */
// TODO - this will vary per Request... so releasing Prefixes globally that are excluded locally
// is incorrect behavior. It should simply *not* draw on those prefixes for this connection.
err = ice.PrefixPool.ReleaseExcludedPrefixes(excludedPrefixes)
if err != nil {
return nil, err
}
// Update source/dst IP's
request.GetConnection().GetContext().GetIpContext().SrcIpAddr = srcIP.String()
request.GetConnection().GetContext().GetIpContext().DstIpAddr = dstIP.String()
request.GetConnection().GetContext().GetIpContext().ExtraPrefixes = prefixes
if Next(ctx) != nil {
return Next(ctx).Request(ctx, request)
}
return request.GetConnection(), nil
}
// Close implements the close handler
// Consumes from ctx context.Context:
// Next
func (ice *IpamEndpoint) Close(ctx context.Context, connection *connection.Connection) (*empty.Empty, error) {
prefix, requests, err := ice.PrefixPool.GetConnectionInformation(connection.GetId())
Log(ctx).Infof("Release connection prefixes network: %s extra requests: %v", prefix, requests)
if err != nil {
Log(ctx).Errorf("Error: %v", err)
}
err = ice.PrefixPool.Release(connection.GetId())
if err != nil {
Log(ctx).Error("Release error: ", err)
}
if Next(ctx) != nil {
return Next(ctx).Close(ctx, connection)
}
return &empty.Empty{}, nil
}
// Name returns the composite name
func (ice *IpamEndpoint) Name() string {
return "ipam"
}
// NewIpamEndpoint creates a IpamEndpoint
func NewIpamEndpoint(configuration *common.NSConfiguration) *IpamEndpoint {
// ensure the env variables are processed
if configuration == nil {
configuration = &common.NSConfiguration{}
}
pool, err := prefix_pool.NewPrefixPool(configuration.IPAddress)
if err != nil
|
rand.Seed(time.Now().UTC().UnixNano())
self := &IpamEndpoint{
PrefixPool: pool,
}
return self
}
|
{
panic(err.Error())
}
|
Whiskers_Roam_Expanded.py
|
# Whiskers_Roam_Expanded.py
from cyberbot import *
bot(22).tone(2000, 300)
while True:
left = bot(7).read_digital()
right = bot(9).read_digital()
if left == 1 and right == 1: #Go forward
bot(18).servo_speed(75)
bot(19).servo_speed(-75)
display.show(Image.ARROW_S)
bot(15).write_digital(0)
bot(0).write_digital(0)
elif left == 1 and right == 0: #Obstacle on right
bot(18).servo_speed(-75) #back up for 1s, turn left
bot(19).servo_speed(75)
|
display.show(Image.ARROW_N)
bot(15).write_digital(0)
bot(0).write_digital(1)
sleep(1000)
bot(18).servo_speed(-75)
bot(19).servo_speed(-75)
display.show(Image.ARROW_E)
sleep(600)
elif left == 0 and right ==1: #Obstacle on left
bot(18).servo_speed(-75) #backup for 1s, turn right
bot(19).servo_speed(75)
display.show(Image.ARROW_N)
bot(15).write_digital(1)
bot(0).write_digital(0)
sleep(1000)
bot(18).servo_speed(75)
bot(19).servo_speed(75)
display.show(Image.ARROW_W)
sleep(600)
elif left == 0 and right == 0: #Obstacle on left + right
bot(18).servo_speed(-75) #backup for 1s, turn
bot(19).servo_speed(75)
display.show(Image.ARROW_N)
bot(15).write_digital(1)
bot(0).write_digital(1)
sleep(1000)
bot(18).servo_speed(75)
bot(19).servo_speed(75)
display.show(Image.ARROW_W)
sleep(1000)
| |
inspectors.js
|
'use strict';
/*jshint latedef:false */
var AssertionError = require('assert').AssertionError;
var ownUtils = require('./utilities');
var Report = require('./report');
function ensureEqual(context, actual, expected) {
ensureEqualValues(
context,
typeof actual,
typeof expected,
'types');
if (ownUtils.isObject(actual) &&
ownUtils.isObject(expected)) {
ensureEqualValues(
context,
Object.getPrototypeOf(actual),
Object.getPrototypeOf(expected),
'prototypes');
|
} else if (ownUtils.isInstanceOf(Buffer, actual, expected)) {
ensureEqualObjects(context, actual, expected, {
exclude: [ 'parent', 'offset' ]
});
} else {
ensureEqualObjects(context, actual, expected);
}
} else {
ensureEqualValues(context, actual, expected, 'values');
}
}
function ensureEqualValues(context, actual, expected, reason) {
if (!(Number.isNaN(actual) &&
Number.isNaN(expected))) {
if (actual !== expected) {
throw new AssertionError({
actual: context.actual,
expected: context.expected,
operator: 'is paranoidly equal to',
message: new Report(context, actual, expected, reason)
});
}
}
}
function ensureEqualDates(context, actual, expected) {
ensureEqualValues(
context,
actual.getTime(),
expected.getTime(),
'date_timestamps');
ensureEqualObjects(
context,
actual,
expected);
}
function ensureEqualObjects(context, actual, expected, options) {
var actualKeys, expectedKeys, includeKeys, excludeKeys,
index, length, currentKey;
if (!ownUtils.isNothing(options)) {
includeKeys = options.include;
excludeKeys = options.exclude;
}
actualKeys = ownUtils.collectKeys(actual, includeKeys, excludeKeys);
expectedKeys = ownUtils.collectKeys(expected, includeKeys, excludeKeys);
ensureEqualValues(
context,
actualKeys.length,
expectedKeys.length,
'object_property_amounts');
actualKeys.sort();
expectedKeys.sort();
length = actualKeys.length;
for (index = 0; index < length; index += 1) {
ensureEqualValues(
context,
actualKeys[index],
expectedKeys[index],
'object_property_names');
}
for (index = 0; index < length; index += 1) {
currentKey = actualKeys[index];
ensureEqual(
context.descent(currentKey),
actual[currentKey],
expected[currentKey]);
}
}
module.exports.ensureEqual = ensureEqual;
module.exports.ensureEqualValues = ensureEqualValues;
module.exports.ensureEqualDates = ensureEqualDates;
module.exports.ensureEqualObjects = ensureEqualObjects;
|
if (ownUtils.isInstanceOf(Date, actual, expected)) {
ensureEqualDates(context, actual, expected);
|
index.test.js
|
// import React from 'react';
// import { shallow } from 'enzyme';
// import { Business } from '../index';
describe('<Business />', () => {
|
expect(true).toEqual(false);
});
});
|
it('Expect to have unit tests specified', () => {
|
slack.go
|
/*
Copyright 2016 Skippbox, Ltd.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package cmd
import (
"github.com/spf13/cobra"
"github.com/bitnami-labs/kubewatch/config"
"github.com/Sirupsen/logrus"
)
// slackConfigCmd represents the slack subcommand
var slackConfigCmd = &cobra.Command{
Use: "slack FLAG",
Short: "specific slack configuration",
Long: `specific slack configuration`,
Run: func(cmd *cobra.Command, args []string){
conf, err := config.New()
if err != nil {
logrus.Fatal(err)
}
token, err := cmd.Flags().GetString("token")
if err == nil {
if len(token) > 0 {
conf.Handler.Slack.Token = token
}
} else {
logrus.Fatal(err)
}
channel, err := cmd.Flags().GetString("channel")
if err == nil {
if len(channel) > 0 {
conf.Handler.Slack.Channel = channel
}
} else {
logrus.Fatal(err)
}
if err = conf.Write(); err != nil {
logrus.Fatal(err)
}
},
}
func init()
|
{
slackConfigCmd.Flags().StringP("channel", "c", "", "Specify slack channel")
slackConfigCmd.Flags().StringP("token", "t", "", "Specify slack token")
}
|
|
cache.py
|
import io
import zipfile
from django.core.cache import cache
from django.utils.translation import ugettext as _
from soil import DownloadBase
from corehq.apps.hqmedia.models import (
CommCareAudio,
CommCareImage,
CommCareVideo,
)
class BaseMultimediaStatusCache(object):
upload_type = None
cache_expiry = 60 * 60 # defaults to one hour
def __init__(self, processing_id):
self.processing_id = processing_id
self.in_celery = False
self.complete = False
self.progress = 0
self.errors = []
if self.upload_type is None:
raise NotImplementedError("You need to specify an upload type.")
|
'processing_id': self.processing_id,
'progress': self.progress,
}
def save(self):
cache.set(self.get_cache_key(self.processing_id), self, self.cache_expiry)
def mark_with_error(self, error_str):
self.complete = True
self.errors.append(error_str)
self.save()
def get_response(self):
"""
Response that gets sent back to the upload controller.
"""
return {
'type': self.upload_type,
'in_celery': self.in_celery,
'complete': self.complete,
'progress': self.progress,
'errors': self.errors,
'processing_id': self.processing_id,
}
@classmethod
def get_cache_key(cls, processing_id):
raise NotImplementedError("You need to specify a cache_key format for the status.")
@classmethod
def get(cls, processing_id):
return cache.get(cls.get_cache_key(processing_id))
class BulkMultimediaStatusCache(BaseMultimediaStatusCache):
upload_type = "zip"
def __init__(self, processing_id):
super(BulkMultimediaStatusCache, self).__init__(processing_id)
self.skipped_files = []
self.unmatched_files = []
self.matched_files = dict((m.__name__, []) for m in self.allowed_media)
self.total_files = None
self.processed_files = None
@property
def allowed_media(self):
return [CommCareAudio, CommCareImage, CommCareVideo]
def get_response(self):
response = super(BulkMultimediaStatusCache, self).get_response()
response.update({
'unmatched_files': self.unmatched_files,
'matched_files': self.matched_files,
'total_files': self.total_files,
'processed_files': self.processed_files,
'skipped_files': self.skipped_files,
})
return response
def update_progress(self, num_files_processed):
if self.total_files is None:
raise ValueError("You need to set total_files before you can update progress.")
self.processed_files = num_files_processed
self.progress = int(100 * (self.processed_files / self.total_files))
if self.progress >= 100:
self.complete = True
self.save()
def add_skipped_path(self, path, mimetype):
self.skipped_files.append({
'path': path,
'mimetype': mimetype,
})
def add_unmatched_path(self, path, reason):
self.unmatched_files.append({
'path': path,
'reason': reason,
})
def add_matched_path(self, media_class, media_info):
if media_class.__name__ in self.matched_files:
self.matched_files[media_class.__name__].append(media_info)
else:
self.add_unmatched_path(media_info['path'],
_("Not a bulk-upload supported CommCareMedia type: %s" % media_class.__name__))
def _get_upload_file(self):
saved_file = io.BytesIO()
try:
saved_ref = DownloadBase.get(self.processing_id)
data = saved_ref.get_content()
except Exception as e:
self.mark_with_error(_("Could not fetch cached bulk upload file. Error: %s." % e))
return
saved_file.write(data)
saved_file.seek(0)
return saved_file
def get_upload_zip(self):
saved_file = self._get_upload_file()
try:
uploaded_zip = zipfile.ZipFile(saved_file)
except Exception as e:
self.mark_with_error(_("Error opening file as zip file: %s" % e))
return
if uploaded_zip.testzip():
self.mark_with_error(_("Error encountered processing Zip File. File doesn't look valid."))
return
return uploaded_zip
@classmethod
def get_cache_key(cls, processing_id):
return "MMBULK_%s" % processing_id
class BulkMultimediaStatusCacheNfs(BulkMultimediaStatusCache):
def __init__(self, processing_id, file_path):
super(BulkMultimediaStatusCacheNfs, self).__init__(processing_id)
self.file_path = file_path
def _get_upload_file(self):
return self.file_path
|
def __str__(self):
return "Status of process id %(processing_id)s: %(progress)d%%" % {
|
ApduDataExtDomainAddressWrite.go
|
//
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements. See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership. The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the License for the
// specific language governing permissions and limitations
// under the License.
//
package model
import (
"encoding/xml"
"github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
"io"
)
// Code generated by build-utils. DO NOT EDIT.
// The data-structure of this message
type ApduDataExtDomainAddressWrite struct {
Parent *ApduDataExt
}
// The corresponding interface
type IApduDataExtDomainAddressWrite interface {
LengthInBytes() uint16
LengthInBits() uint16
Serialize(io utils.WriteBuffer) error
xml.Marshaler
xml.Unmarshaler
}
///////////////////////////////////////////////////////////
// Accessors for discriminator values.
///////////////////////////////////////////////////////////
func (m *ApduDataExtDomainAddressWrite) ExtApciType() uint8 {
return 0x20
}
func (m *ApduDataExtDomainAddressWrite) InitializeParent(parent *ApduDataExt) {
}
func
|
() *ApduDataExt {
child := &ApduDataExtDomainAddressWrite{
Parent: NewApduDataExt(),
}
child.Parent.Child = child
return child.Parent
}
func CastApduDataExtDomainAddressWrite(structType interface{}) *ApduDataExtDomainAddressWrite {
castFunc := func(typ interface{}) *ApduDataExtDomainAddressWrite {
if casted, ok := typ.(ApduDataExtDomainAddressWrite); ok {
return &casted
}
if casted, ok := typ.(*ApduDataExtDomainAddressWrite); ok {
return casted
}
if casted, ok := typ.(ApduDataExt); ok {
return CastApduDataExtDomainAddressWrite(casted.Child)
}
if casted, ok := typ.(*ApduDataExt); ok {
return CastApduDataExtDomainAddressWrite(casted.Child)
}
return nil
}
return castFunc(structType)
}
func (m *ApduDataExtDomainAddressWrite) GetTypeName() string {
return "ApduDataExtDomainAddressWrite"
}
func (m *ApduDataExtDomainAddressWrite) LengthInBits() uint16 {
return m.LengthInBitsConditional(false)
}
func (m *ApduDataExtDomainAddressWrite) LengthInBitsConditional(lastItem bool) uint16 {
lengthInBits := uint16(m.Parent.ParentLengthInBits())
return lengthInBits
}
func (m *ApduDataExtDomainAddressWrite) LengthInBytes() uint16 {
return m.LengthInBits() / 8
}
func ApduDataExtDomainAddressWriteParse(io utils.ReadBuffer) (*ApduDataExt, error) {
// Create a partially initialized instance
_child := &ApduDataExtDomainAddressWrite{
Parent: &ApduDataExt{},
}
_child.Parent.Child = _child
return _child.Parent, nil
}
func (m *ApduDataExtDomainAddressWrite) Serialize(io utils.WriteBuffer) error {
ser := func() error {
io.PushContext("ApduDataExtDomainAddressWrite")
io.PopContext("ApduDataExtDomainAddressWrite")
return nil
}
return m.Parent.SerializeParent(io, m, ser)
}
func (m *ApduDataExtDomainAddressWrite) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
var token xml.Token
var err error
foundContent := false
token = start
for {
switch token.(type) {
case xml.StartElement:
foundContent = true
tok := token.(xml.StartElement)
switch tok.Name.Local {
}
}
token, err = d.Token()
if err != nil {
if err == io.EOF && foundContent {
return nil
}
return err
}
}
}
func (m *ApduDataExtDomainAddressWrite) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
return nil
}
func (m ApduDataExtDomainAddressWrite) String() string {
return string(m.Box("", 120))
}
func (m ApduDataExtDomainAddressWrite) Box(name string, width int) utils.AsciiBox {
boxName := "ApduDataExtDomainAddressWrite"
if name != "" {
boxName += "/" + name
}
childBoxer := func() []utils.AsciiBox {
boxes := make([]utils.AsciiBox, 0)
return boxes
}
return m.Parent.BoxParent(boxName, width, childBoxer)
}
|
NewApduDataExtDomainAddressWrite
|
search.api.ts
|
//
import * as eyes from 'eyes'
import * as _ from 'lodash'
import * as core from '../../common/core'
import fastify from '../fastify'
import * as boom from 'boom'
import * as fuzzy from 'fuzzy'
import * as stores from '../adapters/stores'
fastify.route({
method: 'POST',
url: '/api/search',
schema: {
body: {
type: 'object',
properties: { query: { type: 'string' }, },
required: ['query'],
},
},
handler: async function(request, reply) {
let query = core.string.clean(request.body.query, true)
let results = await stores.search(query)
results.forEach(function(result) {
let desc = result.apple ? result.description : result.summary
|
results.sort((a, b) => b.fuzzy - a.fuzzy)
return results
},
})
|
let input = core.string.clean(result.title + ' ' + desc, true)
let match = fuzzy.match(query, input)
result.fuzzy = match ? match.score : 0
})
|
training_loop.py
|
# Copyright The PyTorch Lightning team.
#
# 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.
from contextlib import contextmanager
from copy import copy, deepcopy
import numpy as np
import torch
import torch.distributed as torch_distrib
from pytorch_lightning.callbacks import ModelCheckpoint
from pytorch_lightning.core.lightning import LightningModule
from pytorch_lightning.core.memory import ModelSummary
from pytorch_lightning.core.step_result import EvalResult, Result
from pytorch_lightning.trainer.states import TrainerState
from pytorch_lightning.trainer.supporters import TensorRunningAccum, Accumulator
from pytorch_lightning.utilities import parsing, AMPType
from pytorch_lightning.utilities.distributed import rank_zero_info, rank_zero_warn
from pytorch_lightning.utilities.exceptions import MisconfigurationException
from pytorch_lightning.utilities.memory import recursive_detach
from pytorch_lightning.utilities.model_utils import is_overridden
from pytorch_lightning.utilities.parsing import AttributeDict
from pytorch_lightning.utilities.warning_utils import WarningCache
class TrainLoop:
def __init__(self, trainer):
self.trainer = trainer
self.early_stopping_accumulator = None
self.checkpoint_accumulator = None
self.accumulated_loss = None
self.warning_cache = WarningCache()
self._teardown_already_run = False
self.running_loss = TensorRunningAccum(window_length=20)
self.automatic_optimization = True
self._curr_step_result = None
self._cur_grad_norm_dict = None
def on_trainer_init(
self, max_epochs, min_epochs, max_steps, min_steps, num_sanity_val_steps, automatic_optimization
):
self.trainer.global_step = 0
self.trainer.current_epoch = 0
self.trainer.interrupted = False
self.trainer.should_stop = False
self.trainer._state = TrainerState.INITIALIZING
self.trainer.total_batch_idx = 0
self.trainer.batch_idx = 0
self.trainer.num_training_batches = 0
self.trainer.train_dataloader = None
self.automatic_optimization = automatic_optimization
self.trainer.max_epochs = max_epochs
self.trainer.min_epochs = min_epochs
self.trainer.max_steps = max_steps
self.trainer.min_steps = min_steps
if num_sanity_val_steps == -1:
self.trainer.num_sanity_val_steps = float("inf")
else:
self.trainer.num_sanity_val_steps = num_sanity_val_steps
@property
def num_optimizers(self):
num_optimizers = len(self.get_optimizers_iterable())
return num_optimizers
def should_skip_training(self):
if self.trainer.current_epoch >= self.trainer.max_epochs:
return True
if self.trainer.limit_train_batches == 0:
return True
return False
def on_train_start(self):
# clear cache before training
if self.trainer.on_gpu and self.trainer.root_gpu is not None:
# use context because of:
# https://discuss.pytorch.org/t/out-of-memory-when-i-use-torch-cuda-empty-cache/57898
with torch.cuda.device(f"cuda:{self.trainer.root_gpu}"):
torch.cuda.empty_cache()
# hook
self.trainer.call_hook("on_train_start")
def setup_fit(self, model, train_dataloader, val_dataloaders, datamodule):
# bind logger and other properties
self.trainer.model_connector.copy_trainer_model_properties(model)
# clean hparams
if hasattr(model, "hparams"):
parsing.clean_namespace(model.hparams)
# links data to the trainer
self.trainer.data_connector.attach_data(model, train_dataloader, val_dataloaders, datamodule)
# check that model is configured correctly
self.trainer.config_validator.verify_loop_configurations(model)
def setup_training(self, model: LightningModule):
"""Sanity check a few things before starting actual training.
Args:
model: The model to run sanity test on.
"""
# --------------------------
# Setup??
# --------------------------
ref_model = model
if self.trainer.data_parallel:
ref_model = model.module
# set the ranks and devices
self.trainer.accelerator_backend.dist.rank = self.trainer.global_rank
self.trainer.accelerator_backend.dist.device = ref_model.device
# give model convenience properties
ref_model.trainer = self.trainer
# set local properties on the model
self.trainer.model_connector.copy_trainer_model_properties(ref_model)
# init amp. Must be done here instead of __init__ to allow ddp to work
if self.trainer.amp_backend == AMPType.NATIVE and self.trainer.precision == 16 and not self.trainer.use_tpu:
self.trainer.scaler = torch.cuda.amp.GradScaler()
# log hyper-parameters
if self.trainer.logger is not None:
# save exp to get started (this is where the first experiment logs are written)
self.trainer.logger.log_hyperparams(ref_model.hparams_initial)
self.trainer.logger.log_graph(ref_model)
self.trainer.logger.save()
# wait for all to join if on distributed
self.trainer.accelerator_backend.barrier("setup_training")
# register auto-resubmit when on SLURM
self.trainer.slurm_connector.register_slurm_signal_handlers()
# --------------------------
# Pre-train
# --------------------------
# on pretrain routine start
self.trainer.on_pretrain_routine_start(ref_model)
if self.trainer.is_function_implemented("on_pretrain_routine_start"):
ref_model.on_pretrain_routine_start()
# print model summary
if self.trainer.is_global_zero and self.trainer.weights_summary is not None and not self.trainer.testing:
if self.trainer.weights_summary in ModelSummary.MODES:
ref_model.summarize(mode=self.trainer.weights_summary)
else:
raise MisconfigurationException("weights_summary can be None, " + ", ".join(ModelSummary.MODES))
# track model now.
# if cluster resets state, the model will update with the saved weights
self.trainer.model = model
# restore training and model before hpc is called
self.trainer.checkpoint_connector.restore_weights(model)
# on pretrain routine end
self.trainer.on_pretrain_routine_end(ref_model)
if self.trainer.is_function_implemented("on_pretrain_routine_end"):
ref_model.on_pretrain_routine_end()
def on_train_end(self):
if self._teardown_already_run:
return
self._teardown_already_run = True
# trigger checkpoint check. need to temporarily decrease the global step to avoid saving duplicates
# when a checkpoint was saved at the last step
self.trainer.global_step -= 1
self.check_checkpoint_callback(should_save=True, is_last=True)
self.trainer.global_step += 1
# hook
self.trainer.call_hook("on_train_end")
# kill loggers
if self.trainer.logger is not None:
self.trainer.logger.finalize("success")
# summarize profile results
if self.trainer.global_rank == 0:
self.trainer.profiler.describe()
# give accelerators a chance to finish
self.trainer.accelerator_backend.on_train_end()
# clear mem
if self.trainer.on_gpu:
model = self.trainer.get_model()
model.cpu()
torch.cuda.empty_cache()
def check_checkpoint_callback(self, should_save, is_last=False):
# TODO bake this logic into the checkpoint callback
if should_save and self.trainer.checkpoint_connector.has_trained:
checkpoint_callbacks = [c for c in self.trainer.callbacks if isinstance(c, ModelCheckpoint)]
if is_last and any(c.save_last for c in checkpoint_callbacks):
rank_zero_info("Saving latest checkpoint...")
model = self.trainer.get_model()
[c.on_validation_end(self.trainer, model) for c in checkpoint_callbacks]
def on_train_epoch_start(self, epoch):
# update training progress in trainer
self.trainer.current_epoch = epoch
model = self.trainer.get_model()
# reset train dataloader
if self.trainer.reload_dataloaders_every_epoch:
self.trainer.reset_train_dataloader(model)
# set seed for distributed sampler (enables shuffling for each epoch)
try:
self.trainer.train_dataloader.sampler.set_epoch(epoch)
except Exception:
pass
# changing gradient according accumulation_scheduler
self.trainer.accumulation_scheduler.on_epoch_start(self.trainer, self.trainer.get_model())
# stores accumulated grad fractions per batch
self.accumulated_loss = TensorRunningAccum(window_length=self.trainer.accumulate_grad_batches)
# structured result accumulators for callbacks
self.early_stopping_accumulator = Accumulator()
self.checkpoint_accumulator = Accumulator()
# hook
self.trainer.call_hook("on_epoch_start")
self.trainer.call_hook("on_train_epoch_start")
def on_train_batch_end(self, epoch_output, epoch_end_outputs, batch, batch_idx, dataloader_idx):
# hook
self.trainer.call_hook('on_batch_end')
self.trainer.call_hook('on_train_batch_end', epoch_end_outputs, batch, batch_idx, dataloader_idx)
# figure out what to track for epoch end
self.track_epoch_end_reduce_metrics(epoch_output, epoch_end_outputs)
# reset batch logger internals
self.trainer.logger_connector.on_train_batch_end()
def reset_train_val_dataloaders(self, model):
if not self.trainer.reload_dataloaders_every_epoch:
self.trainer.reset_train_dataloader(model)
if self.trainer.val_dataloaders is None and not self.trainer.reload_dataloaders_every_epoch:
self.trainer.reset_val_dataloader(model)
def track_epoch_end_reduce_metrics(self, epoch_output, epoch_end_outputs):
# track the outputs to reduce at the end of the epoch
for opt_idx, opt_outputs in enumerate(epoch_end_outputs):
# with 1 step (no tbptt) don't use a sequence at epoch end
if isinstance(opt_outputs, list) and len(opt_outputs) == 1 and not isinstance(opt_outputs[0], Result):
opt_outputs = opt_outputs[0]
epoch_output[opt_idx].append(opt_outputs)
def get_optimizers_iterable(self):
"""
Generates an iterable with (idx, optimizer) for each optimizer.
"""
if not self.trainer.optimizer_frequencies:
# call training_step once per optimizer
return list(enumerate(self.trainer.optimizers))
optimizer_freq_cumsum = np.cumsum(self.trainer.optimizer_frequencies)
optimizers_loop_length = optimizer_freq_cumsum[-1]
current_place_in_loop = self.trainer.total_batch_idx % optimizers_loop_length
# find optimzier index by looking for the first {item > current_place} in the cumsum list
opt_idx = np.argmax(optimizer_freq_cumsum > current_place_in_loop)
return [[opt_idx, self.trainer.optimizers[opt_idx]]]
def on_after_backward(self, training_step_output, batch_idx, untouched_loss):
is_result_obj = isinstance(training_step_output, Result)
if is_result_obj:
training_step_output.detach()
else:
training_step_output.batch_loss = training_step_output.batch_loss.detach()
# insert after step hook
self.trainer.call_hook("on_after_backward")
# when in dev debugging track the losses
self.trainer.dev_debugger.track_train_loss_history(batch_idx, untouched_loss.detach())
def
|
(self, training_step_output):
if isinstance(training_step_output, torch.Tensor) and not self.automatic_optimization:
if training_step_output.grad_fn is None:
# TODO: Find why - RuntimeError: Expected to mark a variable ready only once ...
raise MisconfigurationException("In manual optimization, `training_step` should not return a Tensor")
def training_step(self, split_batch, batch_idx, opt_idx, hiddens):
# give the PL module a result for logging
model_ref = self.trainer.get_model()
with self.trainer.profiler.profile("model_forward"):
args = self.build_train_args(split_batch, batch_idx, opt_idx, hiddens)
# manually capture logged metrics
model_ref._current_fx_name = 'training_step'
training_step_output = self.trainer.accelerator_backend.training_step(args)
self.trainer.logger_connector.cache_logged_metrics()
self._check_training_step_output(training_step_output)
training_step_output = self.trainer.call_hook("training_step_end", training_step_output)
training_step_output_for_epoch_end, training_step_output = self._process_training_step_output(
training_step_output, split_batch
)
is_result_obj = isinstance(training_step_output, Result)
if training_step_output_for_epoch_end is None:
return None
# enable empty loss when using manual opt
closure_loss = None
untouched_loss = None
if self.trainer.train_loop.automatic_optimization:
# accumulate loss
# (if accumulate_grad_batches = 1 no effect)
if is_result_obj:
closure_loss = training_step_output.minimize
else:
closure_loss = training_step_output.batch_loss
closure_loss = closure_loss / self.trainer.accumulate_grad_batches
# the loss will get scaled for amp. avoid any modifications to it
untouched_loss = closure_loss.detach().clone()
# result
result = AttributeDict(
closure_loss=closure_loss,
loss=untouched_loss,
training_step_output=training_step_output,
training_step_output_for_epoch_end=training_step_output_for_epoch_end,
hiddens=training_step_output.hiddens,
)
return result
def _process_training_step_output(self, training_step_output, split_batch):
training_step_output_for_epoch_end = training_step_output
# enable validation_step return None
if training_step_output_for_epoch_end is None:
return None, None
# -----------------------------------------
# process result return (DEPRECATE in 1.0)
# -----------------------------------------
if isinstance(training_step_output, Result):
training_step_output_for_epoch_end = self._process_result(training_step_output, split_batch)
return training_step_output_for_epoch_end, training_step_output
# -----------------------------------------
# process hybrid (1.0)
# -----------------------------------------
# no need for these checks in 1.0.0
# TODO: remove checks in 1.0.0
is_tensor = isinstance(training_step_output_for_epoch_end, torch.Tensor)
is_1_0_output = is_tensor or ("log" not in training_step_output and "progress_bar" not in training_step_output)
if is_1_0_output:
return self._process_training_step_output_1_0(training_step_output, split_batch)
# -----------------------------------------
# process old dict (deprecate 1.0)
# -----------------------------------------
training_step_output = self.trainer.process_dict_result(training_step_output, train=True)
training_step_output = AttributeDict(
batch_loss=training_step_output[0],
pbar_on_batch_end=training_step_output[1],
log_metrics=training_step_output[2],
callback_metrics=training_step_output[3],
hiddens=training_step_output[4],
)
# if the user decides to finally reduce things in epoch_end, save raw output without graphs
if isinstance(training_step_output_for_epoch_end, torch.Tensor):
training_step_output_for_epoch_end = training_step_output_for_epoch_end.detach()
else:
training_step_output_for_epoch_end = recursive_detach(training_step_output_for_epoch_end)
return training_step_output_for_epoch_end, training_step_output
def _process_training_step_output_1_0(self, training_step_output, split_batch):
result = self.trainer.get_model()._results
loss = None
hiddens = None
# handle dict return
if isinstance(training_step_output, dict):
loss = training_step_output.pop("loss", None)
hiddens = training_step_output.pop("hiddens", None)
result["extra"] = training_step_output
# handle scalar return
elif isinstance(training_step_output, torch.Tensor):
loss = training_step_output
result["extra"] = {}
# map to results under the hood
result.minimize = loss
result.hiddens = hiddens
# track batch for manual reduction with result
result.track_batch_size(len(split_batch))
# track metrics without grads for epoch reduction
training_step_output_for_epoch_end = copy(result)
training_step_output_for_epoch_end.detach()
if self.trainer.move_metrics_to_cpu:
training_step_output_for_epoch_end.cpu()
# what flows back into the system
training_step_output = result
return training_step_output_for_epoch_end, training_step_output
def _process_result(self, training_step_output, split_batch):
training_step_output.track_batch_size(len(split_batch))
m = """
TrainResult and EvalResult were deprecated in 0.9.1 and support will drop in 1.0.0.
Use self.log and .write from the LightningModule to log metrics and write predictions.
training_step can now only return a scalar (for the loss) or a dictionary with anything you want.
Option 1:
return loss
Option 2:
return {'loss': loss, 'anything_else': ...}
Option 3:
return {'loss': loss, 'hiddens': hiddens, 'anything_else': ...}
"""
rank_zero_warn(m)
# don't allow EvalResult in the training_step
if isinstance(training_step_output, EvalResult):
raise MisconfigurationException(
"training_step cannot return EvalResult, " "use a dict or TrainResult instead"
)
training_step_output_for_epoch_end = copy(training_step_output)
training_step_output_for_epoch_end.detach()
return training_step_output_for_epoch_end
def optimizer_step(self, optimizer, opt_idx, batch_idx, train_step_and_backward_closure):
with self.trainer.profiler.profile("optimizer_step"):
# optimizer step lightningModule hook
self.trainer.accelerator_backend.optimizer_step(
optimizer, batch_idx, opt_idx, train_step_and_backward_closure
)
def on_before_zero_grad(self, optimizer):
self.trainer.call_hook('on_before_zero_grad', optimizer)
def optimizer_zero_grad(self, batch_idx, optimizer, opt_idx):
self.trainer.accelerator_backend.optimizer_zero_grad(batch_idx, optimizer, opt_idx)
def track_and_norm_grad(self, optimizer):
# track gradient norms
grad_norm_dic = self._track_gradient_norm()
# clip gradients
self.trainer.accelerator_backend.clip_gradients(optimizer)
self._cur_grad_norm_dict = grad_norm_dic
def _track_gradient_norm(self):
grad_norm_dict = {}
if (self.trainer.global_step + 1) % self.trainer.log_every_n_steps == 0:
if float(self.trainer.track_grad_norm) > 0:
model = self.trainer.get_model()
grad_norm_dict = model.grad_norm(self.trainer.track_grad_norm)
return grad_norm_dict
def process_hiddens(self, opt_closure_result):
hiddens = opt_closure_result.hiddens
if isinstance(opt_closure_result.training_step_output, Result):
opt_closure_result.training_step_output_for_epoch_end.drop_hiddens()
return hiddens
def tbptt_split_batch(self, batch):
splits = [batch]
if self.trainer.truncated_bptt_steps is not None:
model_ref = self.trainer.get_model()
with self.trainer.profiler.profile("tbptt_split_batch"):
splits = model_ref.tbptt_split_batch(batch, self.trainer.truncated_bptt_steps)
return splits
def run_training_epoch(self):
# get model
model = self.trainer.get_model()
# modify dataloader if needed (ddp, etc...)
train_dataloader = self.trainer.accelerator_backend.process_dataloader(self.trainer.train_dataloader)
# track epoch output
epoch_output = [[] for _ in range(self.num_optimizers)]
# enable profiling for the dataloader
train_dataloader = self.trainer.data_connector.get_profiled_train_dataloader(train_dataloader)
dataloader_idx = 0
should_check_val = False
for batch_idx, (batch, is_last_batch) in train_dataloader:
self.trainer.batch_idx = batch_idx
# ------------------------------------
# TRAINING_STEP + TRAINING_STEP_END
# ------------------------------------
batch_output = self.run_training_batch(batch, batch_idx, dataloader_idx)
# when returning -1 from train_step, we end epoch early
if batch_output.signal == -1:
break
# only track outputs when user implements training_epoch_end
# otherwise we will build up unnecessary memory
epoch_end_outputs = self.process_train_step_outputs(
batch_output.training_step_output_for_epoch_end,
self.early_stopping_accumulator,
self.checkpoint_accumulator,
)
# hook
# TODO: add outputs to batches
self.on_train_batch_end(epoch_output, epoch_end_outputs, batch, batch_idx, dataloader_idx)
# -----------------------------------------
# SAVE METRICS TO LOGGERS
# -----------------------------------------
self.trainer.logger_connector.log_train_step_metrics(batch_output)
# -----------------------------------------
# VALIDATE IF NEEDED + CHECKPOINT CALLBACK
# -----------------------------------------
should_check_val = self.should_check_val_fx(batch_idx, is_last_batch)
if should_check_val:
self.trainer.run_evaluation(test_mode=False)
# reset stage to train
self.trainer.logger_connector.set_stage("train")
# -----------------------------------------
# SAVE LOGGERS (ie: Tensorboard, etc...)
# -----------------------------------------
self.save_loggers_on_train_batch_end()
# update LR schedulers
monitor_metrics = deepcopy(self.trainer.logger_connector.callback_metrics)
self.update_train_loop_lr_schedulers(monitor_metrics=monitor_metrics)
self.trainer.checkpoint_connector.has_trained = True
# max steps reached, end training
if self.trainer.max_steps is not None and self.trainer.max_steps == self.trainer.global_step + 1:
accumulation_done = self._accumulated_batches_reached()
# Ensure accumulation across batches has completed before breaking loop
if accumulation_done:
break
# end epoch early
# stop when the flag is changed or we've gone past the amount
# requested in the batches
if self.trainer.should_stop:
break
self.trainer.total_batch_idx += 1
# stop epoch if we limited the number of training batches
if (batch_idx + 1) >= self.trainer.num_training_batches:
break
# progress global step according to grads progress
self.increment_accumulated_grad_global_step()
# epoch end hook
self.run_on_epoch_end_hook(epoch_output)
# log epoch metrics
self.trainer.logger_connector.log_train_epoch_end_metrics(
epoch_output,
self.checkpoint_accumulator,
self.early_stopping_accumulator,
self.num_optimizers
)
# when no val loop is present or fast-dev-run still need to call checkpoints
self.check_checkpoint_callback(not (should_check_val or is_overridden('validation_step', model)))
# increment the global step once
# progress global step according to grads progress
self.increment_accumulated_grad_global_step()
def run_training_batch(self, batch, batch_idx, dataloader_idx):
# track grad norms
grad_norm_dic = {}
# bookkeeping
using_results_obj = False
self.trainer.hiddens = None
# track all outputs across time and num of optimizers
batch_outputs = [[] for _ in range(len(self.get_optimizers_iterable()))]
if batch is None:
return AttributeDict(signal=0, grad_norm_dic=grad_norm_dic)
# hook
response = self.trainer.call_hook("on_batch_start")
if response == -1:
return AttributeDict(signal=-1, grad_norm_dic=grad_norm_dic)
# hook
response = self.trainer.call_hook("on_train_batch_start", batch, batch_idx, dataloader_idx)
if response == -1:
return AttributeDict(signal=-1, grad_norm_dic=grad_norm_dic)
# lightning module hook
splits = self.tbptt_split_batch(batch)
for split_idx, split_batch in enumerate(splits):
# create an iterable for optimizers and loop over them
for opt_idx, optimizer in self.prepare_optimizers():
# toggle model params + set info to logger_connector
self.run_train_split_start(split_idx, split_batch, opt_idx, optimizer)
if self.should_accumulate():
# For gradient accumulation
# -------------------
# calculate loss (train step + train step end)
# -------------------
# perform dpp sync only when performing optimizer_step
with self.block_ddp_sync_behaviour():
self.training_step_and_backward(split_batch, batch_idx, opt_idx, optimizer, self.trainer.hiddens)
batch_outputs = self._process_closure_result(
batch_outputs=batch_outputs,
opt_idx=opt_idx,
)
# ------------------------------
# BACKWARD PASS
# ------------------------------
# gradient update with accumulated gradients
else:
if self.automatic_optimization:
def train_step_and_backward_closure():
result = self.training_step_and_backward(
split_batch,
batch_idx,
opt_idx,
optimizer,
self.trainer.hiddens
)
return None if result is None else result.loss
# optimizer step
self.optimizer_step(optimizer, opt_idx, batch_idx, train_step_and_backward_closure)
else:
self._curr_step_result = self.training_step(
split_batch,
batch_idx,
opt_idx,
self.trainer.hiddens
)
if self._curr_step_result is None:
# user decided to skip optimization
# make sure to zero grad.
self.zero_grad_handler(batch_idx, optimizer, opt_idx)
continue
batch_outputs = self._process_closure_result(
batch_outputs=batch_outputs,
opt_idx=opt_idx,
)
# todo: Properly aggregate grad_norm accros opt_idx and split_idx
grad_norm_dic = self._cur_grad_norm_dict
self._cur_grad_norm_dict = None
# hook + clear gradients
self.zero_grad_handler(batch_idx, optimizer, opt_idx)
# update running loss + reset accumulated loss
self.update_running_loss()
result = AttributeDict(
signal=0,
grad_norm_dic=grad_norm_dic,
training_step_output_for_epoch_end=batch_outputs,
)
return result
@contextmanager
def block_ddp_sync_behaviour(self):
if isinstance(self.trainer.model, torch.nn.parallel.DistributedDataParallel):
yield self.trainer.model.no_sync()
else:
yield
def _process_closure_result(
self, batch_outputs: list, opt_idx: int
) -> list:
opt_closure_result = self._curr_step_result
if opt_closure_result is not None:
# cache metrics
self.trainer.logger_connector.cache_training_step_metrics(opt_closure_result)
# track hiddens
self.trainer.hiddens = self.process_hiddens(opt_closure_result)
# check if loss or model weights are nan
if self.trainer.terminate_on_nan:
self.trainer.detect_nan_tensors(opt_closure_result.loss)
# track all the outputs across all steps
batch_opt_idx = opt_idx if len(batch_outputs) > 1 else 0
batch_outputs[batch_opt_idx].append(opt_closure_result.training_step_output_for_epoch_end)
if self.automatic_optimization:
# track total loss for logging (avoid mem leaks)
self.accumulated_loss.append(opt_closure_result.loss)
self._curr_step_result = None
return batch_outputs
def training_step_and_backward(self, split_batch, batch_idx, opt_idx, optimizer, hiddens):
"""
wrap the forward step in a closure so second order methods work
"""
# lightning module hook
result = self.training_step(split_batch, batch_idx, opt_idx, hiddens)
self._curr_step_result = result
if result is None:
self.warning_cache.warn("training_step returned None if it was on purpose, ignore this warning...")
return None
if self.trainer.train_loop.automatic_optimization:
# backward pass
with self.trainer.profiler.profile("model_backward"):
self.backward(result, optimizer, opt_idx)
# hook - call this hook only
# when gradients have finished to accumulate
if not self.should_accumulate():
self.on_after_backward(result.training_step_output, batch_idx, result.loss)
# check if loss or model weights are nan
if self.trainer.terminate_on_nan:
self.trainer.detect_nan_tensors(result.loss)
return result
def backward(self, result, optimizer, opt_idx, *args, **kwargs):
self.trainer.dev_debugger.track_event("backward_call")
# backward can be called manually in the training loop
if isinstance(result, torch.Tensor):
self.trainer.accelerator_backend.backward(result, optimizer, opt_idx, *args, **kwargs)
else:
result.closure_loss = self.trainer.accelerator_backend.backward(
result.closure_loss, optimizer, opt_idx, *args, **kwargs
)
if not self.should_accumulate():
# track gradients
self.track_and_norm_grad(optimizer=optimizer)
def update_train_loop_lr_schedulers(self, monitor_metrics=None):
num_accumulated_batches_reached = self._accumulated_batches_reached()
num_training_batches_reached = self._num_training_batches_reached()
if num_accumulated_batches_reached or num_training_batches_reached:
# update lr
self.trainer.optimizer_connector.update_learning_rates(interval="step", monitor_metrics=monitor_metrics)
def run_on_epoch_end_hook(self, epoch_output):
self.trainer.call_hook('on_epoch_end')
self.trainer.call_hook('on_train_epoch_end', epoch_output)
self.trainer.logger_connector.on_train_epoch_end()
def increment_accumulated_grad_global_step(self):
num_accumulated_batches_reached = self._accumulated_batches_reached()
num_training_batches_reached = self._num_training_batches_reached()
# progress global step according to grads progress
if num_accumulated_batches_reached or num_training_batches_reached:
self.trainer.global_step += 1
def _accumulated_batches_reached(self):
return (self.trainer.batch_idx + 1) % self.trainer.accumulate_grad_batches == 0
def _num_training_batches_reached(self):
return (self.trainer.batch_idx + 1) == self.trainer.num_training_batches
def should_accumulate(self):
# checks if backward or backward + optimizer step (via closure)
accumulation_done = self._accumulated_batches_reached()
is_final_batch = self._num_training_batches_reached()
return not (accumulation_done or is_final_batch)
def should_check_val_fx(self, batch_idx, is_last_batch):
# decide if we should run validation
is_val_check_batch = (batch_idx + 1) % self.trainer.val_check_batch == 0
is_val_check_epoch = (self.trainer.current_epoch + 1) % self.trainer.check_val_every_n_epoch == 0
can_check_val = self.trainer.enable_validation and is_val_check_epoch
should_check_val = is_val_check_batch or self.trainer.should_stop
is_last_batch_for_infinite_dataset = is_last_batch and self.trainer.val_check_batch == float("inf")
should_check_val = can_check_val and (should_check_val or is_last_batch_for_infinite_dataset)
return should_check_val
def build_train_args(self, batch, batch_idx, opt_idx, hiddens):
# enable not needing to add opt_idx to training_step
args = [batch, batch_idx]
if len(self.trainer.optimizers) > 1:
if self.trainer.has_arg("training_step", "optimizer_idx"):
args.append(opt_idx)
else:
num_opts = len(self.trainer.optimizers)
raise ValueError(
f"Your LightningModule defines {num_opts} optimizers but "
f'training_step is missing the "optimizer_idx" argument.'
)
# pass hiddens if using tbptt
if self.trainer.truncated_bptt_steps is not None:
args.append(hiddens)
return args
def save_loggers_on_train_batch_end(self):
# when loggers should save to disk
should_flush_logs = self.trainer.logger_connector.should_flush_logs
if should_flush_logs or self.trainer.fast_dev_run:
if self.trainer.is_global_zero and self.trainer.logger is not None:
self.trainer.logger.save()
def process_train_step_outputs(self, all_train_step_outputs, early_stopping_accumulator, checkpoint_accumulator):
"""
Figure out what needs to be tracked/logged at the end of the epoch
"""
# the training step outputs a list per optimizer. The list contains the outputs at each time step
# when no TBPTT is used, then the list has 1 item per batch
# when TBPTT IS used, then the list has n items (1 per time step)
epoch_end_outputs = []
for optimizer_idx_outputs in all_train_step_outputs:
# extract one representative sample from each time step (1 if no tbptt) and 0th optimizer
if len(optimizer_idx_outputs) == 0:
continue
sample_output = optimizer_idx_outputs[-1]
# pull out callback info if available (ie: Results object)
if isinstance(sample_output, dict) and "early_stop_on" in sample_output:
early_stopping_accumulator.accumulate(sample_output["early_stop_on"])
if isinstance(sample_output, dict) and "checkpoint_on" in sample_output:
checkpoint_accumulator.accumulate(sample_output["checkpoint_on"])
# decide if we need to reduce at the end of the epoch automatically
auto_reduce_tng_result = isinstance(sample_output, Result) and sample_output.should_reduce_on_epoch_end
# only track when a) it needs to be autoreduced OR b) the user wants to manually reduce on epoch end
if is_overridden("training_epoch_end", model=self.trainer.get_model()) or auto_reduce_tng_result:
epoch_end_outputs.append(optimizer_idx_outputs)
return epoch_end_outputs
def prepare_optimizers(self):
# in manual optimization we loop over all optimizers at once
optimizers = self.get_optimizers_iterable()
if not self.automatic_optimization:
optimizers = [optimizers[0]]
return optimizers
def run_train_split_start(self, split_idx, split_batch, opt_idx, optimizer):
# set split_idx to trainer for tracking
self.trainer.split_idx = split_idx
# make sure only the gradients of the current optimizer's parameters are calculated
# in the training step to prevent dangling gradients in multiple-optimizer setup.
if self.automatic_optimization and len(self.trainer.optimizers) > 1:
model = self.trainer.get_model()
model.toggle_optimizer(optimizer, opt_idx)
# use to track metrics internally
self.trainer.logger_connector.on_train_split_start(split_idx, opt_idx, split_batch)
def update_running_loss(self):
accumulated_loss = self.accumulated_loss.mean()
if accumulated_loss is not None:
# calculate running loss for display
self.running_loss.append(self.accumulated_loss.mean() * self.trainer.accumulate_grad_batches)
# reset for next set of accumulated grads
self.accumulated_loss.reset()
def zero_grad_handler(self, batch_idx, optimizer, opt_idx):
if self.automatic_optimization:
# hook
self.on_before_zero_grad(optimizer)
optimizers = enumerate([optimizer])
else:
optimizers = self.get_optimizers_iterable()
for idx, optimizer in optimizers:
self.optimizer_zero_grad(batch_idx, optimizer, opt_idx)
|
_check_training_step_output
|
stock_price_scraper.py
|
import urllib.request
from datetime import datetime
import string
from argparse import ArgumentParser
import gspread
from oauth2client.service_account import ServiceAccountCredentials
from bs4 import BeautifulSoup
from sortedcontainers import SortedDict
class StockPriceScraper:
def
|
(self, base_url, stock_codes, google_sheet, client_secret, test):
self.stock_codes = stock_codes
self.base_url = base_url
if not test:
self.sheet = client(client_secret).open(google_sheet)
def insert_prices(self):
worksheet = self.sheet.add_worksheet(title=f'{datetime.today().strftime("%Y-%m-%d")}', rows='2', cols=f'{len(self.stock_codes)}')
for i, (stock_code, stock_price) in enumerate(self.stock_prices().items()):
self.update_sheet(worksheet, i, [stock_code, stock_price])
def stock_prices(self):
stock_prices = {}
for stock_code in self.stock_codes:
stock_prices[stock_code] = price(url(self.base_url, stock_code))
return SortedDict(stock_prices)
def update_sheet(self, worksheet, i, contents):
for j, content in enumerate(contents):
update_cell(worksheet, cell(string.ascii_uppercase[i], j), content)
def cell(letter, number):
return f'{letter}{number}'
def update_cell(worksheet, cell, info):
worksheet.update_acell(cell, info)
def client(client_secret):
scope = ['https://spreadsheets.google.com/feeds']
creds = ServiceAccountCredentials.from_json_keyfile_name(client_secret, scope)
return gspread.authorize(creds)
def price(url):
page = urllib.request.urlopen(url)
soup = BeautifulSoup(page, 'html.parser')
return soup.find('h2', attrs={'class':'page-content entry-content'}).text.strip()
def url(base_url, stock_code):
return f'{base_url}{stock_code.upper()}'
if __name__ == '__main__':
parser = ArgumentParser(description='Takes stock codes, scrapes prices from website and inserts into a given google sheet')
parser.add_argument('-c', '--client-secret', action='store', help='the client', type=str, dest='base_url', required=True)
parser.add_argument('-c', '--client-secret', action='store', help='the client', type=str, dest='client_secret', required=True)
parser.add_argument('-g', '--google-sheet', action='store', help='the google sheet to insert prices into', type=str, dest='google_sheet', required=True)
parser.add_argument('-s', '--stock-codes', action='store', help='the stock codes to get price for', type=str, dest='stock_codes', nargs='+', required=True)
parser.add_argument('-t', '--test', action='store_true', help='Perform test', dest='test' )
args = parser.parse_args().__dict__
StockPriceScraper(**args).insert_prices()
|
__init__
|
startQiskit_Class182.py
|
# qubit number=2
# total number=13
import cirq
import qiskit
from qiskit import IBMQ
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit import BasicAer, execute, transpile
from pprint import pprint
from qiskit.test.mock import FakeVigo
from math import log2,floor, sqrt, pi
import numpy as np
import networkx as nx
def build_oracle(n: int, f) -> QuantumCircuit:
# implement the oracle O_f^\pm
# NOTE: use U1 gate (P gate) with \lambda = 180 ==> CZ gate
# or multi_control_Z_gate (issue #127)
controls = QuantumRegister(n, "ofc")
target = QuantumRegister(1, "oft")
oracle = QuantumCircuit(controls, target, name="Of")
for i in range(2 ** n):
rep = np.binary_repr(i, n)
if f(rep) == "1":
for j in range(n):
if rep[j] == "0":
oracle.x(controls[j])
oracle.mct(controls, target[0], None, mode='noancilla')
for j in range(n):
if rep[j] == "0":
oracle.x(controls[j])
# oracle.barrier()
# oracle.draw('mpl', filename='circuit/deutsch-oracle.png')
return oracle
def
|
(n:int,f) -> QuantumCircuit:
# circuit begin
input_qubit = QuantumRegister(n, "qc")
target = QuantumRegister(1, "qt")
prog = QuantumCircuit(input_qubit, target)
# inverse last one (can be omitted if using O_f^\pm)
prog.x(target)
# apply H to get superposition
for i in range(n):
prog.h(input_qubit[i])
prog.h(input_qubit[1]) # number=1
prog.h(target)
prog.barrier()
# apply oracle O_f
oracle = build_oracle(n, f)
prog.append(
oracle.to_gate(),
[input_qubit[i] for i in range(n)] + [target])
# apply H back (QFT on Z_2^n)
for i in range(n):
prog.h(input_qubit[i])
prog.barrier()
# measure
prog.y(input_qubit[1]) # number=2
prog.y(input_qubit[1]) # number=4
prog.y(input_qubit[1]) # number=3
prog.cx(input_qubit[1],input_qubit[0]) # number=7
prog.x(input_qubit[0]) # number=8
prog.h(input_qubit[0]) # number=10
prog.cz(input_qubit[1],input_qubit[0]) # number=11
prog.h(input_qubit[0]) # number=12
prog.x(input_qubit[0]) # number=6
# circuit end
return prog
if __name__ == '__main__':
n = 2
f = lambda rep: rep[-1]
# f = lambda rep: "1" if rep[0:2] == "01" or rep[0:2] == "10" else "0"
# f = lambda rep: "0"
prog = make_circuit(n, f)
sample_shot =2800
backend = BasicAer.get_backend('statevector_simulator')
circuit1 = transpile(prog,FakeVigo())
circuit1.x(qubit=3)
circuit1.x(qubit=3)
prog = circuit1
info = execute(prog, backend=backend).result().get_statevector()
qubits = round(log2(len(info)))
info = {
np.binary_repr(i, qubits): round((info[i]*(info[i].conjugate())).real,3)
for i in range(2 ** qubits)
}
writefile = open("../data/startQiskit_Class182.csv","w")
print(info,file=writefile)
print("results end", file=writefile)
print(circuit1.depth(),file=writefile)
print(circuit1,file=writefile)
writefile.close()
|
make_circuit
|
app_settings.rs
|
#![allow(deprecated)]
// Std
use std::ops::BitOr;
#[cfg(feature = "yaml")]
use std::str::FromStr;
#[allow(unused)]
use crate::App;
#[allow(unused)]
use crate::Arg;
// Third party
use bitflags::bitflags;
#[doc(hidden)]
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub struct AppFlags(Flags);
impl Default for AppFlags {
fn default() -> Self {
AppFlags(Flags::COLOR_AUTO)
}
}
/// Application level settings, which affect how [`App`] operates
///
/// **NOTE:** When these settings are used, they apply only to current command, and are *not*
/// propagated down or up through child or parent subcommands
///
/// [`App`]: crate::App
#[derive(Debug, PartialEq, Copy, Clone)]
#[non_exhaustive]
pub enum AppSettings {
/// Deprecated, replaced with [`App::ignore_errors`]
#[deprecated(since = "3.1.0", note = "Replaced with `App::ignore_errors`")]
IgnoreErrors,
/// Deprecated, replace
/// ```rust,no_run
/// let app = clap::App::new("app")
/// .global_setting(clap::AppSettings::WaitOnError)
/// .arg(clap::arg!(--flag));
/// let m = app.get_matches();
/// ```
/// with
/// ```rust
/// let app = clap::App::new("app")
/// .arg(clap::arg!(--flag));
/// let m = match app.try_get_matches() {
/// Ok(m) => m,
/// Err(err) => {
/// if err.use_stderr() {
/// let _ = err.print();
///
/// eprintln!("\nPress [ENTER] / [RETURN] to continue...");
/// use std::io::BufRead;
/// let mut s = String::new();
/// let i = std::io::stdin();
/// i.lock().read_line(&mut s).unwrap();
///
/// std::process::exit(2);
/// } else {
/// let _ = err.print();
/// std::process::exit(0);
/// }
/// }
/// };
/// ```
#[deprecated(
since = "3.1.0",
note = "See documentation for how to hand-implement this"
)]
WaitOnError,
/// Deprecated, replaced with [`App::allow_hyphen_values`] and
/// [`Arg::is_allow_hyphen_values_set`]
#[deprecated(
since = "3.1.0",
note = "Replaced with `App::allow_hyphen_values` and `Arg::is_allow_hyphen_values_set`"
)]
AllowHyphenValues,
/// Deprecated, replaced with [`App::allow_negative_numbers`] and
/// [`App::is_allow_negative_numbers_set`]
#[deprecated(
since = "3.1.0",
note = "Replaced with `App::allow_negative_numbers` and `App::is_allow_negative_numbers_set`"
)]
AllowNegativeNumbers,
/// Deprecated, replaced with [`App::args_override_self`]
#[deprecated(since = "3.1.0", note = "Replaced with `App::args_override_self`")]
AllArgsOverrideSelf,
/// Deprecated, replaced with [`App::allow_missing_positional`] and
/// [`App::is_allow_missing_positional_set`]
#[deprecated(
since = "3.1.0",
note = "Replaced with `App::allow_missing_positional` and `App::is_allow_missing_positional_set`"
)]
AllowMissingPositional,
/// Deprecated, replaced with [`App::trailing_var_arg`] and [`App::is_trailing_var_arg_set`]
#[deprecated(
since = "3.1.0",
note = "Replaced with `App::trailing_var_arg` and `App::is_trailing_var_arg_set`"
)]
TrailingVarArg,
/// Deprecated, replaced with [`App::dont_delimit_trailing_values`] and
/// [`App::is_dont_delimit_trailing_values_set`]
#[deprecated(
since = "3.1.0",
note = "Replaced with `App::dont_delimit_trailing_values` and `App::is_dont_delimit_trailing_values_set`"
)]
DontDelimitTrailingValues,
/// Deprecated, replaced with [`App::infer_long_args`]
#[deprecated(since = "3.1.0", note = "Replaced with `App::infer_long_args`")]
InferLongArgs,
/// Deprecated, replaced with [`App::infer_subcommands`]
#[deprecated(since = "3.1.0", note = "Replaced with `App::infer_subcommands`")]
InferSubcommands,
/// Deprecated, replaced with [`App::subcommand_required`] and
/// [`App::is_subcommand_required_set`]
#[deprecated(
since = "3.1.0",
note = "Replaced with `App::subcommand_required` and `App::is_subcommand_required_set`"
)]
SubcommandRequired,
/// Deprecated, replaced with [`App::subcommand_required`] combined with
/// [`App::arg_required_else_help`].
#[deprecated(
since = "3.1.0",
note = "Replaced with `App::subcommand_required` combined with `App::arg_required_else_help`"
)]
SubcommandRequiredElseHelp,
/// Deprecated, replaced with [`App::allow_external_subcommands`] and
/// [`App::is_allow_external_subcommands_set`]
#[deprecated(
since = "3.1.0",
note = "Replaced with `App::allow_external_subcommands` and `App::is_allow_external_subcommands_set`"
)]
AllowExternalSubcommands,
/// Deprecated, replaced with [`App::multicall`] and [`App::is_multicall_set`]
#[deprecated(
since = "3.1.0",
note = "Replaced with `App::multicall` and `App::is_multicall_set`"
)]
#[cfg(feature = "unstable-multicall")]
Multicall,
/// Deprecated, replaced with [`App::allow_invalid_utf8_for_external_subcommands`] and [`App::is_allow_invalid_utf8_for_external_subcommands_set`]
#[deprecated(
since = "3.1.0",
note = "Replaced with `App::allow_invalid_utf8_for_external_subcommands` and `App::is_allow_invalid_utf8_for_external_subcommands_set`"
)]
AllowInvalidUtf8ForExternalSubcommands,
/// Deprecated, this is now the default
#[deprecated(since = "3.1.0", note = "This is now the default")]
UseLongFormatForHelpSubcommand,
/// Deprecated, replaced with [`App::subcommand_negates_reqs`] and
/// [`App::is_subcommand_negates_reqs_set`]
#[deprecated(
since = "3.1.0",
note = "Replaced with `App::subcommand_negates_reqs` and `App::is_subcommand_negates_reqs_set`"
)]
SubcommandsNegateReqs,
/// Deprecated, replaced with [`App::args_conflicts_with_subcommands`] and
/// [`App::is_args_conflicts_with_subcommands_set`]
#[deprecated(
since = "3.1.0",
note = "Replaced with `App::args_conflicts_with_subcommands` and `App::is_args_conflicts_with_subcommands_set`"
)]
ArgsNegateSubcommands,
/// Deprecated, replaced with [`App::subcommand_precedence_over_arg`] and
/// [`App::is_subcommand_precedence_over_arg_set`]
#[deprecated(
since = "3.1.0",
note = "Replaced with `App::subcommand_precedence_over_arg` and `App::is_subcommand_precedence_over_arg_set`"
)]
SubcommandPrecedenceOverArg,
/// Deprecated, replaced with [`App::arg_required_else_help`] and
/// [`App::is_arg_required_else_help_set`]
#[deprecated(
since = "3.1.0",
note = "Replaced with `App::arg_required_else_help` and `App::is_arg_required_else_help_set`"
)]
ArgRequiredElseHelp,
/// Displays the arguments and [`subcommands`] in the help message in the order that they were
/// declared in, and not alphabetically which is the default.
///
/// To override the declaration order, see [`Arg::display_order`] and [`App::display_order`].
///
/// # Examples
///
/// ```no_run
/// # use clap::{App, Arg, AppSettings};
/// App::new("myprog")
/// .global_setting(AppSettings::DeriveDisplayOrder)
/// .get_matches();
/// ```
///
/// [`subcommands`]: crate::App::subcommand()
/// [`Arg::display_order`]: crate::Arg::display_order
/// [`App::display_order`]: crate::App::display_order
DeriveDisplayOrder,
/// Deprecated, replaced with [`App::dont_collapse_args_in_usage`] and
/// [`App::is_dont_collapse_args_in_usage_set`]
#[deprecated(
since = "3.1.0",
note = "Replaced with `App::dont_collapse_args_in_usage` and `App::is_dont_collapse_args_in_usage_set`"
)]
DontCollapseArgsInUsage,
/// Deprecated, replaced with [`App::next_line_help`] and [`App::is_next_line_help_set`]
#[deprecated(
since = "3.1.0",
note = "Replaced with `App::next_line_help` and `App::is_next_line_help_set`"
)]
NextLineHelp,
/// Deprecated, replaced with [`App::disable_colored_help`] and
/// [`App::is_disable_colored_help_set`]
#[deprecated(
since = "3.1.0",
note = "Replaced with `App::disable_colored_help` and `App::is_disable_colored_help_set`"
)]
DisableColoredHelp,
/// Deprecated, replaced with [`App::disable_help_flag`] and [`App::is_disable_help_flag_set`]
#[deprecated(
since = "3.1.0",
note = "Replaced with `App::disable_help_flag` and `App::is_disable_help_flag_set`"
)]
DisableHelpFlag,
/// Deprecated, replaced with [`App::disable_help_subcommand`] and
/// [`App::is_disable_help_subcommand_set`]
#[deprecated(
since = "3.1.0",
note = "Replaced with `App::disable_help_subcommand` and `App::is_disable_help_subcommand_set`"
)]
DisableHelpSubcommand,
/// Deprecated, replaced with [`App::disable_version_flag`] and
/// [`App::is_disable_version_flag_set`]
#[deprecated(
since = "3.1.0",
note = "Replaced with `App::disable_version_flag` and `App::is_disable_version_flag_set`"
)]
DisableVersionFlag,
/// Deprecated, replaced with [`App::propagate_version`] and [`App::is_propagate_version_set`]
#[deprecated(
since = "3.1.0",
note = "Replaced with `App::propagate_version` and `App::is_propagate_version_set`"
)]
PropagateVersion,
/// Deprecated, replaced with [`App::hide`] and [`App::is_hide_set`]
#[deprecated(
since = "3.1.0",
note = "Replaced with `App::hide` and `App::is_hide_set`"
)]
Hidden,
/// Deprecated, replaced with [`App::hide_possible_values`] and
/// [`Arg::is_hide_possible_values_set`]
#[deprecated(
since = "3.1.0",
note = "Replaced with `App::hide_possible_values` and `Arg::is_hide_possible_values_set`"
)]
HidePossibleValues,
/// Deprecated, replaced with [`App::help_expected`]
#[deprecated(since = "3.1.0", note = "Replaced with `App::help_expected`")]
HelpExpected,
/// Deprecated, replaced with [`App::no_binary_name`]
#[deprecated(since = "3.1.0", note = "Replaced with `App::no_binary_name`")]
NoBinaryName,
/// Treat the auto-generated `-h, --help` flags like any other flag, and *not* print the help
/// message.
///
/// This allows one to handle printing of the help message manually.
///
/// ```rust
/// # use clap::{App, AppSettings};
/// let result = App::new("myprog")
/// .setting(AppSettings::NoAutoHelp)
/// .try_get_matches_from("myprog --help".split(" "));
///
/// // Normally, if `--help` is used clap prints the help message and returns an
/// // ErrorKind::DisplayHelp
/// //
/// // However, `--help` was treated like a normal flag
///
/// assert!(result.is_ok());
/// assert!(result.unwrap().is_present("help"));
/// ```
NoAutoHelp,
/// Treat the auto-generated `-V, --version` flags like any other flag, and
/// *not* print the version message.
///
/// This allows one to handle printing of the version message manually.
///
/// ```rust
/// # use clap::{App, AppSettings};
/// let result = App::new("myprog")
/// .version("3.0")
/// .setting(AppSettings::NoAutoVersion)
/// .try_get_matches_from("myprog --version".split(" "));
///
/// // Normally, if `--version` is used clap prints the version message and returns an
/// // ErrorKind::DisplayVersion
/// //
/// // However, `--version` was treated like a normal flag
///
/// assert!(result.is_ok());
/// assert!(result.unwrap().is_present("version"));
/// ```
NoAutoVersion,
/// Deprecated, replaced with [`AppSettings::AllowHyphenValues`]
#[deprecated(
since = "3.0.0",
note = "Replaced with `AppSettings::AllowHyphenValues`"
)]
#[doc(hidden)]
AllowLeadingHyphen,
/// Deprecated, this is now the default, see [`AppSettings::AllowInvalidUtf8ForExternalSubcommands`] and [`ArgSettings::AllowInvalidUtf8`][crate::ArgSettings::AllowInvalidUtf8] for the opposite.
#[deprecated(
since = "3.0.0",
note = "This is now the default see `AppSettings::AllowInvalidUtf8ForExternalSubcommands` and `ArgSettings::AllowInvalidUtf8` for the opposite."
)]
#[doc(hidden)]
StrictUtf8,
/// Deprecated, this is now the default
#[deprecated(since = "3.0.0", note = "This is now the default")]
#[doc(hidden)]
UnifiedHelpMessage,
/// Deprecated, this is now the default
#[deprecated(since = "3.0.0", note = "This is now the default")]
#[doc(hidden)]
ColoredHelp,
/// Deprecated, see [`App::color`][crate::App::color]
#[deprecated(since = "3.0.0", note = "Replaced with `App::color`")]
#[doc(hidden)]
ColorAuto,
/// Deprecated, replaced with [`App::color`][crate::App::color]
#[deprecated(since = "3.0.0", note = "Replaced with `App::color`")]
#[doc(hidden)]
ColorAlways,
/// Deprecated, replaced with [`App::color`][crate::App::color]
#[deprecated(since = "3.0.0", note = "Replaced with `App::color`")]
#[doc(hidden)]
ColorNever,
/// Deprecated, replaced with [`AppSettings::DisableHelpFlag`]
#[deprecated(since = "3.0.0", note = "Replaced with `AppSettings::DisableHelpFlag`")]
#[doc(hidden)]
DisableHelpFlags,
/// Deprecated, replaced with [`AppSettings::DisableVersionFlag`]
#[deprecated(
since = "3.0.0",
note = "Replaced with `AppSettings::DisableVersionFlag`"
)]
#[doc(hidden)]
DisableVersion,
/// Deprecated, replaced with [`AppSettings::PropagateVersion`]
#[deprecated(
since = "3.0.0",
note = "Replaced with `AppSettings::PropagateVersion`"
)]
#[doc(hidden)]
GlobalVersion,
/// Deprecated, replaced with [`AppSettings::HidePossibleValues`]
#[deprecated(
since = "3.0.0",
note = "Replaced with AppSettings::HidePossibleValues"
)]
#[doc(hidden)]
HidePossibleValuesInHelp,
/// Deprecated, this is now the default
#[deprecated(since = "3.0.0", note = "This is now the default")]
#[doc(hidden)]
UnifiedHelp,
/// If the app is already built, used for caching.
#[doc(hidden)]
Built,
/// If the app's bin name is already built, used for caching.
#[doc(hidden)]
BinNameBuilt,
}
bitflags! {
struct Flags: u64 {
const SC_NEGATE_REQS = 1;
const SC_REQUIRED = 1 << 1;
const ARG_REQUIRED_ELSE_HELP = 1 << 2;
const PROPAGATE_VERSION = 1 << 3;
const DISABLE_VERSION_FOR_SC = 1 << 4;
const WAIT_ON_ERROR = 1 << 6;
const SC_REQUIRED_ELSE_HELP = 1 << 7;
const NO_AUTO_HELP = 1 << 8;
const NO_AUTO_VERSION = 1 << 9;
const DISABLE_VERSION_FLAG = 1 << 10;
const HIDDEN = 1 << 11;
const TRAILING_VARARG = 1 << 12;
const NO_BIN_NAME = 1 << 13;
const ALLOW_UNK_SC = 1 << 14;
const SC_UTF8_NONE = 1 << 15;
const LEADING_HYPHEN = 1 << 16;
const NO_POS_VALUES = 1 << 17;
const NEXT_LINE_HELP = 1 << 18;
const DERIVE_DISP_ORDER = 1 << 19;
const DISABLE_COLORED_HELP = 1 << 20;
const COLOR_ALWAYS = 1 << 21;
const COLOR_AUTO = 1 << 22;
const COLOR_NEVER = 1 << 23;
const DONT_DELIM_TRAIL = 1 << 24;
const ALLOW_NEG_NUMS = 1 << 25;
const DISABLE_HELP_SC = 1 << 27;
const DONT_COLLAPSE_ARGS = 1 << 28;
const ARGS_NEGATE_SCS = 1 << 29;
const PROPAGATE_VALS_DOWN = 1 << 30;
const ALLOW_MISSING_POS = 1 << 31;
const TRAILING_VALUES = 1 << 32;
const BUILT = 1 << 33;
const BIN_NAME_BUILT = 1 << 34;
const VALID_ARG_FOUND = 1 << 35;
const INFER_SUBCOMMANDS = 1 << 36;
const CONTAINS_LAST = 1 << 37;
const ARGS_OVERRIDE_SELF = 1 << 38;
const HELP_REQUIRED = 1 << 39;
const SUBCOMMAND_PRECEDENCE_OVER_ARG = 1 << 40;
const DISABLE_HELP_FLAG = 1 << 41;
const USE_LONG_FORMAT_FOR_HELP_SC = 1 << 42;
const INFER_LONG_ARGS = 1 << 43;
const IGNORE_ERRORS = 1 << 44;
#[cfg(feature = "unstable-multicall")]
const MULTICALL = 1 << 45;
const NO_OP = 0;
}
}
impl_settings! { AppSettings, AppFlags,
ArgRequiredElseHelp
=> Flags::ARG_REQUIRED_ELSE_HELP,
SubcommandPrecedenceOverArg
=> Flags::SUBCOMMAND_PRECEDENCE_OVER_ARG,
ArgsNegateSubcommands
=> Flags::ARGS_NEGATE_SCS,
AllowExternalSubcommands
=> Flags::ALLOW_UNK_SC,
StrictUtf8
=> Flags::NO_OP,
AllowInvalidUtf8ForExternalSubcommands
=> Flags::SC_UTF8_NONE,
AllowHyphenValues
=> Flags::LEADING_HYPHEN,
AllowLeadingHyphen
=> Flags::LEADING_HYPHEN,
AllowNegativeNumbers
=> Flags::ALLOW_NEG_NUMS,
AllowMissingPositional
=> Flags::ALLOW_MISSING_POS,
UnifiedHelpMessage
=> Flags::NO_OP,
ColoredHelp
=> Flags::NO_OP,
ColorAlways
=> Flags::COLOR_ALWAYS,
ColorAuto
=> Flags::COLOR_AUTO,
ColorNever
=> Flags::COLOR_NEVER,
DontDelimitTrailingValues
=> Flags::DONT_DELIM_TRAIL,
DontCollapseArgsInUsage
=> Flags::DONT_COLLAPSE_ARGS,
DeriveDisplayOrder
=> Flags::DERIVE_DISP_ORDER,
DisableColoredHelp
=> Flags::DISABLE_COLORED_HELP,
DisableHelpSubcommand
=> Flags::DISABLE_HELP_SC,
DisableHelpFlag
=> Flags::DISABLE_HELP_FLAG,
DisableHelpFlags
=> Flags::DISABLE_HELP_FLAG,
DisableVersionFlag
=> Flags::DISABLE_VERSION_FLAG,
DisableVersion
=> Flags::DISABLE_VERSION_FLAG,
PropagateVersion
=> Flags::PROPAGATE_VERSION,
GlobalVersion
=> Flags::PROPAGATE_VERSION,
HidePossibleValues
=> Flags::NO_POS_VALUES,
HidePossibleValuesInHelp
=> Flags::NO_POS_VALUES,
HelpExpected
=> Flags::HELP_REQUIRED,
Hidden
=> Flags::HIDDEN,
#[cfg(feature = "unstable-multicall")]
Multicall
=> Flags::MULTICALL,
NoAutoHelp
=> Flags::NO_AUTO_HELP,
NoAutoVersion
=> Flags::NO_AUTO_VERSION,
NoBinaryName
=> Flags::NO_BIN_NAME,
SubcommandsNegateReqs
=> Flags::SC_NEGATE_REQS,
SubcommandRequired
=> Flags::SC_REQUIRED,
SubcommandRequiredElseHelp
=> Flags::SC_REQUIRED_ELSE_HELP,
UseLongFormatForHelpSubcommand
=> Flags::USE_LONG_FORMAT_FOR_HELP_SC,
TrailingVarArg
=> Flags::TRAILING_VARARG,
UnifiedHelp => Flags::NO_OP,
NextLineHelp
=> Flags::NEXT_LINE_HELP,
IgnoreErrors
=> Flags::IGNORE_ERRORS,
WaitOnError
=> Flags::WAIT_ON_ERROR,
Built
=> Flags::BUILT,
BinNameBuilt
=> Flags::BIN_NAME_BUILT,
InferSubcommands
=> Flags::INFER_SUBCOMMANDS,
AllArgsOverrideSelf
=> Flags::ARGS_OVERRIDE_SELF,
InferLongArgs
=> Flags::INFER_LONG_ARGS
}
/// Deprecated in [Issue #3087](https://github.com/clap-rs/clap/issues/3087), maybe [`clap::Parser`][crate::Parser] would fit your use case?
#[cfg(feature = "yaml")]
impl FromStr for AppSettings {
type Err = String;
fn from_str(s: &str) -> Result<Self, <Self as FromStr>::Err>
|
}
#[cfg(test)]
mod test {
#[allow(clippy::cognitive_complexity)]
#[test]
#[cfg(feature = "yaml")]
fn app_settings_fromstr() {
use super::AppSettings;
assert_eq!(
"disablehelpflag".parse::<AppSettings>().unwrap(),
AppSettings::DisableHelpFlag
);
assert_eq!(
"argsnegatesubcommands".parse::<AppSettings>().unwrap(),
AppSettings::ArgsNegateSubcommands
);
assert_eq!(
"argrequiredelsehelp".parse::<AppSettings>().unwrap(),
AppSettings::ArgRequiredElseHelp
);
assert_eq!(
"subcommandprecedenceoverarg"
.parse::<AppSettings>()
.unwrap(),
AppSettings::SubcommandPrecedenceOverArg
);
assert_eq!(
"allowexternalsubcommands".parse::<AppSettings>().unwrap(),
AppSettings::AllowExternalSubcommands
);
assert_eq!(
"allowinvalidutf8forexternalsubcommands"
.parse::<AppSettings>()
.unwrap(),
AppSettings::AllowInvalidUtf8ForExternalSubcommands
);
assert_eq!(
"allowhyphenvalues".parse::<AppSettings>().unwrap(),
AppSettings::AllowHyphenValues
);
assert_eq!(
"allownegativenumbers".parse::<AppSettings>().unwrap(),
AppSettings::AllowNegativeNumbers
);
assert_eq!(
"disablehelpsubcommand".parse::<AppSettings>().unwrap(),
AppSettings::DisableHelpSubcommand
);
assert_eq!(
"disableversionflag".parse::<AppSettings>().unwrap(),
AppSettings::DisableVersionFlag
);
assert_eq!(
"dontcollapseargsinusage".parse::<AppSettings>().unwrap(),
AppSettings::DontCollapseArgsInUsage
);
assert_eq!(
"dontdelimittrailingvalues".parse::<AppSettings>().unwrap(),
AppSettings::DontDelimitTrailingValues
);
assert_eq!(
"derivedisplayorder".parse::<AppSettings>().unwrap(),
AppSettings::DeriveDisplayOrder
);
assert_eq!(
"disablecoloredhelp".parse::<AppSettings>().unwrap(),
AppSettings::DisableColoredHelp
);
assert_eq!(
"propagateversion".parse::<AppSettings>().unwrap(),
AppSettings::PropagateVersion
);
assert_eq!(
"hidden".parse::<AppSettings>().unwrap(),
AppSettings::Hidden
);
assert_eq!(
"hidepossiblevalues".parse::<AppSettings>().unwrap(),
AppSettings::HidePossibleValues
);
assert_eq!(
"helpexpected".parse::<AppSettings>().unwrap(),
AppSettings::HelpExpected
);
assert_eq!(
"nobinaryname".parse::<AppSettings>().unwrap(),
AppSettings::NoBinaryName
);
assert_eq!(
"nextlinehelp".parse::<AppSettings>().unwrap(),
AppSettings::NextLineHelp
);
assert_eq!(
"subcommandsnegatereqs".parse::<AppSettings>().unwrap(),
AppSettings::SubcommandsNegateReqs
);
assert_eq!(
"subcommandrequired".parse::<AppSettings>().unwrap(),
AppSettings::SubcommandRequired
);
assert_eq!(
"subcommandrequiredelsehelp".parse::<AppSettings>().unwrap(),
AppSettings::SubcommandRequiredElseHelp
);
assert_eq!(
"uselongformatforhelpsubcommand"
.parse::<AppSettings>()
.unwrap(),
AppSettings::UseLongFormatForHelpSubcommand
);
assert_eq!(
"trailingvararg".parse::<AppSettings>().unwrap(),
AppSettings::TrailingVarArg
);
assert_eq!(
"waitonerror".parse::<AppSettings>().unwrap(),
AppSettings::WaitOnError
);
assert_eq!("built".parse::<AppSettings>().unwrap(), AppSettings::Built);
assert_eq!(
"binnamebuilt".parse::<AppSettings>().unwrap(),
AppSettings::BinNameBuilt
);
assert_eq!(
"infersubcommands".parse::<AppSettings>().unwrap(),
AppSettings::InferSubcommands
);
assert!("hahahaha".parse::<AppSettings>().is_err());
}
}
|
{
#[allow(deprecated)]
#[allow(unreachable_patterns)]
match &*s.to_ascii_lowercase() {
"argrequiredelsehelp" => Ok(AppSettings::ArgRequiredElseHelp),
"subcommandprecedenceoverarg" => Ok(AppSettings::SubcommandPrecedenceOverArg),
"argsnegatesubcommands" => Ok(AppSettings::ArgsNegateSubcommands),
"allowexternalsubcommands" => Ok(AppSettings::AllowExternalSubcommands),
"strictutf8" => Ok(AppSettings::StrictUtf8),
"allowinvalidutf8forexternalsubcommands" => {
Ok(AppSettings::AllowInvalidUtf8ForExternalSubcommands)
}
"allowhyphenvalues" => Ok(AppSettings::AllowHyphenValues),
"allowleadinghyphen" => Ok(AppSettings::AllowLeadingHyphen),
"allownegativenumbers" => Ok(AppSettings::AllowNegativeNumbers),
"allowmissingpositional" => Ok(AppSettings::AllowMissingPositional),
"unifiedhelpmessage" => Ok(AppSettings::UnifiedHelpMessage),
"coloredhelp" => Ok(AppSettings::ColoredHelp),
"coloralways" => Ok(AppSettings::ColorAlways),
"colorauto" => Ok(AppSettings::ColorAuto),
"colornever" => Ok(AppSettings::ColorNever),
"dontdelimittrailingvalues" => Ok(AppSettings::DontDelimitTrailingValues),
"dontcollapseargsinusage" => Ok(AppSettings::DontCollapseArgsInUsage),
"derivedisplayorder" => Ok(AppSettings::DeriveDisplayOrder),
"disablecoloredhelp" => Ok(AppSettings::DisableColoredHelp),
"disablehelpsubcommand" => Ok(AppSettings::DisableHelpSubcommand),
"disablehelpflag" => Ok(AppSettings::DisableHelpFlag),
"disablehelpflags" => Ok(AppSettings::DisableHelpFlags),
"disableversionflag" => Ok(AppSettings::DisableVersionFlag),
"disableversion" => Ok(AppSettings::DisableVersion),
"propagateversion" => Ok(AppSettings::PropagateVersion),
"propagateversion" => Ok(AppSettings::GlobalVersion),
"hidepossiblevalues" => Ok(AppSettings::HidePossibleValues),
"hidepossiblevaluesinhelp" => Ok(AppSettings::HidePossibleValuesInHelp),
"helpexpected" => Ok(AppSettings::HelpExpected),
"hidden" => Ok(AppSettings::Hidden),
"noautohelp" => Ok(AppSettings::NoAutoHelp),
"noautoversion" => Ok(AppSettings::NoAutoVersion),
"nobinaryname" => Ok(AppSettings::NoBinaryName),
"subcommandsnegatereqs" => Ok(AppSettings::SubcommandsNegateReqs),
"subcommandrequired" => Ok(AppSettings::SubcommandRequired),
"subcommandrequiredelsehelp" => Ok(AppSettings::SubcommandRequiredElseHelp),
"uselongformatforhelpsubcommand" => Ok(AppSettings::UseLongFormatForHelpSubcommand),
"trailingvararg" => Ok(AppSettings::TrailingVarArg),
"unifiedhelp" => Ok(AppSettings::UnifiedHelp),
"nextlinehelp" => Ok(AppSettings::NextLineHelp),
"ignoreerrors" => Ok(AppSettings::IgnoreErrors),
"waitonerror" => Ok(AppSettings::WaitOnError),
"built" => Ok(AppSettings::Built),
"binnamebuilt" => Ok(AppSettings::BinNameBuilt),
"infersubcommands" => Ok(AppSettings::InferSubcommands),
"allargsoverrideself" => Ok(AppSettings::AllArgsOverrideSelf),
"inferlongargs" => Ok(AppSettings::InferLongArgs),
_ => Err(format!("unknown AppSetting: `{}`", s)),
}
}
|
daily-quote.component.ts
|
import { Component, Input, OnInit } from '@angular/core';
import { QuoteService } from 'src/app/services/quote.service';
import { Quote } from './../../services/quote.service'
import { Observable } from 'rxjs';
@Component({
selector: 'app-daily-quote',
templateUrl: './daily-quote.component.html',
styleUrls: ['./daily-quote.component.css']
})
export class DailyQuoteComponent implements OnInit {
body: string = '';
author: string = '';
quotes$: any = [];
constructor(private quoteService: QuoteService) { }
loadQuotes () {
this.quoteService.getDailyQuotes().subscribe(data => {
this.quotes$ = data;
this.getQuote();
})
}
getQuote() {
const randomQuoteIndex: number = Math.round(Math.random() * 50);
this.body = this.quotes$[randomQuoteIndex].q;
this.author = this.quotes$[randomQuoteIndex].a;
}
ngOnInit(): void {
this.loadQuotes();
}
|
}
| |
glusterfs_test.go
|
package glusterfsoutput
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/vjeantet/bitfan/processors/doc"
)
func TestNew(t *testing.T) {
p := New()
_, ok := p.(*processor)
assert.Equal(t, ok, true, "New() should return a processor")
}
func TestDoc(t *testing.T) {
assert.IsType(t, &doc.Processor{}, New().(*processor).Doc())
}
func TestMaxConcurent(t *testing.T)
|
{
max := New().(*processor).MaxConcurent()
assert.Equal(t, 0, max, "this processor does support concurency")
}
|
|
test_TimeAverager.py
|
import Averager as Avg
class Average:
def __init__(self):
self.answer = 0
self.delta_time = 0
def average(self, avg, delta_t):
print("Average: " + str(avg) + " Timespan: " + str(delta_t))
self.answer = avg
self.delta_time = delta_t
def test_averager():
avg = Average()
averager = Avg.TimeAverager(1, avg.average)
averager.update_average(12.345)
assert avg.answer == 12.345
assert avg.delta_time > 0
def
|
():
avg = Average()
averager = Avg.TimeAverager(10, avg.average)
averager.update_average(1)
assert avg.answer == 0
assert avg.delta_time == 0
for i in range(2, 10):
averager.update_average(i)
assert avg.answer == 0
assert avg.delta_time == 0
averager.update_average(10)
assert avg.answer == 5.5
assert avg.delta_time > 0
def test_averager_function_none():
averager = Avg.TimeAverager(1, None)
averager.update_average(12.345)
|
test_averager_averages
|
string.rs
|
use crate::formatter_traits::FormatTokenAndNode;
use crate::{FormatElement, FormatResult, Formatter, ToFormatElement};
use rome_js_syntax::JsxString;
impl ToFormatElement for JsxString {
fn
|
(&self, formatter: &Formatter) -> FormatResult<FormatElement> {
self.value_token().format(formatter)
}
}
|
to_format_element
|
bitfield.rs
|
use serde::{Deserialize, Serialize};
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct Bitfield {
data: Vec<u8>
}
impl Bitfield {
pub fn new(length: usize) -> Bitfield {
Bitfield {
data: vec![
0;
if length % 8 == 0 {
length / 8
} else {
length / 8 + 1
}
]
}
}
pub fn from_bytes(data: &[u8]) -> Bitfield {
Bitfield {
data: data.to_vec()
}
|
pub fn as_bytes(&self) -> &[u8] {
self.data.as_slice()
}
/// Get a bit from the bitfield
/// TODO: Maybe it's not at byte offset `(i % 8)` but `(7 - (i % 8))`
pub fn get(&self, i: usize) -> bool {
self.data[i / 8] & (1 << (7 - (i % 8))) != 0
}
/// Set a bit in the bitfield
/// TODO: Maybe it's not at byte offset `(i % 8)` but `(7 - (i % 8))`
pub fn set(&mut self, i: usize, value: bool) {
if value {
self.data[i / 8] = self.data[i / 8] | (1 << (7 - (i % 8)));
} else {
self.data[i / 8] = self.data[i / 8] & (0b11111111 ^ (1 << (7 - (i % 8))));
}
}
}
|
}
|
days-since.pipe.ts
|
import { Pipe, PipeTransform } from '@angular/core';
@Pipe({
name: 'daysSince'
})
export class DaysSincePipe implements PipeTransform {
|
let today:Date = new Date(); //get current date and time
let todayWithNoTime:any = new Date(today.getFullYear(),today.getMonth(),today.getDate())
var timeDifference =Math.abs(value-todayWithNoTime )
var daysDifference = Math.ceil(timeDifference / (1000 * 3600 * 24));
return daysDifference;
}
}
|
transform(value: any): number {
|
member_test.go
|
// Copyright 2018 TiKV Project Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// See the License for the specific language governing permissions and
// limitations under the License.
package member_test
import (
"bytes"
"context"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
"sync"
"testing"
"time"
. "github.com/pingcap/check"
"github.com/pingcap/errors"
"github.com/pingcap/kvproto/pkg/pdpb"
"github.com/tikv/pd/pkg/etcdutil"
"github.com/tikv/pd/pkg/testutil"
"github.com/tikv/pd/server"
"github.com/tikv/pd/server/config"
"github.com/tikv/pd/tests"
"go.uber.org/goleak"
)
func Test(t *testing.T) {
TestingT(t)
}
func TestMain(m *testing.M) {
goleak.VerifyTestMain(m, testutil.LeakOptions...)
}
var _ = Suite(&serverTestSuite{})
type serverTestSuite struct {
ctx context.Context
cancel context.CancelFunc
}
func (s *serverTestSuite) SetUpSuite(c *C) {
s.ctx, s.cancel = context.WithCancel(context.Background())
server.EnableZap = true
}
func (s *serverTestSuite) TearDownSuite(c *C) {
s.cancel()
}
func (s *serverTestSuite) TestMemberDelete(c *C) {
dcLocationConfig := map[string]string{
"pd1": "dc-1",
"pd2": "dc-2",
"pd3": "dc-3",
}
dcLocationNum := len(dcLocationConfig)
cluster, err := tests.NewTestCluster(s.ctx, dcLocationNum, func(conf *config.Config, serverName string) {
conf.LocalTSO.EnableLocalTSO = true
conf.LocalTSO.DCLocation = dcLocationConfig[serverName]
})
defer cluster.Destroy()
c.Assert(err, IsNil)
err = cluster.RunInitialServers()
c.Assert(err, IsNil)
leaderName := cluster.WaitLeader()
c.Assert(leaderName, Not(Equals), "")
leader := cluster.GetServer(leaderName)
var members []*tests.TestServer
for _, s := range cluster.GetConfig().InitialServers {
if s.Name != leaderName
|
}
c.Assert(members, HasLen, 2)
var table = []struct {
path string
status int
members []*config.Config
}{
{path: "name/foobar", status: http.StatusNotFound},
{path: "name/" + members[0].GetConfig().Name, members: []*config.Config{leader.GetConfig(), members[1].GetConfig()}},
{path: "name/" + members[0].GetConfig().Name, status: http.StatusNotFound},
{path: fmt.Sprintf("id/%d", members[1].GetServerID()), members: []*config.Config{leader.GetConfig()}},
}
httpClient := &http.Client{Timeout: 15 * time.Second}
for _, t := range table {
c.Log(time.Now(), "try to delete:", t.path)
testutil.WaitUntil(c, func(c *C) bool {
addr := leader.GetConfig().ClientUrls + "/pd/api/v1/members/" + t.path
req, err := http.NewRequest("DELETE", addr, nil)
c.Assert(err, IsNil)
res, err := httpClient.Do(req)
c.Assert(err, IsNil)
defer res.Body.Close()
// Check by status.
if t.status != 0 {
if res.StatusCode != t.status {
time.Sleep(time.Second)
return false
}
return true
}
// Check by member list.
cluster.WaitLeader()
if err = s.checkMemberList(c, leader.GetConfig().ClientUrls, t.members); err != nil {
c.Logf("check member fail: %v", err)
time.Sleep(time.Second)
return false
}
return true
})
}
// Check whether the dc-location info of the corresponding member is deleted.
for _, member := range members {
key := member.GetServer().GetMember().GetDCLocationPath(member.GetServerID())
resp, err := etcdutil.EtcdKVGet(leader.GetEtcdClient(), key)
c.Assert(err, IsNil)
c.Assert(len(resp.Kvs), Equals, 0)
}
}
func (s *serverTestSuite) checkMemberList(c *C, clientURL string, configs []*config.Config) error {
httpClient := &http.Client{Timeout: 15 * time.Second}
addr := clientURL + "/pd/api/v1/members"
res, err := httpClient.Get(addr)
c.Assert(err, IsNil)
defer res.Body.Close()
buf, err := ioutil.ReadAll(res.Body)
c.Assert(err, IsNil)
if res.StatusCode != http.StatusOK {
return errors.Errorf("load members failed, status: %v, data: %q", res.StatusCode, buf)
}
data := make(map[string][]*pdpb.Member)
json.Unmarshal(buf, &data)
if len(data["members"]) != len(configs) {
return errors.Errorf("member length not match, %v vs %v", len(data["members"]), len(configs))
}
for _, member := range data["members"] {
for _, cfg := range configs {
if member.GetName() == cfg.Name {
c.Assert(member.ClientUrls, DeepEquals, []string{cfg.ClientUrls})
c.Assert(member.PeerUrls, DeepEquals, []string{cfg.PeerUrls})
}
}
}
return nil
}
func (s *serverTestSuite) TestLeaderPriority(c *C) {
cluster, err := tests.NewTestCluster(s.ctx, 3)
defer cluster.Destroy()
c.Assert(err, IsNil)
err = cluster.RunInitialServers()
c.Assert(err, IsNil)
cluster.WaitLeader()
leader1, err := cluster.GetServer("pd1").GetEtcdLeader()
c.Assert(err, IsNil)
server1 := cluster.GetServer(leader1)
addr := server1.GetConfig().ClientUrls
// PD leader should sync with etcd leader.
testutil.WaitUntil(c, func(c *C) bool {
return cluster.GetLeader() == leader1
})
// Bind a lower priority to current leader.
s.post(c, addr+"/pd/api/v1/members/name/"+leader1, `{"leader-priority": -1}`)
// Wait etcd leader change.
leader2 := s.waitEtcdLeaderChange(c, server1, leader1)
// PD leader should sync with etcd leader again.
testutil.WaitUntil(c, func(c *C) bool {
return cluster.GetLeader() == leader2
})
}
func (s *serverTestSuite) post(c *C, url string, body string) {
testutil.WaitUntil(c, func(c *C) bool {
res, err := http.Post(url, "", bytes.NewBufferString(body))
c.Assert(err, IsNil)
b, err := ioutil.ReadAll(res.Body)
res.Body.Close()
c.Assert(err, IsNil)
c.Logf("post %s, status: %v res: %s", url, res.StatusCode, string(b))
return res.StatusCode == http.StatusOK
})
}
func (s *serverTestSuite) waitEtcdLeaderChange(c *C, server *tests.TestServer, old string) string {
var leader string
testutil.WaitUntil(c, func(c *C) bool {
var err error
leader, err = server.GetEtcdLeader()
if err != nil {
return false
}
if leader == old {
// Priority check could be slow. So we sleep longer here.
time.Sleep(5 * time.Second)
}
return leader != old
})
return leader
}
func (s *serverTestSuite) TestLeaderResign(c *C) {
cluster, err := tests.NewTestCluster(s.ctx, 3)
defer cluster.Destroy()
c.Assert(err, IsNil)
err = cluster.RunInitialServers()
c.Assert(err, IsNil)
leader1 := cluster.WaitLeader()
addr1 := cluster.GetServer(leader1).GetConfig().ClientUrls
s.post(c, addr1+"/pd/api/v1/leader/resign", "")
leader2 := s.waitLeaderChange(c, cluster, leader1)
c.Log("leader2:", leader2)
addr2 := cluster.GetServer(leader2).GetConfig().ClientUrls
s.post(c, addr2+"/pd/api/v1/leader/transfer/"+leader1, "")
leader3 := s.waitLeaderChange(c, cluster, leader2)
c.Assert(leader3, Equals, leader1)
}
func (s *serverTestSuite) waitLeaderChange(c *C, cluster *tests.TestCluster, old string) string {
var leader string
testutil.WaitUntil(c, func(c *C) bool {
leader = cluster.GetLeader()
if leader == old || leader == "" {
time.Sleep(time.Second)
return false
}
return true
})
return leader
}
func (s *serverTestSuite) TestMoveLeader(c *C) {
cluster, err := tests.NewTestCluster(s.ctx, 5)
defer cluster.Destroy()
c.Assert(err, IsNil)
err = cluster.RunInitialServers()
c.Assert(err, IsNil)
cluster.WaitLeader()
var wg sync.WaitGroup
wg.Add(5)
for _, s := range cluster.GetServers() {
go func(s *tests.TestServer) {
defer wg.Done()
if s.IsLeader() {
s.ResignLeader()
} else {
old, _ := s.GetEtcdLeaderID()
s.MoveEtcdLeader(old, s.GetServerID())
}
}(s)
}
done := make(chan struct{})
go func() {
wg.Wait()
close(done)
}()
select {
case <-done:
case <-time.After(10 * time.Second):
c.Fatal("move etcd leader does not return in 10 seconds")
}
}
var _ = Suite(&leaderTestSuite{})
type leaderTestSuite struct {
ctx context.Context
cancel context.CancelFunc
svr *server.Server
wg sync.WaitGroup
done chan bool
cfg *config.Config
}
func (s *leaderTestSuite) SetUpSuite(c *C) {
s.ctx, s.cancel = context.WithCancel(context.Background())
s.cfg = server.NewTestSingleConfig(c)
s.wg.Add(1)
s.done = make(chan bool)
svr, err := server.CreateServer(s.ctx, s.cfg)
c.Assert(err, IsNil)
err = svr.Run()
// Send requests after server has started.
go s.sendRequest(c, s.cfg.ClientUrls)
time.Sleep(100 * time.Millisecond)
c.Assert(err, IsNil)
s.svr = svr
}
func (s *leaderTestSuite) TearDownSuite(c *C) {
s.cancel()
s.svr.Close()
testutil.CleanServer(s.cfg.DataDir)
}
func (s *leaderTestSuite) TestGetLeader(c *C) {
mustWaitLeader(c, []*server.Server{s.svr})
leader := s.svr.GetLeader()
c.Assert(leader, NotNil)
s.done <- true
s.wg.Wait()
}
func (s *leaderTestSuite) sendRequest(c *C, addr string) {
defer s.wg.Done()
req := &pdpb.AllocIDRequest{
Header: testutil.NewRequestHeader(0),
}
for {
select {
case <-s.done:
return
default:
// We don't need to check the response and error,
// just make sure the server will not panic.
grpcPDClient := testutil.MustNewGrpcClient(c, addr)
if grpcPDClient != nil {
_, _ = grpcPDClient.AllocID(context.Background(), req)
}
}
time.Sleep(10 * time.Millisecond)
}
}
func mustWaitLeader(c *C, svrs []*server.Server) *server.Server {
var leader *server.Server
testutil.WaitUntil(c, func(c *C) bool {
for _, s := range svrs {
if !s.IsClosed() && s.GetMember().IsLeader() {
leader = s
return true
}
}
return false
})
return leader
}
|
{
members = append(members, cluster.GetServer(s.Name))
}
|
exception.rs
|
/*******************************************************************************
* (c) 2021 Zondax GmbH
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
********************************************************************************/
use crate::sys::errors::{catch, throw_raw, Error as SysError};
use crate::{
constants::ApduError as Error,
dispatcher::{ApduHandler, INS_DEV_EXCEPT},
utils::ApduBufferRead,
};
use std::convert::TryFrom;
pub struct
|
{}
impl ApduHandler for Except {
#[inline(never)]
fn handle<'apdu>(
_: &mut u32,
tx: &mut u32,
buffer: ApduBufferRead<'apdu>,
) -> Result<(), Error> {
*tx = 0;
if buffer.ins() != INS_DEV_EXCEPT {
return Err(Error::InsNotSupported);
}
let do_catch = buffer.p1() >= 1;
let exception = buffer.p2();
#[allow(unreachable_code)]
let call = move || {
let ex = match SysError::try_from(exception as u16) {
Ok(ex) => ex,
Err(_) => return false,
};
throw_raw(ex.into());
true
};
//if we have catch == true, then we should always
// be returning the passed code
// otherwise... don't know yet!
let res = if do_catch { catch(call) } else { Ok(call()) };
let buffer = buffer.write();
match res {
//if exception was unspecified, then the call returns false,
//so we can match against it and return our error
Ok(false) => {
return Err(Error::InvalidP1P2);
}
Ok(_) => {
let n: u64 = 0x100000000;
let n = n.to_be_bytes();
let len = n.len();
buffer[..len].copy_from_slice(&n[..]);
*tx = len as u32;
}
Err(ex) => {
let ex: u32 = ex.into();
let n = (ex as u64).to_be_bytes();
let len = n.len();
buffer[..len].copy_from_slice(&n[..]);
*tx = len as u32;
}
}
Ok(())
}
}
#[cfg(test)]
mod tests {
use crate::{
assert_error_code,
constants::ApduError as Error,
dispatcher::{handle_apdu, CLA, INS_DEV_EXCEPT},
};
use std::convert::TryInto;
#[test]
#[should_panic(expected = "exception = 1")]
fn throw() {
let mut flags = 0;
let mut tx = 0;
let mut buffer = [0; 260];
let rx = 5;
let ex: u16 = 1;
buffer[..rx].copy_from_slice(&[CLA, INS_DEV_EXCEPT, 0, ex as u8, 0]);
handle_apdu(&mut flags, &mut tx, rx as u32, &mut buffer);
std::dbg!(&buffer[..tx as usize]);
assert!(tx > 2);
assert_error_code!(tx, buffer, Error::Success);
assert_eq!(&buffer[..2], &1u32.to_be_bytes()[..])
}
#[test]
#[should_panic(expected = "exception = 1")] //unfortunately we don't catch during tests...
fn catch() {
let mut flags = 0;
let mut tx = 0;
let mut buffer = [0; 260];
let rx = 5;
let ex: u16 = 1;
buffer[..rx].copy_from_slice(&[CLA, INS_DEV_EXCEPT, 1, ex as u8, 0]);
handle_apdu(&mut flags, &mut tx, rx as u32, &mut buffer);
std::dbg!(&buffer[..tx as usize]);
assert!(tx > 2);
assert_error_code!(tx, buffer, Error::Success);
//if we don't throw properly we should get this...
assert_eq!(&buffer[..4], &0x100000000u64.to_be_bytes()[..])
}
}
|
Except
|
logger.ts
|
import moment from 'moment'
import morgan from 'morgan'
import chalk from 'chalk'
import environment from '../environments/environment'
export enum LogStyle{
succes,
info,
warning,
error
}
export class
|
{
private static instance: Logger
constructor() {
console.log('┌────────────────────────────────────────────┐');
console.log('| CONFIGURATION |');
console.log('└────────────────────────────────────────────┘');
if (environment.name == 'development') {
console.log(' Environment ' + chalk.yellow(environment.name.toUpperCase()));
console.log(' Database ' + chalk.yellow(environment.db.host.toUpperCase()));
console.log(' Port ' + chalk.yellow(environment.app.port));
}
else {
console.log(' Environment ' + environment.name.toUpperCase());
console.log(' Database ' + environment.db.host.toUpperCase());
console.log(' Port ' + environment.app.port);
}
console.log('┌────────────────────────────────────────────┐');
console.log('| LOGS |');
console.log('└────────────────────────────────────────────┘');
}
public static getInstance() {
if (!Logger.instance)
Logger.instance = new Logger();
return Logger.instance;
}
public printLog(style: LogStyle, log: string) {
let trimmedLog = log
if(log.length > 50)
trimmedLog = log.substring(0,50)+"..."
if (environment.name !== 'development')
return console.log(this.getDate() + trimmedLog);
if (style == LogStyle.info)
return console.log(chalk.gray(this.getDate()) + trimmedLog);
if (style == LogStyle.succes)
return console.log(chalk.gray(this.getDate()) + chalk.green(trimmedLog));
if (style == LogStyle.warning)
return console.log(chalk.gray(this.getDate()) + chalk.yellow(trimmedLog));
if (style == LogStyle.error)
return console.log(chalk.gray(this.getDate()) + chalk.red(trimmedLog));
}
public config() {
morgan.token('urlOriginal', function getUrlToken(req) {
return req.originalUrl;
});
if (environment.name == 'development') {
morgan.token('statusColor', (req, res, args) => {
var status = res.statusCode;
var color = status >= 500 ? 31 // red
: status >= 400 ? 33 // yellow
: status >= 300 ? 36 // cyan
: status >= 200 ? 32 // green
: 0; // no color
return '\x1b[' + color + 'm' + status + '\x1b[0m';
});
morgan.token('timeColored', () => {
var time = chalk.gray(this.getDate());
return time;
});
morgan.token('trimedUrl', (req, res, args) => {
var trimedUrl = req.originalUrl;
if(trimedUrl.length>50)
trimedUrl = trimedUrl.substring(0,50)+"..."
return trimedUrl;
});
morgan.format('custom', ':timeColored\x1b[32m:method\x1b[0m \x1b[0m:trimedUrl\x1b[0m :statusColor - :response-time ms');
}
else {
morgan.token('time', () => {
var time = this.getDate();
return time;
});
morgan.format('custom', ':time:method :urlOriginal :status - :response-time ms');
}
}
public getDate() { return '[' + moment().format('DD/MM/YYYY-HH:mm:ss') + '] '; }
}
|
Logger
|
RowReorderBehavior.d.ts
|
import { Behavior } from "../Model/Behavior";
import { State } from "../Model/State";
import { PointerLocation, Direction } from "../../core";
import { PointerEvent } from "../Model/domEventsTypes";
export declare class
|
extends Behavior {
private initialRowIdx;
private lastPossibleDropLocation?;
private pointerOffset;
private selectedIds;
private position;
autoScrollDirection: Direction;
handlePointerDown(event: PointerEvent, location: PointerLocation, state: State): State;
handlePointerMove(event: PointerEvent, location: PointerLocation, state: State): State;
getShadowPosition(location: PointerLocation, state: State): number;
getLastPossibleDropLocation(state: State, currentLocation: PointerLocation): PointerLocation | undefined;
handlePointerUp(event: PointerEvent, location: PointerLocation, state: State): State;
handleContextMenu(event: PointerEvent, state: State): State;
}
|
RowReorderBehavior
|
mod.rs
|
use std::collections::HashMap;
use std::fmt;
use std::hash::BuildHasher;
use std::time::Instant;
use contract_ffi::key::Key;
use contract_ffi::value::Value;
use engine_shared::logging::{log_duration, log_metric, GAUGE};
use engine_shared::newtypes::{Blake2bHash, CorrelationId};
use engine_shared::transform::{self, Transform, TypeMismatch};
use trie::Trie;
use trie_store::operations::{read, write, ReadResult, WriteResult};
use trie_store::{Transaction, TransactionSource, TrieStore};
pub mod in_memory;
pub mod lmdb;
/// A reader of state
pub trait StateReader<K, V> {
/// An error which occurs when reading state
type Error;
/// Returns the state value from the corresponding key
fn read(&self, correlation_id: CorrelationId, key: &K) -> Result<Option<V>, Self::Error>;
}
#[derive(Debug)]
pub enum
|
{
RootNotFound,
Success(Blake2bHash),
KeyNotFound(Key),
TypeMismatch(TypeMismatch),
}
impl fmt::Display for CommitResult {
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
match self {
CommitResult::RootNotFound => write!(f, "Root not found"),
CommitResult::Success(hash) => write!(f, "Success: {}", hash),
CommitResult::KeyNotFound(key) => write!(f, "Key not found: {}", key),
CommitResult::TypeMismatch(type_mismatch) => {
write!(f, "Type mismatch: {:?}", type_mismatch)
}
}
}
}
impl From<transform::Error> for CommitResult {
fn from(error: transform::Error) -> Self {
match error {
transform::Error::TypeMismatch(type_mismatch) => {
CommitResult::TypeMismatch(type_mismatch)
}
}
}
}
pub trait History {
type Error;
type Reader: StateReader<Key, Value, Error = Self::Error>;
/// Checkouts to the post state of a specific block.
fn checkout(&self, prestate_hash: Blake2bHash) -> Result<Option<Self::Reader>, Self::Error>;
/// Applies changes and returns a new post state hash.
/// block_hash is used for computing a deterministic and unique keys.
fn commit(
&mut self,
correlation_id: CorrelationId,
prestate_hash: Blake2bHash,
effects: HashMap<Key, Transform>,
) -> Result<CommitResult, Self::Error>;
fn current_root(&self) -> Blake2bHash;
fn empty_root(&self) -> Blake2bHash;
}
const GLOBAL_STATE_COMMIT_READS: &str = "global_state_commit_reads";
const GLOBAL_STATE_COMMIT_WRITES: &str = "global_state_commit_writes";
const GLOBAL_STATE_COMMIT_DURATION: &str = "global_state_commit_duration";
const GLOBAL_STATE_COMMIT_READ_DURATION: &str = "global_state_commit_read_duration";
const GLOBAL_STATE_COMMIT_WRITE_DURATION: &str = "global_state_commit_write_duration";
const COMMIT: &str = "commit";
pub fn commit<'a, R, S, H, E>(
environment: &'a R,
store: &S,
correlation_id: CorrelationId,
prestate_hash: Blake2bHash,
effects: HashMap<Key, Transform, H>,
) -> Result<CommitResult, E>
where
R: TransactionSource<'a, Handle = S::Handle>,
S: TrieStore<Key, Value>,
S::Error: From<R::Error>,
E: From<R::Error> + From<S::Error> + From<contract_ffi::bytesrepr::Error>,
H: BuildHasher,
{
let mut txn = environment.create_read_write_txn()?;
let mut current_root = prestate_hash;
let maybe_root: Option<Trie<Key, Value>> = store.get(&txn, ¤t_root)?;
if maybe_root.is_none() {
return Ok(CommitResult::RootNotFound);
};
let start = Instant::now();
let mut reads: i32 = 0;
let mut writes: i32 = 0;
for (key, transform) in effects.into_iter() {
let read_result = read::<_, _, _, _, E>(correlation_id, &txn, store, ¤t_root, &key)?;
log_duration(
correlation_id,
GLOBAL_STATE_COMMIT_READ_DURATION,
COMMIT,
start.elapsed(),
);
reads += 1;
let value = match (read_result, transform) {
(ReadResult::NotFound, Transform::Write(new_value)) => new_value,
(ReadResult::NotFound, _) => {
return Ok(CommitResult::KeyNotFound(key));
}
(ReadResult::Found(current_value), transform) => match transform.apply(current_value) {
Ok(updated_value) => updated_value,
Err(err) => return Ok(err.into()),
},
_x @ (ReadResult::RootNotFound, _) => panic!(stringify!(_x._1)),
};
let write_result =
write::<_, _, _, _, E>(correlation_id, &mut txn, store, ¤t_root, &key, &value)?;
log_duration(
correlation_id,
GLOBAL_STATE_COMMIT_WRITE_DURATION,
COMMIT,
start.elapsed(),
);
match write_result {
WriteResult::Written(root_hash) => {
current_root = root_hash;
writes += 1;
}
WriteResult::AlreadyExists => (),
_x @ WriteResult::RootNotFound => panic!(stringify!(_x)),
}
}
txn.commit()?;
log_duration(
correlation_id,
GLOBAL_STATE_COMMIT_DURATION,
COMMIT,
start.elapsed(),
);
log_metric(
correlation_id,
GLOBAL_STATE_COMMIT_READS,
COMMIT,
GAUGE,
f64::from(reads),
);
log_metric(
correlation_id,
GLOBAL_STATE_COMMIT_WRITES,
COMMIT,
GAUGE,
f64::from(writes),
);
Ok(CommitResult::Success(current_root))
}
|
CommitResult
|
lib.rs
|
//! Asynchronous tasks for GUI programming, inspired by Elm.
#![deny(missing_docs)]
#![deny(missing_debug_implementations)]
#![deny(unused_results)]
#![forbid(unsafe_code)]
#![forbid(rust_2018_idioms)]
pub use futures;
mod command;
mod runtime;
pub mod executor;
pub mod subscription;
pub use command::Command;
pub use executor::Executor;
pub use runtime::Runtime;
pub use subscription::Subscription;
/// A boxed static future.
///
/// - On native platforms, it needs a `Send` requirement.
/// - On the Web platform, it does not need a `Send` requirement.
#[cfg(not(target_arch = "wasm32"))]
pub type BoxFuture<T> = futures::future::BoxFuture<'static, T>;
/// A boxed static future.
///
/// - On native platforms, it needs a `Send` requirement.
|
/// A boxed static stream.
///
/// - On native platforms, it needs a `Send` requirement.
/// - On the Web platform, it does not need a `Send` requirement.
#[cfg(not(target_arch = "wasm32"))]
pub type BoxStream<T> = futures::stream::BoxStream<'static, T>;
/// A boxed static stream.
///
/// - On native platforms, it needs a `Send` requirement.
/// - On the Web platform, it does not need a `Send` requirement.
#[cfg(target_arch = "wasm32")]
pub type BoxStream<T> = futures::stream::LocalBoxStream<'static, T>;
|
/// - On the Web platform, it does not need a `Send` requirement.
#[cfg(target_arch = "wasm32")]
pub type BoxFuture<T> = futures::future::LocalBoxFuture<'static, T>;
|
modal_body_text.test.js
|
import React from 'react';
import { render } from 'enzyme';
import { requiredProps } from '../../test/required_props';
|
test('renders KuiModalBodyText', () => {
const component = <KuiModalBodyText { ...requiredProps }>children</KuiModalBodyText>;
expect(render(component)).toMatchSnapshot();
});
|
import {
KuiModalBodyText,
} from './modal_body_text';
|
drag-scroll.directive.d.ts
|
import { CdkDrag, DragRef } from '@angular/cdk/drag-drop';
import { OnDestroy, NgZone, ChangeDetectorRef, SimpleChanges, OnChanges } from '@angular/core';
import { Subject } from 'rxjs';
import { AutoScroll } from './auto-scroll';
import { DragDebugService } from './drag-debug.service';
export declare class DragScrollDirective<T = any> implements OnDestroy, OnChanges {
private cdkDrag;
private dragDebugService;
private zone;
private changeDetectorRef;
|
dragRef: DragRef<CdkDrag<T>>;
autoScroll: AutoScroll;
lastScroll: {
top: number;
left: number;
};
dragConnectedIds: string[];
scrollContainer: HTMLElement;
constructor(cdkDrag: CdkDrag, dragDebugService: DragDebugService, zone: NgZone, changeDetectorRef: ChangeDetectorRef);
ngOnChanges(changes: SimpleChanges): void;
ngOnDestroy(): void;
started(): void;
ended(): void;
entered(): void;
exited(): void;
private handleScroll;
private destroyAutoScroll;
private getDropListRef;
private addDebugInfo;
private dragFixContainer;
private syncSiblings;
private syncItems;
private adjustContainers;
private adjustItems;
private log;
}
|
destroy$: Subject<void>;
stopDragging$: Subject<void>;
|
candidate.rs
|
/// Candidates
#[derive(Queryable, Debug, Serialize, Deserialize)]
pub struct Candidate {
pub candidate: String,
|
}
|
|
FileLine.js
|
import React from 'react';
import PropTypes from 'prop-types';
import { ClassManager } from '@axa-fr/react-toolkit-core';
const propTypes = {
file: PropTypes.object.isRequired,
onClick: PropTypes.func.isRequired,
id: PropTypes.string.isRequired,
disabled: PropTypes.bool,
className: PropTypes.string,
classModifier: PropTypes.string,
};
const defaultClassName = 'custom-line-file af-file-line';
const defaultProps = {
disabled: false,
className: defaultClassName,
classModifier: null,
};
const style = {
maxWidth: '200px',
maxHeight: '200px',
};
const Preview = ({ file }) => {
if (file && file.type && file.type.startsWith('image')) {
return (
<img
src={file.preview}
style={style}
className="img-thumbnail"
alt="File Preview"
|
return <span>TODO a définir le comportement avec les UX</span>;
};
const FileLine = props => {
const { className, classModifier, file, disabled, id, onClick } = props;
const componentClassName = ClassManager.getComponentClassName(
className,
classModifier,
defaultClassName
);
return (
<tr className={componentClassName}>
<td className="text-center">
<Preview file={file} />
</td>
<td>{file.name}</td>
<td className="text-center">{file.size}</td>
<td className="text-center">
<button
disabled={disabled}
type="button"
className="btn btn-danger"
onClick={() => onClick(id)}>
X
</button>
</td>
</tr>
);
};
FileLine.propTypes = propTypes;
FileLine.defaultProps = defaultProps;
export default FileLine;
|
/>
);
}
|
test_ir_spectra.py
|
from __future__ import unicode_literals
import unittest
import os
from pymatgen.util.testing import PymatgenTest
from monty.serialization import loadfn
test_dir = os.path.join(os.path.dirname(__file__), "..", "..", "..",
'test_files')
class
|
(PymatgenTest):
def setUp(self):
self.ir_spectra = loadfn(os.path.join(test_dir, 'ir_spectra_mp-991652_DDB.json'))
def test_basic(self):
self.ir_spectra.write_json('test.json')
ir_spectra = loadfn('test.json')
irdict = ir_spectra.as_dict()
ir_spectra.from_dict(irdict)
ir_spectra.plot(show=False)
def tearDown(self):
if os.path.isfile('test.json'):
os.remove('test.json')
if __name__ == '__main__':
unittest.main()
|
IRDielectricTensorTest
|
observable.test.ts
|
import { describe, it } from 'mocha'
import { expect } from 'chai'
import { interval, map, merge, multicast, stream, switchMap, zip } from '../../src/utils/observable'
describe('observable', function() {
const delay = 5
const double = (num: number) => num * 2
const count = [0, 1, 2]
const doubleCount = count.slice().map(double)
const makeObserver = (arr: Array<number>) => {
const vars = {
iterations: 0,
completed: false,
error: false
}
const observer = {
next: (num: number) => expect(num).eq(arr[vars.iterations++]),
complete: () => vars.completed = true,
error: () => vars.error = true
}
return { observer, vars }
}
it('interval', function(done) {
const observable = interval(delay)
const unsub = observable({
next: num => {
if(num >= count.length) {
unsub()
done()
}
}
})
})
it('stream', function() {
const { vars, observer } = makeObserver(count)
const observable = stream(count)
observable(observer)
expect(vars.completed).eq(true)
expect(vars.error).eq(false)
expect(vars.iterations).eq(count.length)
})
it('map', function() {
const { vars, observer } = makeObserver(doubleCount)
const observable = map(stream(count), double)
observable(observer)
expect(vars.iterations).eq(count.length)
expect(vars.completed).eq(true)
expect(vars.error).eq(false)
})
it('merge', function() {
let completed = false
let error = false
let iterations = 0
const countObservable = stream(count)
const doubleCountObservable = stream(doubleCount)
const merged = merge(countObservable, doubleCountObservable)
merged({
next: num => {
expect(num).to.satisfy(function(num: number) {
return count.includes(num) || doubleCount.includes(num)
})
iterations++
},
complete: () => completed = true,
error: () => error = true
})
expect(iterations).eq(count.length + doubleCount.length)
expect(completed).eq(true)
expect(error).eq(false)
})
it('multicast', function() {
const observer1 = makeObserver(count)
const observer2 = makeObserver(count)
const observable = multicast(stream(count), observer1.observer, observer2.observer)
let completed = false
observable({
complete: () => completed = true
})
expect(observer1.vars.completed).eq(observer2.vars.completed)
expect(observer1.vars.error).eq(observer2.vars.error)
expect(observer1.vars.iterations).eq(observer2.vars.iterations)
expect(completed).eq(true)
})
it('switchmap', function() {
let completed = false
let errors = 0
let iterations = 0
const observable = switchMap(stream(count), stream(count))
observable({
next: () => iterations++,
complete: () => completed = true,
error: () => errors++
})
expect(iterations).eq(count.length ** 2)
expect(errors).eq(0)
expect(completed).eq(true)
})
it('zip', function() {
let completed = false
let error = false
let iterations = 0
const observable = zip(stream(count), stream(doubleCount))
observable({
next: arr => {
expect(arr).to.be.an('array')
iterations++
},
complete: () => completed = true,
error: () => error = true
})
expect(completed).eq(true)
|
expect(error).eq(false)
expect(iterations).eq(count.length * 2)
})
})
| |
coveo.js
|
!function(){"use strict";var e,t=window.analytics,o=document.getElementById("coveo-script").dataset,n=document.querySelector(".js-coveo");Coveo.SearchEndpoint.endpoints.default=new Coveo.SearchEndpoint({restUri:"https://platform.cloud.coveo.com/rest/search",accessToken:o.accessToken}),n.addEventListener("buildingQuery",function(e){e.detail.queryBuilder.pipeline=o.queryPipeline});var c=document.querySelector(".modal-backdrop"),s=document.querySelector("nav.nav"),d=document.querySelector(".js-search-trigger"),i=document.querySelector(".js-search-ui"),r=document.querySelector(".js-search-close");function a(){e||(Coveo.init(n),e=!0),c.classList.add("show"),c.classList.remove("mobile"),document.body.classList.add("no-scroll"),document.body.classList.remove("mobile"),i.classList.add("show"),s.classList.remove("active"),tippy.hideAll(),t&&t.track("Clicked Open Search")}function
|
(e){c.classList.remove("show"),document.body.classList.remove("no-scroll"),i.classList.remove("show")}function u(e){e.stopPropagation()}d.addEventListener("click",a),d.addEventListener("touchend",a),window.addEventListener("click",l),window.addEventListener("touchend",l),r.addEventListener("click",l),r.addEventListener("touchend",l),document.addEventListener("keydown",function(e){27===e.keyCode&&l()}),n.addEventListener("click",u),n.addEventListener("touchend",u)}();
|
l
|
wall_stop.py
|
#!/usr/bin/env python
import rospy,copy
from geometry_msgs.msg import Twist
from std_srvs.srv import Trigger, TriggerResponse
from pimouse_ros.msg import LightSensorValues
class WallStop():
|
if __name__ == '__main__':
rospy.init_node('wall_stop')
rospy.wait_for_service('/motor_on')
rospy.wait_for_service('/motor_off')
rospy.on_shutdown(rospy.ServiceProxy('/motor_off',Trigger).call)
rospy.ServiceProxy('/motor_on',Trigger).call()
WallStop().run()
|
def __init__(self):
self.cmd_vel = rospy.Publisher('/cmd_vel',Twist,queue_size=1)
self.sensor_values = LightSensorValues()
rospy.Subscriber('/lightsensors',LightSensorValues,self.callback)
def callback(self,messages):
self.sensor_values = messages
def run(self):
rate = rospy.Rate(10)
data = Twist()
while not rospy.is_shutdown():
data.linear.x = 0.2 if self.sensor_values.sum_all < 500 else 0.0
self.cmd_vel.publish(data)
rate.sleep()
|
iterator.rs
|
// Copyright 2013-2016 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use cmp::Ordering;
use super::{Chain, Cycle, Cloned, Enumerate, Filter, FilterMap, FlatMap, Fuse};
use super::{Inspect, Map, Peekable, Scan, Skip, SkipWhile, StepBy, Take, TakeWhile, Rev};
use super::{Zip, Sum, Product};
use super::{ChainState, FromIterator, ZipImpl};
fn _assert_is_object_safe(_: &Iterator<Item=()>) {}
/// An interface for dealing with iterators.
///
/// This is the main iterator trait. For more about the concept of iterators
/// generally, please see the [module-level documentation]. In particular, you
/// may want to know how to [implement `Iterator`][impl].
///
/// [module-level documentation]: index.html
/// [impl]: index.html#implementing-iterator
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_on_unimplemented = "`{Self}` is not an iterator; maybe try calling \
`.iter()` or a similar method"]
pub trait Iterator {
/// The type of the elements being iterated over.
#[stable(feature = "rust1", since = "1.0.0")]
type Item;
/// Advances the iterator and returns the next value.
///
/// Returns [`None`] when iteration is finished. Individual iterator
/// implementations may choose to resume iteration, and so calling `next()`
/// again may or may not eventually start returning [`Some(Item)`] again at some
/// point.
///
/// [`None`]: ../../std/option/enum.Option.html#variant.None
/// [`Some(Item)`]: ../../std/option/enum.Option.html#variant.Some
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let a = [1, 2, 3];
///
/// let mut iter = a.iter();
///
/// // A call to next() returns the next value...
/// assert_eq!(Some(&1), iter.next());
/// assert_eq!(Some(&2), iter.next());
/// assert_eq!(Some(&3), iter.next());
///
/// // ... and then None once it's over.
/// assert_eq!(None, iter.next());
///
/// // More calls may or may not return None. Here, they always will.
/// assert_eq!(None, iter.next());
/// assert_eq!(None, iter.next());
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
fn next(&mut self) -> Option<Self::Item>;
/// Returns the bounds on the remaining length of the iterator.
///
/// Specifically, `size_hint()` returns a tuple where the first element
/// is the lower bound, and the second element is the upper bound.
///
/// The second half of the tuple that is returned is an [`Option`]`<`[`usize`]`>`.
/// A [`None`] here means that either there is no known upper bound, or the
/// upper bound is larger than [`usize`].
///
/// # Implementation notes
///
/// It is not enforced that an iterator implementation yields the declared
/// number of elements. A buggy iterator may yield less than the lower bound
/// or more than the upper bound of elements.
///
/// `size_hint()` is primarily intended to be used for optimizations such as
/// reserving space for the elements of the iterator, but must not be
/// trusted to e.g. omit bounds checks in unsafe code. An incorrect
/// implementation of `size_hint()` should not lead to memory safety
/// violations.
///
/// That said, the implementation should provide a correct estimation,
/// because otherwise it would be a violation of the trait's protocol.
///
/// The default implementation returns `(0, None)` which is correct for any
/// iterator.
///
/// [`usize`]: ../../std/primitive.usize.html
/// [`Option`]: ../../std/option/enum.Option.html
/// [`None`]: ../../std/option/enum.Option.html#variant.None
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let a = [1, 2, 3];
/// let iter = a.iter();
///
/// assert_eq!((3, Some(3)), iter.size_hint());
/// ```
///
/// A more complex example:
///
/// ```
/// // The even numbers from zero to ten.
/// let iter = (0..10).filter(|x| x % 2 == 0);
///
/// // We might iterate from zero to ten times. Knowing that it's five
/// // exactly wouldn't be possible without executing filter().
/// assert_eq!((0, Some(10)), iter.size_hint());
///
/// // Let's add five more numbers with chain()
/// let iter = (0..10).filter(|x| x % 2 == 0).chain(15..20);
///
/// // now both bounds are increased by five
/// assert_eq!((5, Some(15)), iter.size_hint());
/// ```
///
/// Returning `None` for an upper bound:
///
/// ```
/// // an infinite iterator has no upper bound
/// // and the maximum possible lower bound
/// let iter = 0..;
///
/// assert_eq!((usize::max_value(), None), iter.size_hint());
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn size_hint(&self) -> (usize, Option<usize>) { (0, None) }
/// Consumes the iterator, counting the number of iterations and returning it.
///
/// This method will evaluate the iterator until its [`next`] returns
/// [`None`]. Once [`None`] is encountered, `count()` returns the number of
/// times it called [`next`].
///
/// [`next`]: #tymethod.next
/// [`None`]: ../../std/option/enum.Option.html#variant.None
///
/// # Overflow Behavior
///
/// The method does no guarding against overflows, so counting elements of
/// an iterator with more than [`usize::MAX`] elements either produces the
/// wrong result or panics. If debug assertions are enabled, a panic is
/// guaranteed.
///
/// # Panics
///
/// This function might panic if the iterator has more than [`usize::MAX`]
/// elements.
///
/// [`usize::MAX`]: ../../std/isize/constant.MAX.html
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let a = [1, 2, 3];
/// assert_eq!(a.iter().count(), 3);
///
/// let a = [1, 2, 3, 4, 5];
/// assert_eq!(a.iter().count(), 5);
/// ```
#[inline]
#[rustc_inherit_overflow_checks]
#[stable(feature = "rust1", since = "1.0.0")]
fn count(self) -> usize where Self: Sized {
// Might overflow.
self.fold(0, |cnt, _| cnt + 1)
}
/// Consumes the iterator, returning the last element.
///
/// This method will evaluate the iterator until it returns [`None`]. While
/// doing so, it keeps track of the current element. After [`None`] is
/// returned, `last()` will then return the last element it saw.
///
/// [`None`]: ../../std/option/enum.Option.html#variant.None
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let a = [1, 2, 3];
/// assert_eq!(a.iter().last(), Some(&3));
///
/// let a = [1, 2, 3, 4, 5];
/// assert_eq!(a.iter().last(), Some(&5));
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn last(self) -> Option<Self::Item> where Self: Sized {
let mut last = None;
for x in self { last = Some(x); }
last
}
/// Returns the `n`th element of the iterator.
///
/// Like most indexing operations, the count starts from zero, so `nth(0)`
/// returns the first value, `nth(1)` the second, and so on.
///
/// Note that all preceding elements, as well as the returned element, will be
/// consumed from the iterator. That means that the preceding elements will be
/// discarded, and also that calling `nth(0)` multiple times on the same iterator
/// will return different elements.
///
/// `nth()` will return [`None`] if `n` is greater than or equal to the length of the
/// iterator.
///
/// [`None`]: ../../std/option/enum.Option.html#variant.None
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let a = [1, 2, 3];
/// assert_eq!(a.iter().nth(1), Some(&2));
/// ```
///
/// Calling `nth()` multiple times doesn't rewind the iterator:
///
/// ```
/// let a = [1, 2, 3];
///
/// let mut iter = a.iter();
///
/// assert_eq!(iter.nth(1), Some(&2));
/// assert_eq!(iter.nth(1), None);
/// ```
///
/// Returning `None` if there are less than `n + 1` elements:
///
/// ```
/// let a = [1, 2, 3];
/// assert_eq!(a.iter().nth(10), None);
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn nth(&mut self, mut n: usize) -> Option<Self::Item> {
for x in self {
if n == 0 { return Some(x) }
n -= 1;
}
None
}
/// Creates an iterator starting at the same point, but stepping by
/// the given amount at each iteration.
///
/// Note that it will always return the first element of the iterator,
/// regardless of the step given.
///
/// # Panics
///
/// The method will panic if the given step is `0`.
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// #![feature(iterator_step_by)]
/// let a = [0, 1, 2, 3, 4, 5];
/// let mut iter = a.into_iter().step_by(2);
///
/// assert_eq!(iter.next(), Some(&0));
/// assert_eq!(iter.next(), Some(&2));
/// assert_eq!(iter.next(), Some(&4));
/// assert_eq!(iter.next(), None);
/// ```
#[inline]
#[unstable(feature = "iterator_step_by",
reason = "unstable replacement of Range::step_by",
issue = "27741")]
fn step_by(self, step: usize) -> StepBy<Self> where Self: Sized {
assert!(step != 0);
StepBy{iter: self, step: step - 1, first_take: true}
}
/// Takes two iterators and creates a new iterator over both in sequence.
///
/// `chain()` will return a new iterator which will first iterate over
/// values from the first iterator and then over values from the second
/// iterator.
///
/// In other words, it links two iterators together, in a chain. 🔗
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let a1 = [1, 2, 3];
/// let a2 = [4, 5, 6];
///
/// let mut iter = a1.iter().chain(a2.iter());
///
/// assert_eq!(iter.next(), Some(&1));
/// assert_eq!(iter.next(), Some(&2));
/// assert_eq!(iter.next(), Some(&3));
/// assert_eq!(iter.next(), Some(&4));
/// assert_eq!(iter.next(), Some(&5));
/// assert_eq!(iter.next(), Some(&6));
/// assert_eq!(iter.next(), None);
/// ```
///
/// Since the argument to `chain()` uses [`IntoIterator`], we can pass
/// anything that can be converted into an [`Iterator`], not just an
/// [`Iterator`] itself. For example, slices (`&[T]`) implement
/// [`IntoIterator`], and so can be passed to `chain()` directly:
///
/// [`IntoIterator`]: trait.IntoIterator.html
/// [`Iterator`]: trait.Iterator.html
///
/// ```
/// let s1 = &[1, 2, 3];
/// let s2 = &[4, 5, 6];
///
/// let mut iter = s1.iter().chain(s2);
///
/// assert_eq!(iter.next(), Some(&1));
/// assert_eq!(iter.next(), Some(&2));
/// assert_eq!(iter.next(), Some(&3));
/// assert_eq!(iter.next(), Some(&4));
/// assert_eq!(iter.next(), Some(&5));
/// assert_eq!(iter.next(), Some(&6));
/// assert_eq!(iter.next(), None);
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn chain<U>(self, other: U) -> Chain<Self, U::IntoIter> where
Self: Sized, U: IntoIterator<Item=Self::Item>,
{
Chain{a: self, b: other.into_iter(), state: ChainState::Both}
}
/// 'Zips up' two iterators into a single iterator of pairs.
///
/// `zip()` returns a new iterator that will iterate over two other
/// iterators, returning a tuple where the first element comes from the
/// first iterator, and the second element comes from the second iterator.
///
/// In other words, it zips two iterators together, into a single one.
///
/// When either iterator returns [`None`], all further calls to [`next`]
/// will return [`None`].
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let a1 = [1, 2, 3];
/// let a2 = [4, 5, 6];
///
/// let mut iter = a1.iter().zip(a2.iter());
///
/// assert_eq!(iter.next(), Some((&1, &4)));
/// assert_eq!(iter.next(), Some((&2, &5)));
/// assert_eq!(iter.next(), Some((&3, &6)));
/// assert_eq!(iter.next(), None);
/// ```
///
/// Since the argument to `zip()` uses [`IntoIterator`], we can pass
/// anything that can be converted into an [`Iterator`], not just an
/// [`Iterator`] itself. For example, slices (`&[T]`) implement
/// [`IntoIterator`], and so can be passed to `zip()` directly:
///
/// [`IntoIterator`]: trait.IntoIterator.html
/// [`Iterator`]: trait.Iterator.html
///
/// ```
/// let s1 = &[1, 2, 3];
/// let s2 = &[4, 5, 6];
///
/// let mut iter = s1.iter().zip(s2);
///
/// assert_eq!(iter.next(), Some((&1, &4)));
/// assert_eq!(iter.next(), Some((&2, &5)));
/// assert_eq!(iter.next(), Some((&3, &6)));
/// assert_eq!(iter.next(), None);
/// ```
///
/// `zip()` is often used to zip an infinite iterator to a finite one.
/// This works because the finite iterator will eventually return [`None`],
/// ending the zipper. Zipping with `(0..)` can look a lot like [`enumerate`]:
///
/// ```
/// let enumerate: Vec<_> = "foo".chars().enumerate().collect();
///
/// let zipper: Vec<_> = (0..).zip("foo".chars()).collect();
///
/// assert_eq!((0, 'f'), enumerate[0]);
/// assert_eq!((0, 'f'), zipper[0]);
///
/// assert_eq!((1, 'o'), enumerate[1]);
/// assert_eq!((1, 'o'), zipper[1]);
///
/// assert_eq!((2, 'o'), enumerate[2]);
/// assert_eq!((2, 'o'), zipper[2]);
/// ```
///
/// [`enumerate`]: trait.Iterator.html#method.enumerate
/// [`next`]: ../../std/iter/trait.Iterator.html#tymethod.next
/// [`None`]: ../../std/option/enum.Option.html#variant.None
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn zip<U>(self, other: U) -> Zip<Self, U::IntoIter> where
Self: Sized, U: IntoIterator
{
Zip::new(self, other.into_iter())
}
/// Takes a closure and creates an iterator which calls that closure on each
/// element.
///
/// `map()` transforms one iterator into another, by means of its argument:
/// something that implements `FnMut`. It produces a new iterator which
/// calls this closure on each element of the original iterator.
///
/// If you are good at thinking in types, you can think of `map()` like this:
/// If you have an iterator that gives you elements of some type `A`, and
/// you want an iterator of some other type `B`, you can use `map()`,
/// passing a closure that takes an `A` and returns a `B`.
///
/// `map()` is conceptually similar to a [`for`] loop. However, as `map()` is
/// lazy, it is best used when you're already working with other iterators.
/// If you're doing some sort of looping for a side effect, it's considered
/// more idiomatic to use [`for`] than `map()`.
///
/// [`for`]: ../../book/first-edition/loops.html#for
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let a = [1, 2, 3];
///
/// let mut iter = a.into_iter().map(|x| 2 * x);
///
/// assert_eq!(iter.next(), Some(2));
/// assert_eq!(iter.next(), Some(4));
/// assert_eq!(iter.next(), Some(6));
/// assert_eq!(iter.next(), None);
/// ```
///
/// If you're doing some sort of side effect, prefer [`for`] to `map()`:
///
/// ```
/// # #![allow(unused_must_use)]
/// // don't do this:
/// (0..5).map(|x| println!("{}", x));
///
/// // it won't even execute, as it is lazy. Rust will warn you about this.
///
/// // Instead, use for:
/// for x in 0..5 {
/// println!("{}", x);
/// }
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn map<B, F>(self, f: F) -> Map<Self, F> where
Self: Sized, F: FnMut(Self::Item) -> B,
{
Map{iter: self, f: f}
}
/// Calls a closure on each element of an iterator.
///
/// This is equivalent to using a [`for`] loop on the iterator, although
/// `break` and `continue` are not possible from a closure. It's generally
/// more idiomatic to use a `for` loop, but `for_each` may be more legible
/// when processing items at the end of longer iterator chains. In some
/// cases `for_each` may also be faster than a loop, because it will use
/// internal iteration on adaptors like `Chain`.
///
/// [`for`]: ../../book/first-edition/loops.html#for
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// use std::sync::mpsc::channel;
///
/// let (tx, rx) = channel();
/// (0..5).map(|x| x * 2 + 1)
/// .for_each(move |x| tx.send(x).unwrap());
///
/// let v: Vec<_> = rx.iter().collect();
/// assert_eq!(v, vec![1, 3, 5, 7, 9]);
/// ```
///
/// For such a small example, a `for` loop may be cleaner, but `for_each`
/// might be preferable to keep a functional style with longer iterators:
///
/// ```
/// (0..5).flat_map(|x| x * 100 .. x * 110)
/// .enumerate()
/// .filter(|&(i, x)| (i + x) % 3 == 0)
/// .for_each(|(i, x)| println!("{}:{}", i, x));
/// ```
#[inline]
#[stable(feature = "iterator_for_each", since = "1.21.0")]
fn for_each<F>(self, mut f: F) where
Self: Sized, F: FnMut(Self::Item),
{
self.fold((), move |(), item| f(item));
}
/// Creates an iterator which uses a closure to determine if an element
/// should be yielded.
///
/// The closure must return `true` or `false`. `filter()` creates an
/// iterator which calls this closure on each element. If the closure
/// returns `true`, then the element is returned. If the closure returns
/// `false`, it will try again, and call the closure on the next element,
/// seeing if it passes the test.
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let a = [0i32, 1, 2];
///
/// let mut iter = a.into_iter().filter(|x| x.is_positive());
///
/// assert_eq!(iter.next(), Some(&1));
/// assert_eq!(iter.next(), Some(&2));
/// assert_eq!(iter.next(), None);
/// ```
///
/// Because the closure passed to `filter()` takes a reference, and many
/// iterators iterate over references, this leads to a possibly confusing
/// situation, where the type of the closure is a double reference:
///
/// ```
/// let a = [0, 1, 2];
///
/// let mut iter = a.into_iter().filter(|x| **x > 1); // need two *s!
///
/// assert_eq!(iter.next(), Some(&2));
/// assert_eq!(iter.next(), None);
/// ```
///
/// It's common to instead use destructuring on the argument to strip away
/// one:
///
/// ```
/// let a = [0, 1, 2];
///
/// let mut iter = a.into_iter().filter(|&x| *x > 1); // both & and *
///
/// assert_eq!(iter.next(), Some(&2));
/// assert_eq!(iter.next(), None);
/// ```
///
/// or both:
///
/// ```
/// let a = [0, 1, 2];
///
/// let mut iter = a.into_iter().filter(|&&x| x > 1); // two &s
///
/// assert_eq!(iter.next(), Some(&2));
/// assert_eq!(iter.next(), None);
/// ```
///
/// of these layers.
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn filter<P>(self, predicate: P) -> Filter<Self, P> where
Self: Sized, P: FnMut(&Self::Item) -> bool,
{
Filter{iter: self, predicate: predicate}
}
/// Creates an iterator that both filters and maps.
///
/// The closure must return an [`Option<T>`]. `filter_map` creates an
/// iterator which calls this closure on each element. If the closure
/// returns [`Some(element)`][`Some`], then that element is returned. If the
/// closure returns [`None`], it will try again, and call the closure on the
/// next element, seeing if it will return [`Some`].
///
/// Why `filter_map` and not just [`filter`] and [`map`]? The key is in this
/// part:
///
/// [`filter`]: #method.filter
/// [`map`]: #method.map
///
/// > If the closure returns [`Some(element)`][`Some`], then that element is returned.
///
/// In other words, it removes the [`Option<T>`] layer automatically. If your
/// mapping is already returning an [`Option<T>`] and you want to skip over
/// [`None`]s, then `filter_map` is much, much nicer to use.
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let a = ["1", "2", "lol"];
///
/// let mut iter = a.iter().filter_map(|s| s.parse().ok());
///
/// assert_eq!(iter.next(), Some(1));
/// assert_eq!(iter.next(), Some(2));
/// assert_eq!(iter.next(), None);
/// ```
///
/// Here's the same example, but with [`filter`] and [`map`]:
///
/// ```
/// let a = ["1", "2", "lol"];
///
/// let mut iter = a.iter()
/// .map(|s| s.parse())
/// .filter(|s| s.is_ok())
/// .map(|s| s.unwrap());
///
/// assert_eq!(iter.next(), Some(1));
/// assert_eq!(iter.next(), Some(2));
/// assert_eq!(iter.next(), None);
/// ```
///
/// [`Option<T>`]: ../../std/option/enum.Option.html
/// [`Some`]: ../../std/option/enum.Option.html#variant.Some
/// [`None`]: ../../std/option/enum.Option.html#variant.None
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where
Self: Sized, F: FnMut(Self::Item) -> Option<B>,
{
FilterMap { iter: self, f: f }
}
/// Creates an iterator which gives the current iteration count as well as
/// the next value.
///
/// The iterator returned yields pairs `(i, val)`, where `i` is the
/// current index of iteration and `val` is the value returned by the
/// iterator.
///
/// `enumerate()` keeps its count as a [`usize`]. If you want to count by a
/// different sized integer, the [`zip`] function provides similar
/// functionality.
///
/// # Overflow Behavior
///
/// The method does no guarding against overflows, so enumerating more than
/// [`usize::MAX`] elements either produces the wrong result or panics. If
/// debug assertions are enabled, a panic is guaranteed.
///
/// # Panics
///
/// The returned iterator might panic if the to-be-returned index would
/// overflow a [`usize`].
///
/// [`usize::MAX`]: ../../std/usize/constant.MAX.html
/// [`usize`]: ../../std/primitive.usize.html
/// [`zip`]: #method.zip
///
/// # Examples
///
/// ```
/// let a = ['a', 'b', 'c'];
///
/// let mut iter = a.iter().enumerate();
///
/// assert_eq!(iter.next(), Some((0, &'a')));
/// assert_eq!(iter.next(), Some((1, &'b')));
/// assert_eq!(iter.next(), Some((2, &'c')));
/// assert_eq!(iter.next(), None);
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn enumerate(self) -> Enumerate<Self> where Self: Sized {
Enumerate { iter: self, count: 0 }
}
/// Creates an iterator which can use `peek` to look at the next element of
/// the iterator without consuming it.
///
/// Adds a [`peek`] method to an iterator. See its documentation for
/// more information.
///
/// Note that the underlying iterator is still advanced when [`peek`] is
/// called for the first time: In order to retrieve the next element,
/// [`next`] is called on the underlying iterator, hence any side effects (i.e.
/// anything other than fetching the next value) of the [`next`] method
/// will occur.
///
/// [`peek`]: struct.Peekable.html#method.peek
/// [`next`]: ../../std/iter/trait.Iterator.html#tymethod.next
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let xs = [1, 2, 3];
///
/// let mut iter = xs.iter().peekable();
///
/// // peek() lets us see into the future
/// assert_eq!(iter.peek(), Some(&&1));
/// assert_eq!(iter.next(), Some(&1));
///
/// assert_eq!(iter.next(), Some(&2));
///
/// // we can peek() multiple times, the iterator won't advance
/// assert_eq!(iter.peek(), Some(&&3));
/// assert_eq!(iter.peek(), Some(&&3));
///
/// assert_eq!(iter.next(), Some(&3));
///
/// // after the iterator is finished, so is peek()
/// assert_eq!(iter.peek(), None);
/// assert_eq!(iter.next(), None);
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn peekable(self) -> Peekable<Self> where Self: Sized {
Peekable{iter: self, peeked: None}
}
/// Creates an iterator that [`skip`]s elements based on a predicate.
///
/// [`skip`]: #method.skip
///
/// `skip_while()` takes a closure as an argument. It will call this
/// closure on each element of the iterator, and ignore elements
/// until it returns `false`.
///
/// After `false` is returned, `skip_while()`'s job is over, and the
/// rest of the elements are yielded.
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let a = [-1i32, 0, 1];
///
/// let mut iter = a.into_iter().skip_while(|x| x.is_negative());
///
/// assert_eq!(iter.next(), Some(&0));
/// assert_eq!(iter.next(), Some(&1));
/// assert_eq!(iter.next(), None);
/// ```
///
/// Because the closure passed to `skip_while()` takes a reference, and many
/// iterators iterate over references, this leads to a possibly confusing
/// situation, where the type of the closure is a double reference:
///
/// ```
/// let a = [-1, 0, 1];
///
/// let mut iter = a.into_iter().skip_while(|x| **x < 0); // need two *s!
///
/// assert_eq!(iter.next(), Some(&0));
/// assert_eq!(iter.next(), Some(&1));
/// assert_eq!(iter.next(), None);
/// ```
///
/// Stopping after an initial `false`:
///
/// ```
/// let a = [-1, 0, 1, -2];
///
/// let mut iter = a.into_iter().skip_while(|x| **x < 0);
///
/// assert_eq!(iter.next(), Some(&0));
/// assert_eq!(iter.next(), Some(&1));
///
/// // while this would have been false, since we already got a false,
/// // skip_while() isn't used any more
/// assert_eq!(iter.next(), Some(&-2));
///
/// assert_eq!(iter.next(), None);
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where
Self: Sized, P: FnMut(&Self::Item) -> bool,
{
SkipWhile{iter: self, flag: false, predicate: predicate}
}
/// Creates an iterator that yields elements based on a predicate.
///
/// `take_while()` takes a closure as an argument. It will call this
/// closure on each element of the iterator, and yield elements
/// while it returns `true`.
///
/// After `false` is returned, `take_while()`'s job is over, and the
/// rest of the elements are ignored.
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let a = [-1i32, 0, 1];
///
/// let mut iter = a.into_iter().take_while(|x| x.is_negative());
///
/// assert_eq!(iter.next(), Some(&-1));
/// assert_eq!(iter.next(), None);
/// ```
///
/// Because the closure passed to `take_while()` takes a reference, and many
/// iterators iterate over references, this leads to a possibly confusing
/// situation, where the type of the closure is a double reference:
///
/// ```
/// let a = [-1, 0, 1];
///
/// let mut iter = a.into_iter().take_while(|x| **x < 0); // need two *s!
///
/// assert_eq!(iter.next(), Some(&-1));
/// assert_eq!(iter.next(), None);
/// ```
///
/// Stopping after an initial `false`:
///
/// ```
/// let a = [-1, 0, 1, -2];
///
/// let mut iter = a.into_iter().take_while(|x| **x < 0);
///
/// assert_eq!(iter.next(), Some(&-1));
///
/// // We have more elements that are less than zero, but since we already
/// // got a false, take_while() isn't used any more
/// assert_eq!(iter.next(), None);
/// ```
///
/// Because `take_while()` needs to look at the value in order to see if it
/// should be included or not, consuming iterators will see that it is
/// removed:
///
/// ```
/// let a = [1, 2, 3, 4];
/// let mut iter = a.into_iter();
///
/// let result: Vec<i32> = iter.by_ref()
/// .take_while(|n| **n != 3)
/// .cloned()
/// .collect();
///
/// assert_eq!(result, &[1, 2]);
///
/// let result: Vec<i32> = iter.cloned().collect();
///
/// assert_eq!(result, &[4]);
/// ```
///
/// The `3` is no longer there, because it was consumed in order to see if
/// the iteration should stop, but wasn't placed back into the iterator or
/// some similar thing.
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where
Self: Sized, P: FnMut(&Self::Item) -> bool,
{
TakeWhile{iter: self, flag: false, predicate: predicate}
}
/// Creates an iterator that skips the first `n` elements.
///
/// After they have been consumed, the rest of the elements are yielded.
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let a = [1, 2, 3];
///
/// let mut iter = a.iter().skip(2);
///
/// assert_eq!(iter.next(), Some(&3));
/// assert_eq!(iter.next(), None);
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn skip(self, n: usize) -> Skip<Self> where Self: Sized {
Skip{iter: self, n: n}
}
/// Creates an iterator that yields its first `n` elements.
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let a = [1, 2, 3];
///
/// let mut iter = a.iter().take(2);
///
/// assert_eq!(iter.next(), Some(&1));
/// assert_eq!(iter.next(), Some(&2));
/// assert_eq!(iter.next(), None);
/// ```
///
/// `take()` is often used with an infinite iterator, to make it finite:
///
/// ```
/// let mut iter = (0..).take(3);
///
/// assert_eq!(iter.next(), Some(0));
/// assert_eq!(iter.next(), Some(1));
/// assert_eq!(iter.next(), Some(2));
/// assert_eq!(iter.next(), None);
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn take(self, n: usize) -> Take<Self> where Self: Sized, {
Take{iter: self, n: n}
}
/// An iterator adaptor similar to [`fold`] that holds internal state and
/// produces a new iterator.
///
/// [`fold`]: #method.fold
///
/// `scan()` takes two arguments: an initial value which seeds the internal
/// state, and a closure with two arguments, the first being a mutable
/// reference to the internal state and the second an iterator element.
/// The closure can assign to the internal state to share state between
/// iterations.
///
/// On iteration, the closure will be applied to each element of the
/// iterator and the return value from the closure, an [`Option`], is
/// yielded by the iterator.
///
/// [`Option`]: ../../std/option/enum.Option.html
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let a = [1, 2, 3];
///
/// let mut iter = a.iter().scan(1, |state, &x| {
/// // each iteration, we'll multiply the state by the element
/// *state = *state * x;
///
/// // the value passed on to the next iteration
/// Some(*state)
/// });
///
/// assert_eq!(iter.next(), Some(1));
/// assert_eq!(iter.next(), Some(2));
/// assert_eq!(iter.next(), Some(6));
/// assert_eq!(iter.next(), None);
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
where Self: Sized, F: FnMut(&mut St, Self::Item) -> Option<B>,
{
Scan{iter: self, f: f, state: initial_state}
}
/// Creates an iterator that works like map, but flattens nested structure.
///
/// The [`map`] adapter is very useful, but only when the closure
/// argument produces values. If it produces an iterator instead, there's
/// an extra layer of indirection. `flat_map()` will remove this extra layer
/// on its own.
///
/// Another way of thinking about `flat_map()`: [`map`]'s closure returns
/// one item for each element, and `flat_map()`'s closure returns an
/// iterator for each element.
///
/// [`map`]: #method.map
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let words = ["alpha", "beta", "gamma"];
///
/// // chars() returns an iterator
/// let merged: String = words.iter()
/// .flat_map(|s| s.chars())
/// .collect();
/// assert_eq!(merged, "alphabetagamma");
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
where Self: Sized, U: IntoIterator, F: FnMut(Self::Item) -> U,
{
FlatMap{iter: self, f: f, frontiter: None, backiter: None }
}
/// Creates an iterator which ends after the first [`None`].
///
/// After an iterator returns [`None`], future calls may or may not yield
/// [`Some(T)`] again. `fuse()` adapts an iterator, ensuring that after a
/// [`None`] is given, it will always return [`None`] forever.
///
/// [`None`]: ../../std/option/enum.Option.html#variant.None
/// [`Some(T)`]: ../../std/option/enum.Option.html#variant.Some
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// // an iterator which alternates between Some and None
/// struct Alternate {
/// state: i32,
/// }
///
/// impl Iterator for Alternate {
/// type Item = i32;
///
/// fn next(&mut self) -> Option<i32> {
/// let val = self.state;
/// self.state = self.state + 1;
///
/// // if it's even, Some(i32), else None
/// if val % 2 == 0 {
/// Some(val)
/// } else {
/// None
/// }
/// }
/// }
///
/// let mut iter = Alternate { state: 0 };
///
/// // we can see our iterator going back and forth
/// assert_eq!(iter.next(), Some(0));
/// assert_eq!(iter.next(), None);
/// assert_eq!(iter.next(), Some(2));
/// assert_eq!(iter.next(), None);
///
/// // however, once we fuse it...
/// let mut iter = iter.fuse();
///
/// assert_eq!(iter.next(), Some(4));
/// assert_eq!(iter.next(), None);
///
/// // it will always return None after the first time.
/// assert_eq!(iter.next(), None);
/// assert_eq!(iter.next(), None);
/// assert_eq!(iter.next(), None);
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn fuse(self) -> Fuse<Self> where Self: Sized {
Fuse{iter: self, done: false}
}
/// Do something with each element of an iterator, passing the value on.
///
/// When using iterators, you'll often chain several of them together.
/// While working on such code, you might want to check out what's
/// happening at various parts in the pipeline. To do that, insert
/// a call to `inspect()`.
///
/// It's much more common for `inspect()` to be used as a debugging tool
/// than to exist in your final code, but never say never.
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let a = [1, 4, 2, 3];
///
/// // this iterator sequence is complex.
/// let sum = a.iter()
/// .cloned()
/// .filter(|&x| x % 2 == 0)
/// .fold(0, |sum, i| sum + i);
///
/// println!("{}", sum);
///
/// // let's add some inspect() calls to investigate what's happening
/// let sum = a.iter()
/// .cloned()
/// .inspect(|x| println!("about to filter: {}", x))
/// .filter(|&x| x % 2 == 0)
/// .inspect(|x| println!("made it through filter: {}", x))
/// .fold(0, |sum, i| sum + i);
///
/// println!("{}", sum);
/// ```
///
/// This will print:
///
/// ```text
/// about to filter: 1
/// about to filter: 4
/// made it through filter: 4
/// about to filter: 2
/// made it through filter: 2
/// about to filter: 3
/// 6
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn inspect<F>(self, f: F) -> Inspect<Self, F> where
Self: Sized, F: FnMut(&Self::Item),
{
Inspect{iter: self, f: f}
}
/// Borrows an iterator, rather than consuming it.
///
/// This is useful to allow applying iterator adaptors while still
/// retaining ownership of the original iterator.
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let a = [1, 2, 3];
///
/// let iter = a.into_iter();
///
/// let sum: i32 = iter.take(5)
/// .fold(0, |acc, &i| acc + i );
///
/// assert_eq!(sum, 6);
///
/// // if we try to use iter again, it won't work. The following line
/// // gives "error: use of moved value: `iter`
/// // assert_eq!(iter.next(), None);
///
/// // let's try that again
/// let a = [1, 2, 3];
///
/// let mut iter = a.into_iter();
///
/// // instead, we add in a .by_ref()
/// let sum: i32 = iter.by_ref()
/// .take(2)
/// .fold(0, |acc, &i| acc + i );
///
/// assert_eq!(sum, 3);
///
/// // now this is just fine:
/// assert_eq!(iter.next(), Some(&3));
/// assert_eq!(iter.next(), None);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
fn by_ref(&mut self) -> &mut Self where Self: Sized { self }
/// Transforms an iterator into a collection.
///
/// `collect()` can take anything iterable, and turn it into a relevant
/// collection. This is one of the more powerful methods in the standard
/// library, used in a variety of contexts.
///
/// The most basic pattern in which `collect()` is used is to turn one
/// collection into another. You take a collection, call [`iter`] on it,
/// do a bunch of transformations, and then `collect()` at the end.
///
/// One of the keys to `collect()`'s power is that many things you might
/// not think of as 'collections' actually are. For example, a [`String`]
/// is a collection of [`char`]s. And a collection of
/// [`Result<T, E>`][`Result`] can be thought of as single
/// [`Result`]`<Collection<T>, E>`. See the examples below for more.
///
/// Because `collect()` is so general, it can cause problems with type
/// inference. As such, `collect()` is one of the few times you'll see
/// the syntax affectionately known as the 'turbofish': `::<>`. This
/// helps the inference algorithm understand specifically which collection
/// you're trying to collect into.
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let a = [1, 2, 3];
///
/// let doubled: Vec<i32> = a.iter()
/// .map(|&x| x * 2)
/// .collect();
///
/// assert_eq!(vec![2, 4, 6], doubled);
/// ```
///
/// Note that we needed the `: Vec<i32>` on the left-hand side. This is because
/// we could collect into, for example, a [`VecDeque<T>`] instead:
///
/// [`VecDeque<T>`]: ../../std/collections/struct.VecDeque.html
///
/// ```
/// use std::collections::VecDeque;
///
/// let a = [1, 2, 3];
///
/// let doubled: VecDeque<i32> = a.iter()
/// .map(|&x| x * 2)
/// .collect();
///
/// assert_eq!(2, doubled[0]);
/// assert_eq!(4, doubled[1]);
/// assert_eq!(6, doubled[2]);
/// ```
///
/// Using the 'turbofish' instead of annotating `doubled`:
///
/// ```
/// let a = [1, 2, 3];
///
/// let doubled = a.iter()
/// .map(|&x| x * 2)
/// .collect::<Vec<i32>>();
///
/// assert_eq!(vec![2, 4, 6], doubled);
/// ```
///
/// Because `collect()` only cares about what you're collecting into, you can
/// still use a partial type hint, `_`, with the turbofish:
///
/// ```
/// let a = [1, 2, 3];
///
/// let doubled = a.iter()
/// .map(|&x| x * 2)
/// .collect::<Vec<_>>();
///
/// assert_eq!(vec![2, 4, 6], doubled);
/// ```
///
/// Using `collect()` to make a [`String`]:
///
/// ```
/// let chars = ['g', 'd', 'k', 'k', 'n'];
///
/// let hello: String = chars.iter()
/// .map(|&x| x as u8)
/// .map(|x| (x + 1) as char)
/// .collect();
///
/// assert_eq!("hello", hello);
/// ```
///
/// If you have a list of [`Result<T, E>`][`Result`]s, you can use `collect()` to
/// see if any of them failed:
///
/// ```
/// let results = [Ok(1), Err("nope"), Ok(3), Err("bad")];
///
/// let result: Result<Vec<_>, &str> = results.iter().cloned().collect();
///
/// // gives us the first error
/// assert_eq!(Err("nope"), result);
///
/// let results = [Ok(1), Ok(3)];
///
/// let result: Result<Vec<_>, &str> = results.iter().cloned().collect();
///
/// // gives us the list of answers
/// assert_eq!(Ok(vec![1, 3]), result);
/// ```
///
/// [`iter`]: ../../std/iter/trait.Iterator.html#tymethod.next
/// [`String`]: ../../std/string/struct.String.html
/// [`char`]: ../../std/primitive.char.html
/// [`Result`]: ../../std/result/enum.Result.html
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn collect<B: FromIterator<Self::Item>>(self) -> B where Self: Sized {
FromIterator::from_iter(self)
}
/// Consumes an iterator, creating two collections from it.
///
/// The predicate passed to `partition()` can return `true`, or `false`.
/// `partition()` returns a pair, all of the elements for which it returned
/// `true`, and all of the elements for which it returned `false`.
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let a = [1, 2, 3];
///
/// let (even, odd): (Vec<i32>, Vec<i32>) = a.into_iter()
/// .partition(|&n| n % 2 == 0);
///
/// assert_eq!(even, vec![2]);
/// assert_eq!(odd, vec![1, 3]);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
fn partition<B, F>(self, mut f: F) -> (B, B) where
Self: Sized,
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool
{
let mut left: B = Default::default();
let mut right: B = Default::default();
for x in self {
if f(&x) {
left.extend(Some(x))
} else {
right.extend(Some(x))
}
}
(left, right)
}
/// An iterator method that applies a function, producing a single, final value.
///
/// `fold()` takes two arguments: an initial value, and a closure with two
/// arguments: an 'accumulator', and an element. The closure returns the value that
/// the accumulator should have for the next iteration.
///
/// The initial value is the value the accumulator will have on the first
/// call.
///
/// After applying this closure to every element of the iterator, `fold()`
/// returns the accumulator.
///
/// This operation is sometimes called 'reduce' or 'inject'.
///
/// Folding is useful whenever you have a collection of something, and want
/// to produce a single value from it.
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let a = [1, 2, 3];
///
/// // the sum of all of the elements of a
/// let sum = a.iter()
/// .fold(0, |acc, &x| acc + x);
///
/// assert_eq!(sum, 6);
/// ```
///
/// Let's walk through each step of the iteration here:
///
/// | element | acc | x | result |
/// |---------|-----|---|--------|
/// | | 0 | | |
/// | 1 | 0 | 1 | 1 |
/// | 2 | 1 | 2 | 3 |
/// | 3 | 3 | 3 | 6 |
///
/// And so, our final result, `6`.
///
/// It's common for people who haven't used iterators a lot to
/// use a `for` loop with a list of things to build up a result. Those
/// can be turned into `fold()`s:
///
/// [`for`]: ../../book/first-edition/loops.html#for
///
/// ```
/// let numbers = [1, 2, 3, 4, 5];
///
/// let mut result = 0;
///
/// // for loop:
/// for i in &numbers {
/// result = result + i;
/// }
///
/// // fold:
/// let result2 = numbers.iter().fold(0, |acc, &x| acc + x);
///
/// // they're the same
/// assert_eq!(result, result2);
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn fold<B, F>(self, init: B, mut f: F) -> B where
Self: Sized, F: FnMut(B, Self::Item) -> B,
{
let mut accum = init;
for x in self {
accum = f(accum, x);
}
accum
}
/// Tests if every element of the iterator matches a predicate.
///
/// `all()` takes a closure that returns `true` or `false`. It applies
/// this closure to each element of the iterator, and if they all return
/// `true`, then so does `all()`. If any of them return `false`, it
/// returns `false`.
///
/// `all()` is short-circuiting; in other words, it will stop processing
/// as soon as it finds a `false`, given that no matter what else happens,
/// the result will also be `false`.
///
/// An empty iterator returns `true`.
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let a = [1, 2, 3];
///
/// assert!(a.iter().all(|&x| x > 0));
///
/// assert!(!a.iter().all(|&x| x > 2));
/// ```
///
/// Stopping at the first `false`:
///
/// ```
/// let a = [1, 2, 3];
///
/// let mut iter = a.iter();
///
/// assert!(!iter.all(|&x| x != 2));
///
/// // we can still use `iter`, as there are more elements.
/// assert_eq!(iter.next(), Some(&3));
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn all<F>(&mut self, mut f: F) -> bool where
Self: Sized, F: FnMut(Self::Item) -> bool
{
for x in self {
if !f(x) {
return false;
}
}
true
}
/// Tests if any element of the iterator matches a predicate.
///
/// `any()` takes a closure that returns `true` or `false`. It applies
/// this closure to each element of the iterator, and if any of them return
/// `true`, then so does `any()`. If they all return `false`, it
/// returns `false`.
///
/// `any()` is short-circuiting; in other words, it will stop processing
/// as soon as it finds a `true`, given that no matter what else happens,
/// the result will also be `true`.
///
/// An empty iterator returns `false`.
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let a = [1, 2, 3];
///
/// assert!(a.iter().any(|&x| x > 0));
///
/// assert!(!a.iter().any(|&x| x > 5));
/// ```
///
/// Stopping at the first `true`:
///
/// ```
/// let a = [1, 2, 3];
///
/// let mut iter = a.iter();
///
/// assert!(iter.any(|&x| x != 2));
///
/// // we can still use `iter`, as there are more elements.
/// assert_eq!(iter.next(), Some(&2));
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn any<F>(&mut self, mut f: F) -> bool where
Self: Sized,
F: FnMut(Self::Item) -> bool
{
for x in self {
if f(x) {
return true;
}
}
false
}
/// Searches for an element of an iterator that satisfies a predicate.
///
/// `find()` takes a closure that returns `true` or `false`. It applies
/// this closure to each element of the iterator, and if any of them return
/// `true`, then `find()` returns [`Some(element)`]. If they all return
/// `false`, it returns [`None`].
///
/// `find()` is short-circuiting; in other words, it will stop processing
/// as soon as the closure returns `true`.
///
/// Because `find()` takes a reference, and many iterators iterate over
/// references, this leads to a possibly confusing situation where the
/// argument is a double reference. You can see this effect in the
/// examples below, with `&&x`.
///
/// [`Some(element)`]: ../../std/option/enum.Option.html#variant.Some
/// [`None`]: ../../std/option/enum.Option.html#variant.None
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let a = [1, 2, 3];
///
/// assert_eq!(a.iter().find(|&&x| x == 2), Some(&2));
///
/// assert_eq!(a.iter().find(|&&x| x == 5), None);
/// ```
///
/// Stopping at the first `true`:
///
/// ```
/// let a = [1, 2, 3];
///
/// let mut iter = a.iter();
///
/// assert_eq!(iter.find(|&&x| x == 2), Some(&2));
///
/// // we can still use `iter`, as there are more elements.
/// assert_eq!(iter.next(), Some(&3));
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn find<P>(&mut self, mut predicate: P) -> Option<Self::Item> where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
{
for x in self {
if predicate(&x) { return Some(x) }
}
None
}
/// Searches for an element in an iterator, returning its index.
///
/// `position()` takes a closure that returns `true` or `false`. It applies
/// this closure to each element of the iterator, and if one of them
/// returns `true`, then `position()` returns [`Some(index)`]. If all of
/// them return `false`, it returns [`None`].
///
/// `position()` is short-circuiting; in other words, it will stop
/// processing as soon as it finds a `true`.
///
/// # Overflow Behavior
///
/// The method does no guarding against overflows, so if there are more
/// than [`usize::MAX`] non-matching elements, it either produces the wrong
/// result or panics. If debug assertions are enabled, a panic is
/// guaranteed.
///
/// # Panics
///
/// This function might panic if the iterator has more than `usize::MAX`
/// non-matching elements.
///
/// [`Some(index)`]: ../../std/option/enum.Option.html#variant.Some
/// [`None`]: ../../std/option/enum.Option.html#variant.None
/// [`usize::MAX`]: ../../std/usize/constant.MAX.html
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let a = [1, 2, 3];
///
/// assert_eq!(a.iter().position(|&x| x == 2), Some(1));
///
/// assert_eq!(a.iter().position(|&x| x == 5), None);
/// ```
///
/// Stopping at the first `true`:
///
/// ```
/// let a = [1, 2, 3, 4];
///
/// let mut iter = a.iter();
///
/// assert_eq!(iter.position(|&x| x >= 2), Some(1));
///
/// // we can still use `iter`, as there are more elements.
/// assert_eq!(iter.next(), Some(&3));
///
/// // The returned index depends on iterator state
/// assert_eq!(iter.position(|&x| x == 4), Some(0));
///
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn position<P>(&mut self, mut predicate: P) -> Option<usize> where
Self: Sized,
P: FnMut(Self::Item) -> bool,
{
// `enumerate` might overflow.
for (i, x) in self.enumerate() {
if predicate(x) {
return Some(i);
}
}
None
}
/// Searches for an element in an iterator from the right, returning its
/// index.
///
/// `rposition()` takes a closure that returns `true` or `false`. It applies
/// this closure to each element of the iterator, starting from the end,
/// and if one of them returns `true`, then `rposition()` returns
/// [`Some(index)`]. If all of them return `false`, it returns [`None`].
///
/// `rposition()` is short-circuiting; in other words, it will stop
/// processing as soon as it finds a `true`.
///
/// [`Some(index)`]: ../../std/option/enum.Option.html#variant.Some
/// [`None`]: ../../std/option/enum.Option.html#variant.None
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let a = [1, 2, 3];
///
/// assert_eq!(a.iter().rposition(|&x| x == 3), Some(2));
///
/// assert_eq!(a.iter().rposition(|&x| x == 5), None);
/// ```
///
/// Stopping at the first `true`:
///
/// ```
/// let a = [1, 2, 3];
///
/// let mut iter = a.iter();
///
/// assert_eq!(iter.rposition(|&x| x == 2), Some(1));
///
/// // we can still use `iter`, as there are more elements.
/// assert_eq!(iter.next(), Some(&1));
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn rposition<P>(&mut self, mut predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool,
Self: Sized + ExactSizeIterator + DoubleEndedIterator
{
let mut i = self.len();
while let Some(v) = self.next_back() {
// No need for an overflow check here, because `ExactSizeIterator`
// implies that the number of elements fits into a `usize`.
i -= 1;
if predicate(v) {
return Some(i);
}
}
None
}
/// Returns the maximum element of an iterator.
///
/// If several elements are equally maximum, the last element is
/// returned. If the iterator is empty, [`None`] is returned.
///
/// [`None`]: ../../std/option/enum.Option.html#variant.None
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let a = [1, 2, 3];
/// let b: Vec<u32> = Vec::new();
///
/// assert_eq!(a.iter().max(), Some(&3));
/// assert_eq!(b.iter().max(), None);
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn max(self) -> Option<Self::Item> where Self: Sized, Self::Item: Ord
{
select_fold1(self,
|_| (),
// switch to y even if it is only equal, to preserve
// stability.
|_, x, _, y| *x <= *y)
.map(|(_, x)| x)
}
/// Returns the minimum element of an iterator.
///
/// If several elements are equally minimum, the first element is
/// returned. If the iterator is empty, [`None`] is returned.
///
/// [`None`]: ../../std/option/enum.Option.html#variant.None
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let a = [1, 2, 3];
/// let b: Vec<u32> = Vec::new();
///
/// assert_eq!(a.iter().min(), Some(&1));
/// assert_eq!(b.iter().min(), None);
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn min(self) -> Option<Self::Item> where Self: Sized, Self::Item: Ord
{
select_fold1(self,
|_| (),
// only switch to y if it is strictly smaller, to
// preserve stability.
|_, x, _, y| *x > *y)
.map(|(_, x)| x)
}
/// Returns the element that gives the maximum value from the
/// specified function.
///
/// If several elements are equally maximum, the last element is
/// returned. If the iterator is empty, [`None`] is returned.
///
/// [`None`]: ../../std/option/enum.Option.html#variant.None
///
/// # Examples
///
/// ```
/// let a = [-3_i32, 0, 1, 5, -10];
/// assert_eq!(*a.iter().max_by_key(|x| x.abs()).unwrap(), -10);
/// ```
#[inline]
#[stable(feature = "iter_cmp_by_key", since = "1.6.0")]
fn max_by_key<B: Ord, F>(self, f: F) -> Option<Self::Item>
where Self: Sized, F: FnMut(&Self::Item) -> B,
{
select_fold1(self,
f,
// switch to y even if it is only equal, to preserve
// stability.
|x_p, _, y_p, _| x_p <= y_p)
.map(|(_, x)| x)
}
/// Returns the element that gives the maximum value with respect to the
/// specified comparison function.
///
/// If several elements are equally maximum, the last element is
/// returned. If the iterator is empty, [`None`] is returned.
///
/// [`None`]: ../../std/option/enum.Option.html#variant.None
///
/// # Examples
///
/// ```
/// let a = [-3_i32, 0, 1, 5, -10];
/// assert_eq!(*a.iter().max_by(|x, y| x.cmp(y)).unwrap(), 5);
/// ```
#[inline]
#[stable(feature = "iter_max_by", since = "1.15.0")]
fn max_by<F>(self, mut compare: F) -> Option<Self::Item>
where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,
{
select_fold1(self,
|_| (),
// switch to y even if it is only equal, to preserve
// stability.
|_, x, _, y| Ordering::Greater != compare(x, y))
.map(|(_, x)| x)
}
/// Returns the element that gives the minimum value from the
/// specified function.
///
/// If several elements are equally minimum, the first element is
/// returned. If the iterator is empty, [`None`] is returned.
///
/// [`None`]: ../../std/option/enum.Option.html#variant.None
///
/// # Examples
///
/// ```
/// let a = [-3_i32, 0, 1, 5, -10];
/// assert_eq!(*a.iter().min_by_key(|x| x.abs()).unwrap(), 0);
/// ```
#[stable(feature = "iter_cmp_by_key", since = "1.6.0")]
fn min_by_key<B: Ord, F>(self, f: F) -> Option<Self::Item>
where Self: Sized, F: FnMut(&Self::Item) -> B,
{
select_fold1(self,
f,
// only switch to y if it is strictly smaller, to
// preserve stability.
|x_p, _, y_p, _| x_p > y_p)
.map(|(_, x)| x)
}
/// Returns the element that gives the minimum value with respect to the
/// specified comparison function.
///
/// If several elements are equally minimum, the first element is
/// returned. If the iterator is empty, [`None`] is returned.
///
/// [`None`]: ../../std/option/enum.Option.html#variant.None
///
/// # Examples
///
/// ```
/// let a = [-3_i32, 0, 1, 5, -10];
/// assert_eq!(*a.iter().min_by(|x, y| x.cmp(y)).unwrap(), -10);
/// ```
#[inline]
#[stable(feature = "iter_min_by", since = "1.15.0")]
fn min_by<F>(self, mut compare: F) -> Option<Self::Item>
where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,
{
select_fold1(self,
|_| (),
// switch to y even if it is strictly smaller, to
// preserve stability.
|_, x, _, y| Ordering::Greater == compare(x, y))
.map(|(_, x)| x)
}
/// Reverses an iterator's direction.
///
/// Usually, iterators iterate from left to right. After using `rev()`,
/// an iterator will instead iterate from right to left.
///
/// This is only possible if the iterator has an end, so `rev()` only
/// works on [`DoubleEndedIterator`]s.
///
/// [`DoubleEndedIterator`]: trait.DoubleEndedIterator.html
///
/// # Examples
///
/// ```
/// let a = [1, 2, 3];
///
/// let mut iter = a.iter().rev();
///
/// assert_eq!(iter.next(), Some(&3));
/// assert_eq!(iter.next(), Some(&2));
/// assert_eq!(iter.next(), Some(&1));
///
/// assert_eq!(iter.next(), None);
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn rev(self) -> Rev<Self> where Self: Sized + DoubleEndedIterator {
Rev{iter: self}
}
/// Converts an iterator of pairs into a pair of containers.
///
/// `unzip()` consumes an entire iterator of pairs, producing two
/// collections: one from the left elements of the pairs, and one
/// from the right elements.
///
/// This function is, in some sense, the opposite of [`zip`].
///
/// [`zip`]: #method.zip
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let a = [(1, 2), (3, 4)];
///
/// let (left, right): (Vec<_>, Vec<_>) = a.iter().cloned().unzip();
///
/// assert_eq!(left, [1, 3]);
/// assert_eq!(right, [2, 4]);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Sized + Iterator<Item=(A, B)>,
{
let mut ts: FromA = Default::default();
let mut us: FromB = Default::default();
for (t, u) in self {
ts.extend(Some(t));
us.extend(Some(u));
}
(ts, us)
}
/// Creates an iterator which [`clone`]s all of its elements.
///
/// This is useful when you have an iterator over `&T`, but you need an
/// iterator over `T`.
///
/// [`clone`]: ../../std/clone/trait.Clone.html#tymethod.clone
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let a = [1, 2, 3];
///
/// let v_cloned: Vec<_> = a.iter().cloned().collect();
///
/// // cloned is the same as .map(|&x| x), for integers
/// let v_map: Vec<_> = a.iter().map(|&x| x).collect();
///
/// assert_eq!(v_cloned, vec![1, 2, 3]);
/// assert_eq!(v_map, vec![1, 2, 3]);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
fn cloned<'a, T: 'a>(self) -> Cloned<Self>
where Self: Sized + Iterator<Item=&'a T>, T: Clone
{
Cloned { it: self }
}
/// Repeats an iterator endlessly.
///
/// Instead of stopping at [`None`], the iterator will instead start again,
/// from the beginning. After iterating again, it will start at the
/// beginning again. And again. And again. Forever.
///
/// [`None`]: ../../std/option/enum.Option.html#variant.None
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let a = [1, 2, 3];
///
/// let mut it = a.iter().cycle();
///
/// assert_eq!(it.next(), Some(&1));
/// assert_eq!(it.next(), Some(&2));
/// assert_eq!(it.next(), Some(&3));
/// assert_eq!(it.next(), Some(&1));
/// assert_eq!(it.next(), Some(&2));
/// assert_eq!(it.next(), Some(&3));
/// assert_eq!(it.next(), Some(&1));
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
fn cycle(self) -> Cycle<Self> where Self: Sized + Clone {
Cycle{orig: self.clone(), iter: self}
}
/// Sums the elements of an iterator.
///
/// Takes each element, adds them together, and returns the result.
///
/// An empty iterator returns the zero value of the type.
///
/// # Panics
///
/// When calling `sum()` and a primitive integer type is being returned, this
/// method will panic if the computation overflows and debug assertions are
/// enabled.
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let a = [1, 2, 3];
/// let sum: i32 = a.iter().sum();
///
/// assert_eq!(sum, 6);
/// ```
#[stable(feature = "iter_arith", since = "1.11.0")]
fn sum<S>(self) -> S
where Self: Sized,
S: Sum<Self::Item>,
{
Sum::sum(self)
}
/// Iterates over the entire iterator, multiplying all the elements
///
/// An empty iterator returns the one value of the type.
///
/// # Panics
///
/// When calling `product()` and a primitive integer type is being returned,
/// method will panic if the computation overflows and debug assertions are
/// enabled.
///
/// # Examples
///
/// ```
/// fn factorial(n: u32) -> u32 {
/// (1..).take_while(|&i| i <= n).product()
/// }
/// assert_eq!(factorial(0), 1);
/// assert_eq!(factorial(1), 1);
/// assert_eq!(factorial(5), 120);
/// ```
#[stable(feature = "iter_arith", since = "1.11.0")]
fn product<P>(self) -> P
where Self: Sized,
P: Product<Self::Item>,
{
Product::product(self)
}
/// Lexicographically compares the elements of this `Iterator` with those
/// of another.
#[stable(feature = "iter_order", since = "1.5.0")]
fn cmp<I>(mut self, other: I) -> Ordering where
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord,
Self: Sized,
{
let mut other = other.into_iter();
loop {
let x = match self.next() {
None => if other.next().is_none() {
return Ordering::Equal
} else {
return Ordering::Less
},
Some(val) => val,
};
let y = match other.next() {
None => return Ordering::Greater,
Some(val) => val,
};
match x.cmp(&y) {
Ordering::Equal => (),
non_eq => return non_eq,
}
}
}
/// Lexicographically compares the elements of this `Iterator` with those
/// of another.
#[stable(feature = "iter_order", since = "1.5.0")]
fn partial_cmp<I>(mut self, other: I) -> Option<Ordering> where
I: IntoIterator,
Self::Item: PartialOrd<I::Item>,
Self: Sized,
{
let mut other = other.into_iter();
loop {
let x = match self.next() {
None => if other.next().is_none() {
return Some(Ordering::Equal)
} else {
return Some(Ordering::Less)
},
Some(val) => val,
};
let y = match other.next() {
None => return Some(Ordering::Greater),
Some(val) => val,
};
match x.partial_cmp(&y) {
Some(Ordering::Equal) => (),
non_eq => return non_eq,
}
}
}
/// Determines if the elements of this `Iterator` are equal to those of
/// another.
#[stable(feature = "iter_order", since = "1.5.0")]
fn eq<I>(mut self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<I::Item>,
Self: Sized,
{
let mut other = other.into_iter();
loop {
let x = match self.next() {
None => return other.next().is_none(),
Some(val) => val,
};
let y = match other.next() {
None => return false,
Some(val) => val,
};
if x != y { return false }
}
}
/// Determines if the elements of this `Iterator` are unequal to those of
/// another.
#[stable(feature = "iter_order", since = "1.5.0")]
fn ne<I>(mut self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<I::Item>,
Self: Sized,
{
let mut other = other.into_iter();
loop {
let x = match self.next() {
None => return other.next().is_some(),
Some(val) => val,
};
let y = match other.next() {
None => return true,
Some(val) => val,
};
if x != y { return true }
}
}
/// Determines if the elements of this `Iterator` are lexicographically
/// less than those of another.
#[stable(feature = "iter_order", since = "1.5.0")]
fn lt<I>(mut self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<I::Item>,
Self: Sized,
{
let mut other = other.into_iter();
loop {
let x = match self.next() {
None => return other.next().is_some(),
Some(val) => val,
};
let y = match other.next() {
None => return false,
Some(val) => val,
};
match x.partial_cmp(&y) {
Some(Ordering::Less) => return true,
Some(Ordering::Equal) => (),
Some(Ordering::Greater) => return false,
None => return false,
}
}
}
/// Determines if the elements of this `Iterator` are lexicographically
/// less or equal to those of another.
#[stable(feature = "iter_order", since = "1.5.0")]
fn le<I>(mut self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<I::Item>,
Self: Sized,
{
let mut other = other.into_iter();
loop {
let x = match self.next() {
None => { other.next(); return true; },
Some(val) => val,
};
let y = match other.next() {
None => return false,
Some(val) => val,
};
match x.partial_cmp(&y) {
Some(Ordering::Less) => return true,
Some(Ordering::Equal) => (),
Some(Ordering::Greater) => return false,
None => return false,
}
}
}
/// Determines if the elements of this `Iterator` are lexicographically
/// greater than those of another.
#[stable(feature = "iter_order", since = "1.5.0")]
fn gt<I>(mut self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<I::Item>,
Self: Sized,
{
let mut other = other.into_iter();
loop {
let x = match self.next() {
None => { other.next(); return false; },
Some(val) => val,
};
let y = match other.next() {
None => return true,
Some(val) => val,
};
match x.partial_cmp(&y) {
Some(Ordering::Less) => return false,
Some(Ordering::Equal) => (),
Some(Ordering::Greater) => return true,
None => return false,
}
}
}
/// Determines if the elements of this `Iterator` are lexicographically
/// greater than or equal to those of another.
#[stable(feature = "iter_order", since = "1.5.0")]
fn ge<I>(mut self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<I::Item>,
Self: Sized,
{
let mut other = other.into_iter();
loop {
let x = match self.next() {
None => return other.next().is_none(),
Some(val) => val,
};
let y = match other.next() {
None => return true,
Some(val) => val,
};
match x.partial_cmp(&y) {
Some(Ordering::Less) => return false,
Some(Ordering::Equal) => (),
Some(Ordering::Greater) => return true,
None => return false,
}
}
}
}
/// Select an element from an iterator based on the given "projection"
/// and "comparison" function.
///
/// This is an idiosyncratic helper to try to factor out the
/// commonalities of {max,min}{,_by}. In particular, this avoids
/// having to implement optimizations several times.
#[inline]
fn select_fold1<I, B, FProj, FCmp>(mut it: I,
mut f_proj: FProj,
mut f_cmp: FCmp) -> Option<(B, I::Item)>
where I: Iterator,
FProj: FnMut(&I::Item) -> B,
FCmp: FnMut(&B, &I::Item, &B, &I::Item) -> bool
{
|
[stable(feature = "rust1", since = "1.0.0")]
impl<'a, I: Iterator + ?Sized> Iterator for &'a mut I {
type Item = I::Item;
fn next(&mut self) -> Option<I::Item> { (**self).next() }
fn size_hint(&self) -> (usize, Option<usize>) { (**self).size_hint() }
fn nth(&mut self, n: usize) -> Option<Self::Item> {
(**self).nth(n)
}
}
|
// start with the first element as our selection. This avoids
// having to use `Option`s inside the loop, translating to a
// sizeable performance gain (6x in one case).
it.next().map(|mut sel| {
let mut sel_p = f_proj(&sel);
for x in it {
let x_p = f_proj(&x);
if f_cmp(&sel_p, &sel, &x_p, &x) {
sel = x;
sel_p = x_p;
}
}
(sel_p, sel)
})
}
#
|
roleList.ts
|
import Vue from 'vue';
import { Component } from "vue-property-decorator";
/// @ts-ignore
import template = require("text!./roleList.html");
|
@Component({
name: 'RoleList',
template: template
})
export default class RoleList extends Vue {
}
|
/* import "css!./roleList.css"; */
|
setup.py
|
#!/usr/bin/env python
import os
from setuptools import setup, find_packages
def
|
(fname):
return open(os.path.join(os.path.dirname(__file__), fname)).read()
setup(
name='netinfo',
version='0.0.2',
description='Client to interact with Netinfo services.',
author="Brandon Dixon",
author_email="[email protected]",
license="MIT",
packages=find_packages(),
install_requires=['requests'],
long_description=read('README.rst'),
classifiers=[
'Development Status :: 4 - Beta',
'Intended Audience :: Developers',
'License :: OSI Approved :: MIT License',
'Natural Language :: English',
'Programming Language :: Python',
'Topic :: Software Development :: Libraries',
'Topic :: Security'
],
entry_points={
'console_scripts': [
'netinfo = netinfo.cli.client:main'
]
},
zip_safe=False,
keywords=['internet scanning', 'cybersecurity', 'defense', 'intelligence']
)
|
read
|
test_servers_negative.py
|
# Copyright 2013 Huawei Technologies Co.,LTD.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import testtools
from tempest.api.compute import base
from tempest.common import tempest_fixtures as fixtures
from tempest.common import waiters
from tempest import config
from tempest.lib.common.utils import data_utils
from tempest.lib import decorators
from tempest.lib import exceptions as lib_exc
CONF = config.CONF
class ServersAdminNegativeTestJSON(base.BaseV2ComputeAdminTest):
"""Tests Servers API using admin privileges"""
@classmethod
def setup_clients(cls):
super(ServersAdminNegativeTestJSON, cls).setup_clients()
cls.client = cls.os_admin.servers_client
cls.quotas_client = cls.os_admin.quotas_client
@classmethod
def resource_setup(cls):
super(ServersAdminNegativeTestJSON, cls).resource_setup()
cls.tenant_id = cls.client.tenant_id
server = cls.create_test_server(wait_until='ACTIVE')
cls.s1_id = server['id']
@decorators.idempotent_id('28dcec23-f807-49da-822c-56a92ea3c687')
@testtools.skipUnless(CONF.compute_feature_enabled.resize,
'Resize not available.')
@decorators.attr(type=['negative'])
def test_resize_server_using_overlimit_ram(self):
# NOTE(mriedem): Avoid conflicts with os-quota-class-sets tests.
self.useFixture(fixtures.LockFixture('compute_quotas'))
quota_set = self.quotas_client.show_quota_set(
self.tenant_id)['quota_set']
ram = quota_set['ram']
if ram == -1:
raise self.skipException("ram quota set is -1,"
" cannot test overlimit")
ram += 1
vcpus = 1
disk = 5
flavor_ref = self.create_flavor(ram=ram, vcpus=vcpus, disk=disk)
self.assertRaises((lib_exc.Forbidden, lib_exc.OverLimit),
self.client.resize_server,
self.s1_id,
flavor_ref['id'])
@decorators.idempotent_id('7368a427-2f26-4ad9-9ba9-911a0ec2b0db')
@testtools.skipUnless(CONF.compute_feature_enabled.resize,
'Resize not available.')
@decorators.attr(type=['negative'])
def test_resize_server_using_overlimit_vcpus(self):
# NOTE(mriedem): Avoid conflicts with os-quota-class-sets tests.
self.useFixture(fixtures.LockFixture('compute_quotas'))
quota_set = self.quotas_client.show_quota_set(
self.tenant_id)['quota_set']
vcpus = quota_set['cores']
if vcpus == -1:
raise self.skipException("cores quota set is -1,"
" cannot test overlimit")
vcpus += 1
ram = 512
disk = 5
flavor_ref = self.create_flavor(ram=ram, vcpus=vcpus, disk=disk)
self.assertRaises((lib_exc.Forbidden, lib_exc.OverLimit),
self.client.resize_server,
self.s1_id,
flavor_ref['id'])
@decorators.attr(type=['negative'])
@decorators.idempotent_id('b0b4d8af-1256-41ef-9ee7-25f1c19dde80')
def test_reset_state_server_invalid_state(self):
self.assertRaises(lib_exc.BadRequest,
self.client.reset_state, self.s1_id,
state='invalid')
@decorators.attr(type=['negative'])
@decorators.idempotent_id('4cdcc984-fab0-4577-9a9d-6d558527ee9d')
def test_reset_state_server_invalid_type(self):
self.assertRaises(lib_exc.BadRequest,
self.client.reset_state, self.s1_id,
state=1)
@decorators.attr(type=['negative'])
@decorators.idempotent_id('e741298b-8df2-46f0-81cb-8f814ff2504c')
def test_reset_state_server_nonexistent_server(self):
self.assertRaises(lib_exc.NotFound,
self.client.reset_state, '999', state='error')
@decorators.attr(type=['negative'])
@decorators.idempotent_id('46a4e1ca-87ae-4d28-987a-1b6b136a0221')
def test_migrate_non_existent_server(self):
# migrate a non existent server
self.assertRaises(lib_exc.NotFound,
self.client.migrate_server,
data_utils.rand_uuid())
@decorators.idempotent_id('b0b17f83-d14e-4fc4-8f31-bcc9f3cfa629')
@testtools.skipUnless(CONF.compute_feature_enabled.cold_migration,
'Cold migration not available.')
@testtools.skipUnless(CONF.compute_feature_enabled.suspend,
'Suspend is not available.')
@decorators.attr(type=['negative'])
def test_migrate_server_invalid_state(self):
# create server.
server = self.create_test_server(wait_until='ACTIVE')
server_id = server['id']
# suspend the server.
self.client.suspend_server(server_id)
waiters.wait_for_server_status(self.client,
server_id, 'SUSPENDED')
# migrate a suspended server should fail
self.assertRaises(lib_exc.Conflict,
self.client.migrate_server,
|
server_id)
|
|
address.rs
|
use crypto::digest::Digest;
use crypto::sha1::Sha1;
use num;
use std::fmt;
use rustc_serialize::hex;
pub const LENGTH: usize = 160;
fn compact_bytes(data: &[u8]) -> [u32; 5] {
let mut compacted = [0; 5];
for (compact, bytes) in compacted.iter_mut().zip(data.chunks(4).rev()) {
*compact = bytes.iter()
.rev()
.enumerate()
.fold(0u32, |sum, (i, &b)| sum + ((b as u32) << (8 * i)));
}
compacted
}
/// An `Address` can be used to address anything that is `Addressable`. `Node`s, for example, have
/// an `Address`. Every `client::messages::TextMessage` has an `Address` as well.
#[derive(Clone,Copy,Eq,Hash,PartialEq)]
pub struct Address {
data: [u32; 5]
}
impl Address {
/// Hashes `content` into an `Address`. Current implementation is to take the SHA1 digest of
/// `content`, but this is subject to change and should not be depended on.
///
/// # Example
///
/// ```
/// use comm::address;
///
/// let addr = address::Address::for_content("alep");
/// let addr_from_str = address::Address::from_str("44751799925b964a00bae3863cc4236f9bb8d519").unwrap();
/// assert_eq!(addr, addr_from_str);
/// ```
pub fn for_content(content: &str) -> Address {
let mut hasher = Sha1::new();
hasher.input_str(content);
let mut data = [0; 20];
hasher.result(&mut data);
Address {
data: compact_bytes(&data)
}
}
/// Creates an `Address` from its numeric representation. Useful for randomly generating
/// `Address`es within a range.
pub fn from_numeric(numeric: num::BigUint) -> Address {
let data = numeric.to_bytes_be();
Address {
data: compact_bytes(data.as_slice())
}
}
/// Creates a `Address` from its hexidecimal string representation. `string` must be
/// hexidecimal or an `Err` will be returned.
pub fn from_str(string: &str) -> Result<Address, hex::FromHexError> {
use rustc_serialize::hex::FromHex;
string.from_hex().map(|bytes| {
let mut data = [0u8; 20];
for (place, byte) in data.iter_mut().zip(bytes.iter()) {
*place = *byte;
}
Address {
data: compact_bytes(&data)
}
})
}
/// The null `Address`. Use to address "nothing." No `Node`, message, or any `Addressable`
/// thing should ever reside at the null address. It's useful for bootstrapping a
/// `network::Network` when one does not know the address of any peers, but has connection
/// details to them such as an IP address and port.
pub fn null() -> Address {
Address {
data: [0; 5]
}
}
/// Randomly generates an `Address` within the address space between `min` and `max`. Useful
/// for refreshing a `NodeBucket` by performing a find node operation on a random address
/// within its range.
pub fn random(min: &num::BigUint, max: &num::BigUint) -> Address {
use rand;
use num::bigint::RandBigInt;
let mut rng = rand::StdRng::new().unwrap();
let numeric = rng.gen_biguint_range(min, max);
Self::from_numeric(numeric)
}
/// The numeric representation of an `Address`. Useful for partitioning the `Node`s in a
/// `NodeBucket` into two new buckets.
pub fn as_numeric(&self) -> num::BigUint {
num::BigUint::new(self.data.to_vec())
}
/// The address space distance of `self` from `other`. Computed as the XOR of their numeric
/// representations.
pub fn distance_from(&self, other: &Self) -> num::BigUint {
use std::ops::BitXor;
self.as_numeric().bitxor(other.as_numeric())
}
/// The string representation of an `Address`. Useful for displaying, exporting outside of
/// Rust, serializing into a protobuf, etc.
///
/// TODO: this may be poorly named, breaking the `to_string` convention set by
/// `&str::to_string`. It's probably wiser to `impl ToString`.
pub fn to_str(&self) -> String {
format!("{:040x}", self.as_numeric())
}
}
/// Anything that needs to be uniquely addressed can implement `Addressable`.
pub trait Addressable {
/// The `Address` where `self` resides.
fn address(&self) -> Address;
}
impl fmt::Debug for Address {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "Address {{ {} }}", self.to_str())
}
}
impl fmt::Display for Address {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "[{}]", self.to_str())
}
}
#[cfg(test)]
mod tests {
use num;
use super::{Address, LENGTH};
#[test]
fn test_for_content() {
let address = Address::for_content("some string");
assert_eq!(address.to_str(), "8b45e4bd1c6acb88bebf6407d16205f567e62a3e");
}
#[test]
fn test_from_numeric()
|
#[test]
fn test_from_str() {
let address = Address::from_str("8b45e4bd1c6acb88bebf6407d16205f567e62a3e").unwrap();
assert_eq!(address.to_str(), "8b45e4bd1c6acb88bebf6407d16205f567e62a3e");
}
#[test]
fn test_as_numeric() {
use num::bigint::ToBigUint;
let address = Address::from_str("000000000000000000000000000000000000000f").unwrap();
assert_eq!(address.as_numeric(), 15u8.to_biguint().unwrap());
let address = Address::from_str("00000000000000000000000000000000000000f0").unwrap();
assert_eq!(address.as_numeric(), 240u8.to_biguint().unwrap());
}
#[test]
fn test_equal() {
let a = Address::from_str("8b45e4bd1c6acb88bebf6407d16205f567e62a3e").unwrap();
let b = Address::from_str("8b45e4bd1c6acb88bebf6407d16205f567e62a3e").unwrap();
assert_eq!(a, b);
}
#[test]
fn test_not_equal() {
let a = Address::from_str("8b45e4bd1c6acb88bebf6407d16205f567e62a3e").unwrap();
let b = Address::from_str("8b45e4bd1c6acb88bebf6407d16205f567e62a3f").unwrap();
assert!(a != b);
}
}
|
{
use num::bigint::ToBigUint;
let numeric = 0x0000000000000000000000000000000000000001.to_biguint().unwrap();
let address = Address::from_numeric(numeric);
assert_eq!(address.as_numeric(), 0x0000000000000000000000000000000000000001.to_biguint().unwrap());
assert_eq!(address.to_str(), "0000000000000000000000000000000000000001");
let numeric = num::pow(2.to_biguint().unwrap(), 158) -
num::pow(2.to_biguint().unwrap(), 157) -
num::pow(2.to_biguint().unwrap(), 156);
let address = Address::from_numeric(numeric.clone());
assert_eq!(address.as_numeric(), numeric);
assert_eq!(address.to_str(), "1000000000000000000000000000000000000000");
let numeric = num::pow(2.to_biguint().unwrap(), LENGTH) - 1.to_biguint().unwrap();
let address = Address::from_numeric(numeric);
assert_eq!(address.as_numeric(), num::pow(2.to_biguint().unwrap(), LENGTH) - 1.to_biguint().unwrap());
assert_eq!(address.to_str(), "ffffffffffffffffffffffffffffffffffffffff");
}
|
main.js
|
/*global $, alert*/
(function () {
'use strict';
// instantiate to create empty tree
$('#root').jqtree();
$('#btns')
.on('click', 'button', function (e) {
if (!e.target || !e.target.id) { return; }
var jqtree = $('#root').jqtree();
|
switch (e.target.id) {
case 'btn-add':
// addNode creates folder by default
o.addNode(selected, {'type': 'folder'}, function () {
alert('Operation is not permitted. You cannot nest a file.');
});
break;
case 'btn-remove':
o.deleteNode(selected);
break;
case 'btn-rename':
o.renameNode(selected);
break;
case 'btn-export':
var json = o.exportJSON();
json = JSON.stringify(json, null, 4);
$('#output').val(json);
break;
default:
break;
}
});
// instantiate to create tree from the given data
$('#demo-root').jqtree({
data: [{
id: '1',
name: 'My Folder',
type: 'folder',
contents: [{
id: '11',
name: 'Folder 1',
type: 'folder',
contents: [{
id: '111',
name: 'File',
type: 'file',
contents: null
}]
}, {
id: '12',
name: 'Folder 2',
type: 'folder',
contents: []
}]
}, {
id: '2',
name: 'Folder 3',
type: 'folder',
contents: []
}, {
id: '3',
name: 'File 2',
type: 'file',
contents: null
}, {
id: '4',
name: 'File 3',
type: 'file',
contents: null
}]
});
$('#demo-btns')
.on('click', 'button', function (e) {
if (!e.target || !e.target.id) { return; }
var jqtree = $('#demo-root').jqtree();
var o = jqtree.data();
var selected = o.getSelection();
switch (e.target.id) {
case 'demo-btn-add':
// addNode creates folder by default
o.addNode(selected, {}, function () {
alert('Operation is not permitted. You cannot nest a file.');
});
break;
case 'demo-btn-remove':
o.deleteNode(selected);
break;
case 'demo-btn-rename':
o.renameNode(selected);
break;
case 'demo-btn-export':
var json = o.exportJSON();
json = JSON.stringify(json, null, 4);
$('#demo-output').val(json);
break;
default:
break;
}
});
})();
|
var o = jqtree.data();
var selected = o.getSelection();
|
cloud_test_base.py
|
"""
Tests for the Openstack Cloud Provider
"""
import logging
import os
import shutil
from time import sleep
import salt.utils.verify
from salt.config import cloud_config, cloud_providers_config
from salt.ext.six.moves import range
from salt.utils.yaml import safe_load
from tests.support.case import ShellCase
from tests.support.helpers import expensiveTest, random_string
from tests.support.paths import FILES
from tests.support.runtests import RUNTIME_VARS
TIMEOUT = 500
log = logging.getLogger(__name__)
@expensiveTest
class CloudTest(ShellCase):
PROVIDER = ""
REQUIRED_PROVIDER_CONFIG_ITEMS = tuple()
__RE_RUN_DELAY = 30
__RE_TRIES = 12
@staticmethod
def clean_cloud_dir(tmp_dir):
"""
Clean the cloud.providers.d tmp directory
"""
# make sure old provider configs are deleted
if not os.path.isdir(tmp_dir):
return
for fname in os.listdir(tmp_dir):
os.remove(os.path.join(tmp_dir, fname))
def query_instances(self):
"""
Standardize the data returned from a salt-cloud --query
"""
return {
x.strip(": ")
for x in self.run_cloud("--query")
if x.lstrip().lower().startswith("cloud-test-")
}
def _instance_exists(self, instance_name=None, query=None):
"""
:param instance_name: The name of the instance to check for in salt-cloud.
For example this is may used when a test temporarily renames an instance
:param query: The result of a salt-cloud --query run outside of this function
"""
if not instance_name:
instance_name = self.instance_name
if not query:
query = self.query_instances()
log.debug('Checking for "{}" in {}'.format(instance_name, query))
if isinstance(query, set):
return instance_name in query
return any(instance_name == q.strip(": ") for q in query)
def assertInstanceExists(self, creation_ret=None, instance_name=None):
"""
:param instance_name: Override the checked instance name, otherwise the class default will be used.
:param creation_ret: The return value from the run_cloud() function that created the instance
"""
if not instance_name:
instance_name = self.instance_name
# If it exists but doesn't show up in the creation_ret, there was probably an error during creation
if creation_ret:
self.assertIn(
instance_name,
[i.strip(": ") for i in creation_ret],
"An error occured during instance creation: |\n\t{}\n\t|".format(
"\n\t".join(creation_ret)
),
)
else:
# Verify that the instance exists via query
query = self.query_instances()
for tries in range(self.__RE_TRIES):
if self._instance_exists(instance_name, query):
log.debug(
'Instance "{}" reported after {} seconds'.format(
instance_name, tries * self.__RE_RUN_DELAY
)
)
break
else:
sleep(self.__RE_RUN_DELAY)
query = self.query_instances()
# Assert that the last query was successful
self.assertTrue(
self._instance_exists(instance_name, query),
'Instance "{}" was not created successfully: {}'.format(
self.instance_name, ", ".join(query)
),
)
log.debug('Instance exists and was created: "{}"'.format(instance_name))
def assertDestroyInstance(self, instance_name=None, timeout=None):
if timeout is None:
timeout = TIMEOUT
if not instance_name:
instance_name = self.instance_name
log.debug('Deleting instance "{}"'.format(instance_name))
delete_str = self.run_cloud(
"-d {} --assume-yes --out=yaml".format(instance_name), timeout=timeout
)
if delete_str:
delete = safe_load("\n".join(delete_str))
self.assertIn(self.profile_str, delete)
self.assertIn(self.PROVIDER, delete[self.profile_str])
self.assertIn(instance_name, delete[self.profile_str][self.PROVIDER])
delete_status = delete[self.profile_str][self.PROVIDER][instance_name]
if isinstance(delete_status, str):
self.assertEqual(delete_status, "True")
return
elif isinstance(delete_status, dict):
current_state = delete_status.get("currentState")
if current_state:
if current_state.get("ACTION"):
self.assertIn(".delete", current_state.get("ACTION"))
return
else:
self.assertEqual(current_state.get("name"), "shutting-down")
return
# It's not clear from the delete string that deletion was successful, ask salt-cloud after a delay
query = self.query_instances()
# some instances take a while to report their destruction
for tries in range(6):
if self._instance_exists(query=query):
sleep(30)
log.debug(
'Instance "{}" still found in query after {} tries: {}'.format(
instance_name, tries, query
)
)
query = self.query_instances()
# The last query should have been successful
self.assertNotIn(instance_name, self.query_instances())
@property
def instance_name(self):
if not hasattr(self, "_instance_name"):
# Create the cloud instance name to be used throughout the tests
subclass = self.__class__.__name__.strip("Test")
# Use the first three letters of the subclass, fill with '-' if too short
self._instance_name = random_string(
"cloud-test-{:-<3}-".format(subclass[:3]), uppercase=False
).lower()
return self._instance_name
@property
def providers(self):
if not hasattr(self, "_providers"):
self._providers = self.run_cloud("--list-providers")
return self._providers
@property
def provider_config(self):
if not hasattr(self, "_provider_config"):
self._provider_config = cloud_providers_config(
os.path.join(
RUNTIME_VARS.TMP_CONF_DIR,
"cloud.providers.d",
self.PROVIDER + ".conf",
)
)
return self._provider_config[self.profile_str][self.PROVIDER]
@property
def config(self):
if not hasattr(self, "_config"):
self._config = cloud_config(
os.path.join(
RUNTIME_VARS.TMP_CONF_DIR,
"cloud.profiles.d",
self.PROVIDER + ".conf",
)
)
return self._config
@property
def profile_str(self):
return self.PROVIDER + "-config"
def add_profile_config(self, name, data, conf, new_profile):
"""
copy the current profile and add a new profile in the same file
"""
conf_path = os.path.join(RUNTIME_VARS.TMP_CONF_DIR, "cloud.profiles.d", conf)
with salt.utils.files.fopen(conf_path, "r") as fp:
conf = safe_load(fp)
conf[new_profile] = conf[name].copy()
conf[new_profile].update(data)
with salt.utils.files.fopen(conf_path, "w") as fp:
salt.utils.yaml.safe_dump(conf, fp)
def setUp(self):
"""
Sets up the test requirements. In child classes, define PROVIDER and REQUIRED_PROVIDER_CONFIG_ITEMS or this will fail
"""
super().setUp()
if not self.PROVIDER:
self.fail("A PROVIDER must be defined for this test")
# check if appropriate cloud provider and profile files are present
if self.profile_str + ":" not in self.providers:
self.skipTest(
"Configuration file for {0} was not found. Check {0}.conf files "
"in tests/integration/files/conf/cloud.*.d/ to run these tests.".format(
self.PROVIDER
)
)
missing_conf_item = []
for att in self.REQUIRED_PROVIDER_CONFIG_ITEMS:
if not self.provider_config.get(att):
missing_conf_item.append(att)
if missing_conf_item:
self.skipTest(
"Conf items are missing that must be provided to run these tests: {}".format(
", ".join(missing_conf_item)
)
+ "\nCheck tests/integration/files/conf/cloud.providers.d/{}.conf".format(
self.PROVIDER
)
)
def _alt_names(self):
"""
Check for an instances created alongside this test's instance that weren't cleaned up
"""
query = self.query_instances()
instances = set()
for q in query:
# Verify but this is a new name and not a shutting down ec2 instance
if q.startswith(self.instance_name) and not q.split("-")[-1].startswith(
"DEL"
):
instances.add(q)
log.debug(
'Adding "{}" to the set of instances that needs to be deleted'.format(
q
)
)
return instances
def _ensure_deletion(self, instance_name=None):
"""
Make sure that the instance absolutely gets deleted, but fail the test if it happens in the tearDown
:return True if an instance was deleted, False if no instance was deleted; and a message
"""
destroyed = False
if not instance_name:
instance_name = self.instance_name
if self._instance_exists(instance_name):
for tries in range(3):
try:
self.assertDestroyInstance(instance_name)
return (
False,
'The instance "{}" was deleted during the tearDown, not the test.'.format(
instance_name
),
)
except AssertionError as e:
log.error(
'Failed to delete instance "{}". Tries: {}\n{}'.format(
instance_name, tries, str(e)
)
)
if not self._instance_exists():
destroyed = True
break
else:
sleep(30)
if not destroyed:
# Destroying instances in the tearDown is a contingency, not the way things should work by default.
return (
False,
'The Instance "{}" was not deleted after multiple attempts'.format(
instance_name
),
)
return (
True,
'The instance "{}" cleaned up properly after the test'.format(
instance_name
),
)
def tearDown(self):
"""
Clean up after tests, If the instance still exists for any reason, delete it.
Instances should be destroyed before the tearDown, assertDestroyInstance() should be called exactly
one time in a test for each instance created. This is a failSafe and something went wrong
if the tearDown is where an instance is destroyed.
"""
success = True
fail_messages = []
alt_names = self._alt_names()
for instance in alt_names:
alt_destroyed, alt_destroy_message = self._ensure_deletion(instance)
if not alt_destroyed:
|
self.assertTrue(success, "\n".join(fail_messages))
self.assertFalse(
alt_names, "Cleanup should happen in the test, not the TearDown"
)
@classmethod
def tearDownClass(cls):
cls.clean_cloud_dir(cls.tmp_provider_dir)
@classmethod
def setUpClass(cls):
# clean up before setup
cls.tmp_provider_dir = os.path.join(
RUNTIME_VARS.TMP_CONF_DIR, "cloud.providers.d"
)
cls.clean_cloud_dir(cls.tmp_provider_dir)
# add the provider config for only the cloud we are testing
provider_file = cls.PROVIDER + ".conf"
shutil.copyfile(
os.path.join(
os.path.join(FILES, "conf", "cloud.providers.d"), provider_file
),
os.path.join(os.path.join(cls.tmp_provider_dir, provider_file)),
)
|
success = False
fail_messages.append(alt_destroy_message)
log.error(
'Failed to destroy instance "{}": {}'.format(
instance, alt_destroy_message
)
)
|
main.rs
|
/// see src/link_list
fn
|
() {
use algs_stanford::link_list::LinkedList;
let mut list = LinkedList::new();
// insert from head
list.push("a".to_string())
.push("b".to_string())
.push("c".to_string());
for s in list.iter() {
print!("{},", s)
}
println!();
println!("size: {}", list.size());
println!("pop: {}", list.pop().unwrap_or("?".to_string()));
println!("pop: {}", list.pop().unwrap_or("?".to_string()));
println!("pop: {}", list.pop().unwrap_or("?".to_string()));
println!("pop: {}", list.pop().unwrap_or("?".to_string()));
println!("size: {}", list.size());
// insert from tail
list.enqueue("1".to_string())
.enqueue("2".to_string())
.enqueue("3".to_string());
for s in list.iter() {
print!("{},", s)
}
println!();
println!("size: {}", list.size());
println!("dequeue: {}", list.dequeue().unwrap_or("?".to_string()));
println!("dequeue: {}", list.dequeue().unwrap_or("?".to_string()));
println!("dequeue: {}", list.dequeue().unwrap_or("?".to_string()));
println!("dequeue: {}", list.dequeue().unwrap_or("?".to_string()));
println!("size: {}", list.size());
}
|
main
|
spectral_summarized.py
|
#!/usr/bin/env python
"""
Spectral features summarized over time using mean and variance. Returns a 22-dimension
feature vector for each audio sample.
Features:
- Spectral Centroid
- Spectral Bandwidth
- Spectral Contrast (7 frequency bands)
- Spectral Flatness
- Spectral Rolloff
"""
import numpy as np
import librosa
from spiegelib import AudioBuffer
from spiegelib.features.features_base import FeaturesBase
class SpectralSummarized(FeaturesBase):
|
"""
Args:
frame_size (int, optional): size of FFT, defaults to 2048
hop_size (int, optional): size of hop shift in samples, defuault to 512
scale_axis (int, tuple, None): When applying scaling, determines which dimensions
scaling be applied along. Defaults to 0, which scales each feature independently.
kwargs: Keyword arguments, see :class:`spiegelib.features.features_base.FeaturesBase`.
"""
def __init__(self, frame_size=2048, hop_size=512, scale_axis=0, **kwargs):
"""
Constructor
"""
self.frame_size = frame_size
self.hop_size = hop_size
super().__init__(scale_axis=scale_axis, **kwargs)
def get_features(self, audio):
"""
Extract spectral features and return results.
Args:
audio (:ref:`AudioBuffer <audio_buffer>`): input audio
Returns:
np.ndarray: Results of spectral features extraction. Format depends on\
output type set during construction.
"""
if not isinstance(audio, AudioBuffer):
raise TypeError('audio must be AudioBuffer, recieved %s' % type(audio))
if audio.get_sample_rate() != self.sample_rate:
raise ValueError(
'audio buffer samplerate does not equal feature '
'extraction rate, %s != %s' % (audio.get_sample_rate(), self.sample_rate)
)
spectral_centroid = librosa.feature.spectral_centroid(
y=audio.get_audio(),
sr=self.sample_rate,
n_fft=self.frame_size,
hop_length=self.hop_size,
)
spectral_bandwidth = librosa.feature.spectral_bandwidth(
y=audio.get_audio(),
sr=self.sample_rate,
n_fft=self.frame_size,
hop_length=self.hop_size,
)
spectral_contrast = librosa.feature.spectral_contrast(
y=audio.get_audio(),
sr=self.sample_rate,
n_fft=self.frame_size,
hop_length=self.hop_size,
)
spectral_flatness = librosa.feature.spectral_flatness(
y=audio.get_audio(),
n_fft=self.frame_size,
hop_length=self.hop_size,
)
spectral_rolloff = librosa.feature.spectral_rolloff(
y=audio.get_audio(),
sr=self.sample_rate,
n_fft=self.frame_size,
hop_length=self.hop_size,
)
features = np.array([
spectral_centroid.mean(),
spectral_centroid.var(),
spectral_bandwidth.mean(),
spectral_bandwidth.var(),
spectral_flatness.mean(),
spectral_flatness.var(),
spectral_rolloff.mean(),
spectral_rolloff.var(),
spectral_contrast[0].mean(),
spectral_contrast[0].var(),
spectral_contrast[1].mean(),
spectral_contrast[1].var(),
spectral_contrast[2].mean(),
spectral_contrast[2].var(),
spectral_contrast[3].mean(),
spectral_contrast[3].var(),
spectral_contrast[4].mean(),
spectral_contrast[4].var(),
spectral_contrast[5].mean(),
spectral_contrast[5].var(),
spectral_contrast[6].mean(),
spectral_contrast[6].var(),
])
return features
|
|
setup.py
|
#!/usr/bin/env python
"""
Setup script for citeproc-py
"""
import os
import re
import sys
from datetime import datetime
from subprocess import Popen, PIPE
from setuptools import setup, find_packages
from setuptools.command.build_py import build_py
from setuptools.command.develop import develop
PACKAGE = 'citeproc'
BASE_PATH = os.path.dirname(os.path.abspath(__file__))
PACKAGE_ABSPATH = os.path.join(BASE_PATH, PACKAGE)
# All external commands are relative to BASE_PATH
os.chdir(BASE_PATH)
def long_description():
with open(os.path.join(BASE_PATH, 'README.rst')) as readme:
result = readme.read()
result += '\n\n'
with open(os.path.join(BASE_PATH, 'CHANGES.rst')) as changes:
result += changes.read()
return result
CSL_SCHEMA_RNC = 'citeproc/data/schema/csl.rnc'
def convert_rnc():
import rnc2rng
filename_root, _ = os.path.splitext(CSL_SCHEMA_RNC)
with open(CSL_SCHEMA_RNC, 'r') as rnc:
root = rnc2rng.load(rnc)
with open(filename_root + '.rng', 'w') as rng:
rnc2rng.dump(root, rng)
class custom_build_py(build_py):
def run(self):
convert_rnc()
build_py.run(self)
class custom_develop(develop):
|
setup(
name='citeproc-py',
version='0.5.5',
cmdclass = dict(build_py=custom_build_py, develop=custom_develop),
packages=find_packages(),
package_data={PACKAGE: ['data/locales/*.xml',
'data/locales/locales.json',
'data/schema/*.rng',
'data/styles/*.csl',
'data/styles/dependent/*.csl']},
scripts=['bin/csl_unsorted'],
setup_requires=['rnc2rng==2.6'],
install_requires=['lxml'],
provides=[PACKAGE],
#test_suite='nose.collector',
author='Brecht Machiels',
author_email='[email protected]',
description='Citations and bibliography formatter',
long_description=long_description(),
url='https://github.com/brechtm/citeproc-py',
keywords='csl citation html rst bibtex xml',
license='2-clause BSD License',
classifiers = [
'Development Status :: 3 - Alpha',
'Environment :: Console',
'Environment :: Other Environment',
'Environment :: Web Environment',
'Intended Audience :: Developers',
'Intended Audience :: Education',
'Intended Audience :: End Users/Desktop',
'Intended Audience :: Legal Industry',
'Intended Audience :: Other Audience',
'Intended Audience :: Science/Research',
'License :: OSI Approved :: BSD License',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3.2',
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3.6',
'Topic :: Documentation',
'Topic :: Printing',
'Topic :: Software Development :: Documentation',
'Topic :: Software Development :: Libraries :: Python Modules',
]
)
|
def run(self):
convert_rnc()
develop.run(self)
|
size.rs
|
use std::{io, mem};
use super::cvt;
use nix::libc::{c_int, c_ushort, ioctl, TIOCGWINSZ};
#[repr(C)]
struct TermSize {
row: c_ushort,
col: c_ushort,
_x: c_ushort,
_y: c_ushort,
}
/// Get the size of the terminal.
|
unsafe {
let mut size: TermSize = mem::zeroed();
cvt(ioctl(fd, TIOCGWINSZ.into(), &mut size as *mut _))?;
Ok((size.col as usize, size.row as usize))
}
}
|
pub fn terminal_size(fd: c_int) -> io::Result<(usize, usize)> {
|
trainer_table_generator.py
|
#!/usr/bin/env python3
from pycparser import c_parser, c_ast, parse_file
from json import dump
from glob import glob
from re import sub
from string import digits
ast = parse_file("../pokeruby/src/data/trainer_parties.h")
#ast = parse_file("trainer_parties_trimmed.h")
#ast.show()
map_script_paths = glob('../pokeruby/data/maps/*/scripts.inc')
map_scripts = []
for path in map_script_paths:
with open(path) as f:
map_name = path.split("/")[-2] # Probably only works on Unix-likes
map_scripts.append(( map_name, f.read() ))
#print(map_scripts)
trainers = []
default_moves_mon_size = 8
custom_moves_mon_size = 16
offset = 0
for trainer_party in ast.children():
# A trainer_party is the abstract syntax tree of an array of structs,
# each struct representing a mon in the trainer's party.
trainer = []
trainer.append(offset)
type_declaration = trainer_party[1].children()[0][1].children()[0][1]
# type_declaration holds just the tree for the struct type and the name
# of the array.
party_member_count = len(trainer_party[1].children()[1][1].children())
trainer.append(party_member_count)
if("Custom" in type_declaration.children()[0][1].name):
offset += custom_moves_mon_size * party_member_count
trainer.append(True)
else:
|
if("MonItem" in type_declaration.children()[0][1].name):
# i.e. has held item
trainer.append(True)
else:
trainer.append(False)
# Automatically determine some of the trainer locations, better than nothing
declaration_name = type_declaration.declname[14:]
trainer.append(declaration_name.rstrip(digits))
trainer_ssc = sub(r'(?<!^)(?=[A-Z])', '_', trainer[-1]).upper()
# Arcane regex magic that turns CamelCase into SCREAMING_SNAKE_CASE
if trainer[-1] != declaration_name:
trainer_ssc += "_1"
#print(trainer_ssc)
for map_tuple in map_scripts:
map_name = map_tuple[0]
map_script = map_tuple[1]
if("TRAINER_{},".format(trainer_ssc) in map_script):
trainer.append(map_name)
if(len(trainer) < 6):
trainer.append("")
#print(trainer)
trainers.append(trainer)
trainer_table_file = open("trainer_table_generated.json", "wt")
dump(trainers, trainer_table_file, indent=" ")
|
offset += default_moves_mon_size * party_member_count
trainer.append(False)
|
repo_index.go
|
/*
Copyright The Helm Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package helm
import (
"fmt"
"io"
"os"
"path/filepath"
"github.com/spf13/cobra"
"k8s.io/helm/pkg/repo"
)
const repoIndexDesc = `
Read the current directory and generate an index file based on the charts found.
This tool is used for creating an 'index.yaml' file for a chart repository. To
set an absolute URL to the charts, use '--url' flag.
To merge the generated index with an existing index file, use the '--merge'
flag. In this case, the charts found in the current directory will be merged
into the existing index, with local charts taking priority over existing charts.
`
type repoIndexCmd struct {
dir string
url string
out io.Writer
merge string
}
func newRepoIndexCmd(out io.Writer) *cobra.Command {
index := &repoIndexCmd{out: out}
cmd := &cobra.Command{
Use: "index [flags] [DIR]",
Short: "Generate an index file given a directory containing packaged charts",
Long: repoIndexDesc,
RunE: func(cmd *cobra.Command, args []string) error {
if err := checkArgsLength(len(args), "path to a directory"); err != nil {
return err
}
|
return index.run()
},
}
f := cmd.Flags()
f.StringVar(&index.url, "url", "", "URL of the chart repository")
f.StringVar(&index.merge, "merge", "", "Merge the generated index into the given index")
return cmd
}
func (i *repoIndexCmd) run() error {
path, err := filepath.Abs(i.dir)
if err != nil {
return err
}
return index(path, i.url, i.merge)
}
func index(dir, url, mergeTo string) error {
out := filepath.Join(dir, "index.yaml")
i, err := repo.IndexDirectory(dir, url)
if err != nil {
return err
}
if mergeTo != "" {
// if index.yaml is missing then create an empty one to merge into
var i2 *repo.IndexFile
if _, err := os.Stat(mergeTo); os.IsNotExist(err) {
i2 = repo.NewIndexFile()
i2.WriteFile(mergeTo, 0644)
} else {
i2, err = repo.LoadIndexFile(mergeTo)
if err != nil {
return fmt.Errorf("Merge failed: %s", err)
}
}
i.Merge(i2)
}
i.SortEntries()
return i.WriteFile(out, 0644)
}
|
index.dir = args[0]
|
test_estimators.py
|
#*******************************************************************************
# Copyright 2014-2020 Intel Corporation
# All Rights Reserved.
#
# This software is licensed under the Apache License, Version 2.0 (the
# "License"), the following terms apply:
#
# You may not use this file except in compliance with the License. You may
# obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#
# See the License for the specific language governing permissions and
# limitations under the License.
#*******************************************************************************
import unittest
from sklearn.utils.estimator_checks import check_estimator
import sklearn.utils.estimator_checks
from daal4py import __daal_run_version__
daal_run_version = tuple(map(int, (__daal_run_version__[0:4], __daal_run_version__[4:8])))
from daal4py.sklearn.neighbors import KNeighborsClassifier
from daal4py.sklearn.ensemble import RandomForestClassifier
from daal4py.sklearn.ensemble import RandomForestRegressor
from daal4py.sklearn.ensemble import GBTDAALClassifier
from daal4py.sklearn.ensemble import GBTDAALRegressor
from daal4py.sklearn.ensemble import AdaBoostClassifier
from daal4py import __daal_link_version__ as dv
daal_version = tuple(map(int, (dv[0:4], dv[4:8])))
def check_version(rule, target):
if not isinstance(rule[0], type(target)):
if rule > target:
return False
else:
for rule_item in range(len(rule)):
if rule[rule_item] > target:
return False
else:
if rule[rule_item][0]==target[0]:
break
return True
def _replace_and_save(md, fns, replacing_fn):
"""
Replaces functions in `fns` list in `md` module with `replacing_fn`.
Returns the dictionary with functions that were replaced.
"""
saved = dict()
for check_f in fns:
try:
fn = getattr(md, check_f)
setattr(md, check_f, replacing_fn)
saved[check_f] = fn
except:
pass
return saved
def _restore_from_saved(md, saved_dict):
"""
Restores functions in `md` that were replaced in the function above.
"""
for check_f in saved_dict:
setattr(md, check_f, saved_dict[check_f])
class Test(unittest.TestCase):
def test_KNeighborsClassifier(self):
check_estimator(KNeighborsClassifier)
@unittest.skipUnless(check_version(((2019,0),(2021, 107)), daal_version), "not supported in this library version")
def test_RandomForestClassifier(self):
# check_methods_subset_invariance fails.
# Issue is created:
# https://github.com/IntelPython/daal4py/issues/129
# Skip the test
def dummy(*args, **kwargs):
pass
md = sklearn.utils.estimator_checks
saved = _replace_and_save(md, ['check_methods_subset_invariance', 'check_dict_unchanged'], dummy)
check_estimator(RandomForestClassifier)
_restore_from_saved(md, saved)
def test_RandomForestRegressor(self):
# check_fit_idempotent is known to fail with DAAL's decision
# forest regressor, due to different partitioning of data
# between threads from run to run.
# Hence skip that test
def dummy(*args, **kwargs):
pass
md = sklearn.utils.estimator_checks
saved = _replace_and_save(md, ['check_methods_subset_invariance', 'check_dict_unchanged'], dummy)
check_estimator(RandomForestRegressor)
_restore_from_saved(md, saved)
def test_GBTDAALClassifier(self):
check_estimator(GBTDAALClassifier)
def test_GBTDAALRegressor(self):
def dummy(*args, **kwargs):
|
md = sklearn.utils.estimator_checks
# got unexpected slightly different prediction result between two same calls in this test
saved = _replace_and_save(md, ['check_estimators_data_not_an_array'], dummy)
check_estimator(GBTDAALRegressor)
_restore_from_saved(md, saved)
@unittest.skipIf(daal_run_version < (2020, 0), "not supported in this library version")
def test_AdaBoostClassifier(self):
check_estimator(AdaBoostClassifier)
if __name__ == '__main__':
unittest.main()
|
pass
|
backend.go
|
// Package noop implements a ineffective RCS backend for use with external
// synchronization solutions.
// TODO(2.x) DEPRECATED and slated for removal in the 2.0.0 release.
package noop
import (
"context"
"time"
"github.com/gopasspw/gopass/internal/backend"
"github.com/blang/semver"
)
// Noop is a no-op git backend
type Noop struct{}
// New creates a new Noop object
func New() *Noop {
return &Noop{}
}
// Add does nothing
func (g *Noop) Add(ctx context.Context, args ...string) error {
return nil
}
// Commit does nothing
func (g *Noop) Commit(ctx context.Context, msg string) error {
return nil
}
// Push does nothing
func (g *Noop) Push(ctx context.Context, origin, branch string) error {
return nil
}
// Pull does nothing
func (g *Noop) Pull(ctx context.Context, origin, branch string) error {
return nil
}
// Cmd does nothing
func (g *Noop) Cmd(ctx context.Context, name string, args ...string) error {
return nil
}
// Init does nothing
func (g *Noop) Init(context.Context, string, string) error {
return nil
}
// InitConfig does nothing
func (g *Noop) InitConfig(context.Context, string, string) error {
return nil
}
// Version returns an empty version
func (g *Noop) Version(context.Context) semver.Version {
return semver.Version{}
}
|
// Name returns noop
func (g *Noop) Name() string {
return "noop"
}
// AddRemote does nothing
func (g *Noop) AddRemote(ctx context.Context, remote, url string) error {
return nil
}
// RemoveRemote does nothing
func (g *Noop) RemoveRemote(ctx context.Context, remote string) error {
return nil
}
// Revisions is not implemented
func (g *Noop) Revisions(context.Context, string) ([]backend.Revision, error) {
return []backend.Revision{
{
Hash: "latest",
Date: time.Now(),
}}, nil
}
// GetRevision is not implemented
func (g *Noop) GetRevision(context.Context, string, string) ([]byte, error) {
return []byte("foo\nbar"), nil
}
// Status is not implemented
func (g *Noop) Status(context.Context) ([]byte, error) {
return []byte(""), nil
}
// Compact is not implemented
func (g *Noop) Compact(context.Context) error {
return nil
}
| |
__init__.py
|
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
import collections
import collections.abc
from dataclasses import dataclass
from functools import partial
from typing import Any, Dict, List, NoReturn, Optional, Tuple
from omegaconf import MISSING, DictConfig, ListConfig
from hydra.types import TargetConf
from tests.instantiate.module_shadowed_by_function import a_function
module_shadowed_by_function = a_function
def _convert_type(obj: Any) -> Any:
if isinstance(obj, DictConfig):
obj = dict(obj)
elif isinstance(obj, ListConfig):
obj = list(obj)
return obj
def partial_equal(obj1: Any, obj2: Any) -> bool:
if obj1 == obj2:
return True
obj1, obj2 = _convert_type(obj1), _convert_type(obj2)
if type(obj1) != type(obj2):
return False
if isinstance(obj1, dict):
if len(obj1) != len(obj2):
return False
for i in obj1.keys():
if not partial_equal(obj1[i], obj2[i]):
return False
return True
if isinstance(obj1, list):
if len(obj1) != len(obj2):
return False
return all([partial_equal(obj1[i], obj2[i]) for i in range(len(obj1))])
if not (isinstance(obj1, partial) and isinstance(obj2, partial)):
return False
return all(
[
partial_equal(getattr(obj1, attr), getattr(obj2, attr))
for attr in ["func", "args", "keywords"]
]
)
class ArgsClass:
def __init__(self, *args: Any, **kwargs: Any) -> None:
assert isinstance(args, tuple)
assert isinstance(kwargs, dict)
self.args = args
self.kwargs = kwargs
def __repr__(self) -> str:
return f"self.args={self.args},self.kwarg={self.kwargs}"
def __eq__(self, other: Any) -> Any:
if isinstance(other, ArgsClass):
return self.args == other.args and self.kwargs == other.kwargs
else:
return NotImplemented
class OuterClass:
def __init__(self) -> None:
pass
@staticmethod
def method() -> str:
return "OuterClass.method return"
class Nested:
def __init__(self) -> None:
pass
@staticmethod
def method() -> str:
return "OuterClass.Nested.method return"
def add_values(a: int, b: int) -> int:
return a + b
def module_function(x: int) -> int:
return x
def module_function2() -> str:
return "fn return"
class ExceptionTakingNoArgument(Exception):
def __init__(self) -> None:
"""Init method taking only one argument (self)"""
super().__init__("Err message")
def raise_exception_taking_no_argument() -> NoReturn:
raise ExceptionTakingNoArgument()
@dataclass
class AClass:
a: Any
b: Any
c: Any
d: Any = "default_value"
@staticmethod
def static_method(z: int) -> int:
return z
@dataclass
class BClass:
a: Any
b: Any
c: Any = "c"
d: Any = "d"
@dataclass
class KeywordsInParamsClass:
target: Any
partial: Any
@dataclass
class UntypedPassthroughConf:
_target_: str = "tests.instantiate.UntypedPassthroughClass"
a: Any = MISSING
@dataclass
class UntypedPassthroughClass:
|
# Type not legal in a config
class IllegalType:
def __eq__(self, other: Any) -> Any:
return isinstance(other, IllegalType)
@dataclass
class AnotherClass:
x: int
class ASubclass(AnotherClass):
@classmethod
def class_method(cls, y: int) -> Any:
return cls(y + 1)
@staticmethod
def static_method(z: int) -> int:
return z
class Parameters:
def __init__(self, params: List[float]):
self.params = params
def __eq__(self, other: Any) -> Any:
if isinstance(other, Parameters):
return self.params == other.params
return False
def __deepcopy__(self, memodict: Any = {}) -> Any:
raise NotImplementedError("Pytorch parameters does not support deepcopy")
@dataclass
class Adam:
params: Parameters
lr: float = 0.001
betas: Tuple[float, ...] = (0.9, 0.999)
eps: float = 1e-08
weight_decay: int = 0
amsgrad: bool = False
@dataclass
class NestingClass:
a: ASubclass = ASubclass(10)
nesting = NestingClass()
class ClassWithMissingModule:
def __init__(self) -> None:
import some_missing_module # type: ignore # noqa: F401
self.x = 1
@dataclass
class AdamConf:
_target_: str = "tests.instantiate.Adam"
lr: float = 0.001
betas: Tuple[float, ...] = (0.9, 0.999)
eps: float = 1e-08
weight_decay: int = 0
amsgrad: bool = False
@dataclass
class BadAdamConf(TargetConf):
# Missing str annotation
_target_ = "tests.instantiate.Adam"
@dataclass
class User:
name: str = MISSING
age: int = MISSING
@dataclass
class UserGroup:
name: str = MISSING
users: List[User] = MISSING
# RECURSIVE
# Classes
class Transform:
...
class CenterCrop(Transform):
def __init__(self, size: int):
self.size = size
def __eq__(self, other: Any) -> Any:
if isinstance(other, type(self)):
return self.size == other.size
else:
return False
class Rotation(Transform):
def __init__(self, degrees: int):
self.degrees = degrees
def __eq__(self, other: Any) -> Any:
if isinstance(other, type(self)):
return self.degrees == other.degrees
else:
return False
class Compose:
transforms: List[Transform]
def __init__(self, transforms: List[Transform]):
self.transforms = transforms
def __eq__(self, other: Any) -> Any:
return partial_equal(self.transforms, other.transforms)
class Tree:
value: Any
# annotated any because of non recursive instantiation tests
left: Any = None
right: Any = None
def __init__(self, value: Any, left: Any = None, right: Any = None) -> None:
self.value = value
self.left = left
self.right = right
def __eq__(self, other: Any) -> Any:
if isinstance(other, type(self)):
return (
partial_equal(self.value, other.value)
and partial_equal(self.left, other.left)
and partial_equal(self.right, other.right)
)
else:
return False
def __repr__(self) -> str:
return f"Tree(value={self.value}, left={self.left}, right={self.right})"
class Mapping:
dictionary: Optional[Dict[str, "Mapping"]] = None
value: Any = None
def __init__(
self, value: Any = None, dictionary: Optional[Dict[str, "Mapping"]] = None
) -> None:
self.dictionary = dictionary
self.value = value
def __eq__(self, other: Any) -> Any:
if isinstance(other, type(self)):
return partial_equal(self.dictionary, other.dictionary) and partial_equal(
self.value, other.value
)
else:
return False
def __repr__(self) -> str:
return f"dictionary={self.dictionary}"
# Configs
@dataclass
class TransformConf:
...
@dataclass
class CenterCropConf(TransformConf):
_target_: str = "tests.instantiate.CenterCrop"
_partial_: bool = False
size: int = MISSING
@dataclass
class RotationConf(TransformConf):
_target_: str = "tests.instantiate.Rotation"
degrees: int = MISSING
@dataclass
class ComposeConf:
_target_: str = "tests.instantiate.Compose"
_partial_: bool = False
transforms: List[TransformConf] = MISSING
@dataclass
class TreeConf:
_target_: str = "tests.instantiate.Tree"
_partial_: bool = False
left: Optional["TreeConf"] = None
right: Optional["TreeConf"] = None
value: Any = MISSING
@dataclass
class MappingConf:
_target_: str = "tests.instantiate.Mapping"
_partial_: bool = False
dictionary: Optional[Dict[str, "MappingConf"]] = None
def __init__(
self,
dictionary: Optional[Dict[str, "MappingConf"]] = None,
_partial_: bool = False,
):
self.dictionary = dictionary
self._partial_ = _partial_
@dataclass
class SimpleDataClass:
a: Any = None
b: Any = None
class SimpleClass:
a: Any = None
b: Any = None
def __init__(self, a: Any, b: Any) -> None:
self.a = a
self.b = b
def __eq__(self, other: Any) -> Any:
if isinstance(other, SimpleClass):
return self.a == other.a and self.b == other.b
return False
@dataclass
class SimpleClassPrimitiveConf:
_target_: str = "tests.instantiate.SimpleClass"
_convert_: str = "partial"
a: Any = None
b: Any = None
@dataclass
class SimpleClassNonPrimitiveConf:
_target_: str = "tests.instantiate.SimpleClass"
_convert_: str = "none"
a: Any = None
b: Any = None
@dataclass
class SimpleClassDefaultPrimitiveConf:
_target_: str = "tests.instantiate.SimpleClass"
a: Any = None
b: Any = None
@dataclass
class NestedConf:
_target_: str = "tests.instantiate.SimpleClass"
a: Any = User(name="a", age=1)
b: Any = User(name="b", age=2)
def recisinstance(got: Any, expected: Any) -> bool:
"""Compare got with expected type, recursively on dict and list."""
if not isinstance(got, type(expected)):
return False
if isinstance(expected, collections.abc.Mapping):
return all(recisinstance(got[key], expected[key]) for key in expected)
elif isinstance(expected, collections.abc.Iterable):
return all(recisinstance(got[idx], exp) for idx, exp in enumerate(expected))
return True
|
a: Any
|
dialogs.go
|
package main
import (
"bytes"
"errors"
"image/png"
"sync/atomic"
"time"
"github.com/lxn/walk"
. "github.com/lxn/walk/declarative"
"github.com/makiuchi-d/gozxing"
"github.com/makiuchi-d/gozxing/qrcode"
qrenc "github.com/skip2/go-qrcode"
"gocv.io/x/gocv"
)
// prompt user to enter a passphrase
func ShowPassphraseDialog(owner walk.Form, okCallback func(pass string))
|
// prompt user to enter the old passphrase and re-type the new passphrase twice
func ShowChangePassphraseDialog(owner walk.Form, okCallback func(oldPass, newPass string)) {
var dlg *walk.Dialog
var okPB, cancelPB *walk.PushButton
var passOldLineEdit, passNew1LineEdit, passNew2LineEdit *walk.LineEdit
var dialog = Dialog{}
dialog.AssignTo = &dlg
dialog.Title = T("changeEncryptPassphrase")
dialog.MinSize = Size{300, 200}
dialog.Layout = VBox{}
dialog.DefaultButton = &okPB
dialog.CancelButton = &cancelPB
childrens := []Widget{
Composite{
Layout: Grid{Columns: 2},
Children: []Widget{
Label{Text: T("enterOldEncryptPassphrase")},
LineEdit{
AssignTo: &passOldLineEdit,
PasswordMode: true,
},
Label{Text: T("belowNewEncryptPassphrase")},
Label{},
Label{Text: T("enterEncryptPassphrase")},
LineEdit{
AssignTo: &passNew1LineEdit,
PasswordMode: true,
},
Label{Text: T("retypeEncryptPassphrase")},
LineEdit{
AssignTo: &passNew2LineEdit,
PasswordMode: true,
},
},
},
Composite{
Layout: HBox{},
Children: []Widget{
HSpacer{},
PushButton{
AssignTo: &okPB,
Text: T("ok"),
OnClicked: func() {
pass1 := passNew1LineEdit.Text()
pass2 := passNew2LineEdit.Text()
oldPass := passOldLineEdit.Text()
if pass1 != pass2 {
walk.MsgBox(MainWin, T("error!"), T("mismatchPassphrase"), walk.MsgBoxIconError|walk.MsgBoxApplModal)
return
}
okCallback(oldPass, pass1)
dlg.Accept()
},
},
PushButton{
AssignTo: &cancelPB,
Text: T("cancel"),
OnClicked: func() { dlg.Cancel() },
},
},
},
}
dialog.Children = childrens
dialog.Run(owner)
}
// continuously read images from webcam and scan QRCode in the images
// When a valid QRCode is obtained, okCallback will be invoked with it and dlg will be closed
func runJob(webcam *gocv.VideoCapture, imageView *walk.ImageView, mat *gocv.Mat,
okCallback func(text string), dlg *walk.Dialog, running *int32) {
for {
if atomic.LoadInt32(running) == 0 {
return
}
//println("haha1")
if ok := webcam.Read(mat); !ok {
continue
}
//println("haha2")
if mat.Empty() {
continue
}
img, err := mat.ToImage()
//println("haha3")
if err != nil {
continue
}
bitmap, err := walk.NewBitmapFromImage(img)
//println("haha4")
if err != nil {
continue
}
MainWin.Synchronize(func() {
imageView.SetImage(bitmap)
})
//println("haha5")
bmp, err := gozxing.NewBinaryBitmapFromImage(img)
if err != nil {
continue
}
// decode image
//println("haha6")
qrReader := qrcode.NewQRCodeReader()
result, err := qrReader.Decode(bmp, nil)
if err == nil {
okCallback(result.String())
dlg.Cancel()
return
}
time.Sleep(200 * time.Millisecond)
}
}
// Scan all the webcams to get the one with highest resolution
func getBestWebcam() (*gocv.VideoCapture, error) {
bestID := -1
largestHeight := -1
for i := 0; i < 10; i++ {
webcam, err := gocv.OpenVideoCapture(i)
if err != nil {
break
}
webcam.Set(gocv.VideoCaptureFrameWidth, 1920)
webcam.Set(gocv.VideoCaptureFrameHeight, 1080)
h := int(webcam.Get(gocv.VideoCaptureFrameHeight))
if h > largestHeight {
largestHeight = h
bestID = i
}
webcam.Close()
}
if bestID == -1 {
return nil, errors.New("No webcam was found!")
}
webcam, err := gocv.OpenVideoCapture(bestID)
if err == nil {
webcam.Set(gocv.VideoCaptureFrameWidth, 1920)
webcam.Set(gocv.VideoCaptureFrameHeight, 1080)
}
return webcam, err
}
// Show a dialog for scanning QRCode
func ShowQRCodeScanDialog(owner walk.Form, okCallback func(text string)) {
var dlg *walk.Dialog
var cancelPB *walk.PushButton
var imageView *walk.ImageView
webcam, err := getBestWebcam()
if err != nil {
walk.MsgBox(MainWin, T("error!"), T("failOpenWebcam"), walk.MsgBoxIconError|walk.MsgBoxApplModal)
return
}
mat := gocv.NewMat()
running := int32(1)
h := int(webcam.Get(gocv.VideoCaptureFrameHeight))
w := int(webcam.Get(gocv.VideoCaptureFrameWidth))
dialog := Dialog{}
dialog.AssignTo = &dlg
dialog.Title = T("scanQRCode")
dialog.MinSize = Size{w+30, h+100}
dialog.Layout = VBox{}
dialog.CancelButton = &cancelPB
childrens := []Widget{
ImageView{
AssignTo: &imageView,
Margin: 10,
Mode: ImageViewModeStretch,
},
PushButton{
AssignTo: &cancelPB,
Text: T("cancel"),
MinSize: Size{100, 50},
OnClicked: func() { dlg.Cancel() },
},
}
dialog.Children = childrens
dialog.Create(owner)
dlg.Closing().Attach(func(canceled *bool, reason walk.CloseReason) {
atomic.AddInt32(&running, -1)
webcam.Close()
mat.Close()
})
imageView.SetDoubleBuffering(true)
dlg.SetDoubleBuffering(true)
go runJob(webcam, imageView, &mat, okCallback, dlg, &running)
dlg.Run()
}
// Shows a QRCode on screen
func ShowQRCodeDialog(owner walk.Form, text, title, hint string) error {
var dlg *walk.Dialog
var okPB *walk.PushButton
var imageView *walk.ImageView
bz, err := qrenc.Encode(text, qrenc.Medium, 512)
if err != nil {
return err
}
pngImg, err := png.Decode(bytes.NewReader(bz))
if err != nil {
return err
}
bitmap, err := walk.NewBitmapFromImage(pngImg)
if err != nil {
return err
}
dialog := Dialog{}
dialog.AssignTo = &dlg
dialog.Title = title
dialog.MinSize = Size{800, 600}
dialog.Layout = VBox{}
dialog.DefaultButton = &okPB
childrens := []Widget{
Label{Text: hint},
ImageView{
AssignTo: &imageView,
Margin: 10,
Mode: ImageViewModeStretch,
},
PushButton{
AssignTo: &okPB,
Text: T("ok"),
OnClicked: func() { dlg.Accept() },
},
}
dialog.Children = childrens
dialog.Create(owner)
imageView.SetImage(bitmap)
dlg.Run()
return nil
}
|
{
var dlg *walk.Dialog
var okPB, cancelPB *walk.PushButton
var passLineEdit *walk.LineEdit
var dialog = Dialog{}
dialog.AssignTo = &dlg
dialog.Title = T("enterEncryptPassphrase")
dialog.MinSize = Size{300, 200}
dialog.Layout = VBox{}
dialog.DefaultButton = &okPB
dialog.CancelButton = &cancelPB
childrens := []Widget{
Composite{
Layout: Grid{Columns: 2},
Children: []Widget{
Label{Text: T("enterEncryptPassphrase")},
LineEdit{
AssignTo: &passLineEdit,
PasswordMode: true,
},
},
},
Composite{
Layout: HBox{},
Children: []Widget{
HSpacer{},
PushButton{
AssignTo: &okPB,
Text: T("ok"),
OnClicked: func() {
okCallback(passLineEdit.Text())
dlg.Accept()
},
},
PushButton{
AssignTo: &cancelPB,
Text: T("cancel"),
OnClicked: func() { dlg.Cancel() },
},
},
},
}
dialog.Children = childrens
dialog.Run(owner)
}
|
BatchClassifier.py
|
from typing import Sequence, Mapping
from numpy import mod
import torch
from torch import nn
from torch import optim
import torch.nn.functional as F
from .model_utils import get_fully_connected_layers
from scETM.logging_utils import log_arguments
class BatchClassifier(nn.Module):
|
"""Docstring (TODO)
"""
@log_arguments
def __init__(self,
n_input: int,
n_output: int,
hidden_sizes: Sequence[int],
bn: bool = False,
bn_track_running_stats: bool = False,
dropout_prob = 0.2,
adversarial_loss = 'confuse',
device=torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
) -> None:
"""Docstring (TODO)
"""
super().__init__()
self.batch_clf = get_fully_connected_layers(
n_trainable_input=n_input,
n_trainable_output=n_output,
hidden_sizes=hidden_sizes,
bn=bn,
bn_track_running_stats=bn_track_running_stats,
dropout_prob=dropout_prob,
).to(device)
self.n_output = n_output
assert adversarial_loss in ('confuse', 'reverse')
self.adversarial_loss = adversarial_loss
def forward(self, X: torch.Tensor, y: torch.Tensor) -> Mapping[str, torch.Tensor]:
"""Docstring (TODO)
"""
logit = self.batch_clf(X)
if not self.training:
return dict(logit=logit)
clf_loss = F.cross_entropy(logit, y)
if self.adversarial_loss == 'confuse':
model_loss = (-F.log_softmax(logit, dim=-1) * torch.zeros_like(logit).fill_(1/self.n_output)).sum(-1).mean()
else:
model_loss = -clf_loss
return clf_loss, dict(logit=logit, model_loss=model_loss), dict(clf_loss=clf_loss.detach().item())
def train_step(self,
optimizer: optim.Optimizer,
X: torch.Tensor,
y: torch.Tensor
) -> Mapping[str, torch.Tensor]:
"""Docstring (TODO)
"""
self.train()
optimizer.zero_grad()
loss, fwd_dict, new_records = self(X, y)
loss.backward()
optimizer.step()
new_records['clf_acc'] = (fwd_dict['logit'].argmax(1) == y).to(torch.float).mean().detach().item()
return new_records
|
|
DateTime.ts
|
import { isDefined, tryTo, Value } from '../../types';
import moment, { Moment } from 'moment';
export type DateTimeUnit =
'years'
| 'quarters'
| 'months'
| 'weeks'
| 'days'
| 'hours'
| 'minutes'
| 'seconds'
| 'milliseconds';
export class
|
extends Value<string | undefined> {
constructor(value?: string | number | Date) {
super(tryTo(value).is.defined().map(v => moment.utc(v, true).toISOString()).orElse());
}
static get now(): DateTime {
return new DateTime(moment.utc().toISOString());
}
get isValid(): boolean {
return isDefined(this.value) && this.utc.isValid();
}
get fromNow(): string {
return this.value ? this.utc.fromNow() : '';
}
protected get utc(): Moment {
return moment.utc(this.value);
}
isAfter(dt: DateTime): boolean {
return this.utc.isAfter(moment.utc(dt.value));
}
isBefore(dt: DateTime): boolean {
return this.utc.isBefore(moment.utc(dt.value));
}
add = (n: number, unit: DateTimeUnit = 'days'): DateTime => new DateTime(this.utc.add(n, unit).toISOString());
subtract = (n: number, unit: DateTimeUnit = 'days'): DateTime => new DateTime(this.utc.subtract(n, unit).toISOString());
diff = (other: DateTime, unit: DateTimeUnit = 'days'): number => this.utc.diff(other.utc, unit);
toString(): string {
return this.value ?? '';
}
toLocale(locales: string | string[] = 'nl-NL', options: Intl.DateTimeFormatOptions = {}): string {
return this.toDate()?.toLocaleDateString(locales, options) ?? '';
}
toDate(): Date | undefined {
return this.isValid ? this.utc.toDate() : undefined;
}
}
|
DateTime
|
encode.go
|
/*
Copyright 2019 The Crossplane Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package v1alpha1
import (
"fmt"
"github.com/zclconf/go-cty/cty"
"github.com/crossplane/crossplane-runtime/pkg/meta"
"github.com/crossplane/crossplane-runtime/pkg/resource"
"github.com/hashicorp/terraform/providers"
)
type ctyEncoder struct{}
func (e *ctyEncoder) EncodeCty(mr resource.Managed, schema *providers.Schema) (cty.Value, error) {
r, ok := mr.(*TagCategory)
if !ok {
return cty.NilVal, fmt.Errorf("EncodeType received a resource.Managed value which is not a TagCategory.")
}
return EncodeTagCategory(*r), nil
}
func EncodeTagCategory(r TagCategory) cty.Value {
ctyVal := make(map[string]cty.Value)
EncodeTagCategory_Cardinality(r.Spec.ForProvider, ctyVal)
EncodeTagCategory_Description(r.Spec.ForProvider, ctyVal)
EncodeTagCategory_Name(r.Spec.ForProvider, ctyVal)
EncodeTagCategory_AssociableTypes(r.Spec.ForProvider, ctyVal)
// always set id = external-name if it exists
// TODO: we should trim Id off schemas in an "optimize" pass
// before code generation
en := meta.GetExternalName(&r)
ctyVal["id"] = cty.StringVal(en)
return cty.ObjectVal(ctyVal)
}
func EncodeTagCategory_Cardinality(p TagCategoryParameters, vals map[string]cty.Value) {
vals["cardinality"] = cty.StringVal(p.Cardinality)
}
func
|
(p TagCategoryParameters, vals map[string]cty.Value) {
vals["description"] = cty.StringVal(p.Description)
}
func EncodeTagCategory_Name(p TagCategoryParameters, vals map[string]cty.Value) {
vals["name"] = cty.StringVal(p.Name)
}
func EncodeTagCategory_AssociableTypes(p TagCategoryParameters, vals map[string]cty.Value) {
colVals := make([]cty.Value, 0)
for _, value := range p.AssociableTypes {
colVals = append(colVals, cty.StringVal(value))
}
if len(colVals) == 0 {
vals["associable_types"] = cty.SetValEmpty(cty.String)
} else {
vals["associable_types"] = cty.SetVal(colVals)
}
}
|
EncodeTagCategory_Description
|
dictionary.js
|
export default {
namespaced: true,
state: {
loading: false
|
getters: {
loading (state) {
return state.loading
}
},
mutations: {
toggleLoading (state, payload) {
state.loading = payload
}
},
actions: {}
}
|
},
|
psc_class.py
|
'''台本の行の種類の定義
'''
from enum import Enum
|
'''
TITLE = 0 # 題名
AUTHOR = 1 # 著者名
CHARSHEADLINE = 2 # 登場人物見出し
CHARACTER = 3 # 登場人物
H1 = 4 # 柱 (レベル1)
H2 = 5 # 柱 (レベル2)
H3 = 6 # 柱 (レベル3)
DIRECTION = 7 # ト書き
DIALOGUE = 8 # セリフ
ENDMARK = 9 # エンドマーク
COMMENT = 10 # コメント
EMPTY = 11 # 空行
CHARACTER_CONTINUED = 12 # 登場人物の2行目以降
DIRECTION_CONTINUED = 13 # ト書きの2行目以降
DIALOGUE_CONTINUED = 14 # セリフの2行目以降
COMMENT_CONTINUED = 15 # コメントの2行目以降
|
class PscClass(Enum):
'''台本の行の種類
|
052.py
|
def helper(num):
|
def ans():
num = 100000
while True:
string = helper(num)
if all(helper(num * i) == string for i in range(2, 7)):
return num
num += 1
if __name__ == '__main__':
print(ans())
|
return ''.join(sorted(str(num)))
|
nn_ops.py
|
# Copyright 2020 Huawei Technologies Co., Ltd
#
# 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.
# ============================================================================
"""Operators for nn."""
import math
import operator
from functools import reduce
import numpy as np
from ... import context
from .. import signature as sig
from ..._checkparam import Validator as validator
from ..._checkparam import Rel
from ...common import dtype as mstype
from ..primitive import Primitive, PrimitiveWithInfer, PrimitiveWithCheck, prim_attr_register
from ..operations.math_ops import _infer_shape_reduce
def _check_positive_int_or_tuple(arg_name, arg_value, prim_name, allow_four=False, ret_four=False):
"""
Checks whether an argument is a positive int or tuple with 2 or 4(when allow_four is True) positive int elements.
"""
def _raise_message():
raise ValueError(f"For '{prim_name}' attr '{arg_name}' should be an positive int number or a tuple of two "
f"{'or four ' if allow_four else ''}positive int numbers, but got {arg_value}")
def _get_return_value():
if isinstance(arg_value, int):
ret = (1, 1, arg_value, arg_value) if ret_four else (arg_value, arg_value)
elif len(arg_value) == 2:
ret = (1, 1, arg_value[0], arg_value[1]) if ret_four else arg_value
elif len(arg_value) == 4:
if not allow_four:
_raise_message()
ret = arg_value if ret_four else (arg_value[2], arg_value[3])
else:
_raise_message()
return ret
validator.check_value_type(arg_name, arg_value, (int, tuple), prim_name)
ret_value = _get_return_value()
for item in ret_value:
if isinstance(item, int) and item > 0:
continue
_raise_message()
return ret_value
class Flatten(PrimitiveWithInfer):
r"""
Flattens a tensor without changing its batch size on the 0-th axis.
Inputs:
- **input_x** (Tensor) - Tensor of shape :math:`(N, \ldots)` to be flattened.
Outputs:
Tensor, the shape of the output tensor is :math:`(N, X)`, where :math:`X` is
the product of the remaining dimension.
Examples:
>>> input_tensor = Tensor(np.ones(shape=[1, 2, 3, 4]), mindspore.float32)
>>> flatten = P.Flatten()
>>> output = flatten(input_tensor)
>>> assert output.shape == (1, 24)
"""
@prim_attr_register
def __init__(self):
pass
def infer_shape(self, input_x):
validator.check_integer('input_x rank', len(input_x), 1, Rel.GE, self.name)
prod = 1 if len(input_x) == 1 else reduce(operator.mul, input_x[1:])
return input_x[0], prod
def infer_dtype(self, input_x):
validator.check_subclass("input_x", input_x, mstype.tensor, self.name)
return input_x
class Softmax(PrimitiveWithInfer):
r"""
Softmax operation.
Applies the Softmax operation to the input tensor on the specified axis.
Suppose a slice in the given aixs :math:`x` then for each element :math:`x_i`
the Softmax function is shown as follows:
.. math::
\text{output}(x_i) = \frac{exp(x_i)}{\sum_{j = 0}^{N-1}\exp(x_j)},
where :math:`N` is the length of the tensor.
Args:
axis (Union[int, tuple]): The axis to do the Softmax operation. Default: -1.
Inputs:
- **logits** (Tensor) - The input of Softmax, with float16 or float32 data type.
Outputs:
Tensor, with the same type and shape as the logits.
Examples:
>>> input_x = Tensor(np.array([1, 2, 3, 4, 5]), mindspore.float32)
>>> softmax = P.Softmax()
>>> softmax(input_x)
[0.01165623, 0.03168492, 0.08612854, 0.23412167, 0.6364086]
"""
@prim_attr_register
def __init__(self, axis=-1):
self.init_prim_io_names(inputs=['x'], outputs=['output'])
validator.check_value_type("axis", axis, [int, tuple], self.name)
if isinstance(axis, int):
self.add_prim_attr('axis', (axis,))
for item in self.axis:
validator.check_value_type("item of axis", item, [int], self.name)
def infer_shape(self, logits):
validator.check_integer("length of axis", len(self.axis), 1, Rel.GE, self.name)
rank = len(logits)
for axis_v in self.axis:
validator.check_int_range("axis", axis_v, -rank, rank, Rel.INC_LEFT, self.name)
return logits
def infer_dtype(self, logits):
validator.check_subclass("logits", logits, mstype.tensor, self.name)
validator.check_tensor_type_same({"logits": logits}, mstype.float_type, self.name)
return logits
class LogSoftmax(PrimitiveWithInfer):
r"""
Log Softmax activation function.
Applies the Log Softmax function to the input tensor on the specified axis.
Suppose a slice in the given aixs :math:`x` then for each element :math:`x_i`
the Log Softmax function is shown as follows:
.. math::
\text{output}(x_i) = \log \left(\frac{exp(x_i)} {\sum_{j = 0}^{N-1}\exp(x_j)}\right),
where :math:`N` is the length of the Tensor.
Args:
axis (int): The axis to do the Log softmax operation. Default: -1.
Inputs:
- **logits** (Tensor) - The input of Log Softmax, with float16 or float32 data type.
Outputs:
Tensor, with the same type and shape as the logits.
Examples:
>>> input_x = Tensor(np.array([1, 2, 3, 4, 5]), mindspore.float32)
>>> log_softmax = P.LogSoftmax()
>>> log_softmax(input_x)
[-4.4519143, -3.4519143, -2.4519143, -1.4519144, -0.4519144]
"""
@prim_attr_register
def __init__(self, axis=-1):
validator.check_value_type("axis", axis, [int], self.name)
def infer_shape(self, logits):
rank = len(logits)
validator.check_int_range('axis', self.axis, -rank, rank, Rel.INC_LEFT, self.name)
return logits
def infer_dtype(self, logits):
validator.check_subclass("logits", logits, mstype.tensor, self.name)
validator.check_tensor_type_same({"logits": logits}, mstype.float_type, self.name)
return logits
class Softplus(PrimitiveWithInfer):
r"""
Softplus activation function.
Softplus is a smooth approximation to the ReLU function.
The function is shown as follows:
.. math::
\text{output} = \log(1 + \exp(\text{input_x})),
Inputs:
- **input_x** (Tensor) - The input tensor whose data type should be float.
Outputs:
Tensor, with the same type and shape as the `input_x`.
Examples:
>>> input_x = Tensor(np.array([1, 2, 3, 4, 5]), mindspore.float32)
>>> softplus = P.Softplus()
>>> softplus(input_x)
[1.3132615, 2.126928, 3.0485873, 4.01815, 5.0067153]
"""
@prim_attr_register
def __init__(self):
"""init Softplus"""
self.init_prim_io_names(inputs=['x'], outputs=['output'])
def infer_shape(self, input_x):
return input_x
def infer_dtype(self, input_x):
validator.check_tensor_type_same({'input_x': input_x}, mstype.float_type, self.name)
return input_x
class Softsign(PrimitiveWithInfer):
r"""
Softsign activation function.
The function is shown as follows:
.. math::
\text{output} = \frac{\text{input_x}}{1 + \left| \text{input_x} \right|},
Inputs:
- **input_x** (Tensor) - The input tensor whose data type should be float16 or float32.
Outputs:
Tensor, with the same type and shape as the `input_x`.
Examples:
>>> input_x = Tensor(np.array([0, -1, 2, 30, -30]), mindspore.float32)
>>> softsign = P.Softsign()
>>> softsign(input_x)
[0. -0.5 0.6666667 0.9677419 -0.9677419]
"""
@prim_attr_register
def __init__(self):
"""init Softsign"""
self.init_prim_io_names(inputs=['x'], outputs=['output'])
def infer_shape(self, input_x):
return input_x
def infer_dtype(self, input_x):
validator.check_tensor_type_same({'input_x': input_x}, [mstype.float16, mstype.float32], self.name)
return input_x
class ReLU(PrimitiveWithInfer):
r"""
Computes ReLU(Rectified Linear Unit) of input tensor element-wise.
It returns :math:`\max(x,\ 0)` element-wise.
Inputs:
- **input_x** (Tensor) - The input tensor.
Outputs:
Tensor, with the same type and shape as the `input_x`.
Examples:
>>> input_x = Tensor(np.array([[-1.0, 4.0, -8.0], [2.0, -5.0, 9.0]]), mindspore.float32)
>>> relu = P.ReLU()
>>> result = relu(input_x)
[[0, 4.0, 0.0], [2.0, 0.0, 9.0]]
"""
@prim_attr_register
def __init__(self):
"""init ReLU"""
self.init_prim_io_names(inputs=['x'], outputs=['output'])
def infer_shape(self, input_x):
return input_x
def infer_dtype(self, input_x):
validator.check_tensor_type_same({'input_x': input_x}, mstype.number_type, self.name)
return input_x
class ReLU6(PrimitiveWithInfer):
r"""
Computes ReLU(Rectified Linear Unit) upper bounded by 6 of input tensor element-wise.
It returns :math:`\min(\max(0,x), 6)` element-wise.
Inputs:
- **input_x** (Tensor) - The input tensor. With float16 or float32 data type.
Outputs:
Tensor, with the same type and shape as the `input_x`.
Examples:
>>> input_x = Tensor(np.array([[-1.0, 4.0, -8.0], [2.0, -5.0, 9.0]]), mindspore.float32)
>>> relu6 = P.ReLU6()
>>> result = relu6(input_x)
"""
@prim_attr_register
def __init__(self):
"""init ReLU6"""
self.init_prim_io_names(inputs=['x'], outputs=['output'])
def infer_shape(self, input_x):
return input_x
def infer_dtype(self, input_x):
validator.check_tensor_type_same({'input_x': input_x}, (mstype.float16, mstype.float32), self.name)
return input_x
class ReLUV2(PrimitiveWithInfer):
r"""
Computes ReLU(Rectified Linear Unit) of input tensor element-wise.
It returns :math:`\max(x,\ 0)` element-wise.
Inputs:
- **input_x** (Tensor) - The input tensor should be a 4-D tensor.
Outputs:
- **output** (Tensor) - Has the same type and shape as the `input_x`.
- **mask** (Tensor) - A tensor whose data type must be uint8.
Examples:
>>> input_x = Tensor(np.array([[[[1, -2], [-3, 4]], [[-5, 6], [7, -8]]]]), mindspore.float32)
>>> relu_v2 = P.ReLUV2()
>>> output = relu_v2(input_x)
([[[[1., 0.], [0., 4.]], [[0., 6.], [7., 0.]]]],
[[[[1, 0], [2, 0]], [[2, 0], [1, 0]]]])
"""
@prim_attr_register
def __init__(self):
"""init ReLUV2"""
self.init_prim_io_names(inputs=['x'], outputs=['output', 'mask'])
def __infer__(self, input_x):
input_shape = list(input_x['shape'])
input_dtype = input_x['dtype']
mask_shape = []
if len(input_shape) != 4:
raise ValueError("The `input_x` should be a 4-D tensor, "
f"but got a {len(input_shape)}-D tensor whose shape is {input_shape}")
for i in enumerate(input_shape):
if i[0] == 1:
if input_dtype == mstype.uint8 and input_dtype == mstype.int8:
mask_shape.append((input_shape[1] + 31) // 32)
else:
mask_shape.append((input_shape[1] + 15) // 16)
else:
mask_shape.append(i[1])
if input_dtype == mstype.uint8 and input_dtype == mstype.int8:
mask_shape.append(4)
else:
mask_shape.append(2)
output_shape = (input_x['shape'], mask_shape)
validator.check_subclass("input_x", input_dtype, mstype.tensor, self.name)
validator.check_tensor_type_same({'input_x': input_dtype}, mstype.number_type, self.name)
mask_dtype = mstype.uint8
output_dtype = (input_dtype, mask_dtype)
return {'shape': output_shape,
'dtype': output_dtype,
'value': None}
class Elu(PrimitiveWithInfer):
r"""
Computes exponential linear: `alpha * (exp(x) - 1)` if x < 0, `x` otherwise.
The data type of input tensor should be float.
Args:
alpha (float): The coefficient of negative factor whose type is float,
only support '1.0' currently. Default: 1.0.
Inputs:
- **input_x** (Tensor) - The input tensor whose data type should be float.
Outputs:
Tensor, has the same shape and data type as `input_x`.
Examples:
>>> input_x = Tensor(np.array([[-1.0, 4.0, -8.0], [2.0, -5.0, 9.0]]), mindspore.float32)
>>> elu = P.Elu()
>>> result = elu(input_x)
Tensor([[-0.632 4.0 -0.999]
[2.0 -0.993 9.0 ]], shape=(2, 3), dtype=mindspore.float32)
"""
@prim_attr_register
def __init__(self, alpha=1.0):
"""Init Elu"""
validator.check_value_type("alpha", alpha, [float], self.name)
validator.check_number("alpha", alpha, 1.0, Rel.EQ, self.name)
def infer_shape(self, input_x):
return input_x
def infer_dtype(self, input_x):
validator.check_tensor_type_same({'input_x': input_x}, mstype.float_type, self.name)
return input_x
class HSwish(PrimitiveWithInfer):
r"""
Hard swish activation function.
Applies hswish-type activation element-wise. The input is a Tensor with any valid shape.
Hard swish is defined as:
.. math::
\text{hswish}(x_{i}) = x_{i} * \frac{ReLU6(x_{i} + 3)}{6},
where :math:`x_{i}` is the :math:`i`-th slice in the given dimension of the input Tensor.
Inputs:
- **input_data** (Tensor) - The input of HSwish, data type should be float16 or float32.
Outputs:
Tensor, with the same type and shape as the `input_data`.
Examples:
>>> hswish = P.HSwish()
>>> input_x = Tensor(np.array([-1, -2, 0, 2, 1]), mindspore.float16)
>>> result = hswish(input_x)
"""
@prim_attr_register
def __init__(self):
self.init_prim_io_names(inputs=['x'], outputs=['output'])
def infer_shape(self, xshape):
return xshape
def infer_dtype(self, x_dtype):
validator.check_tensor_type_same({"x": x_dtype}, (mstype.float16, mstype.float32), self.name)
return x_dtype
class Sigmoid(PrimitiveWithInfer):
r"""
Sigmoid activation function.
Computes Sigmoid of input element-wise. The Sigmoid function is defined as:
.. math::
\text{sigmoid}(x_i) = \frac{1}{1 + exp(-x_i)},
where :math:`x_i` is the element of the input.
Inputs:
- **input_x** (Tensor) - The input of Sigmoid, data type should be float16 or float32.
Outputs:
Tensor, with the same type and shape as the input_x.
Examples:
>>> input_x = Tensor(np.array([1, 2, 3, 4, 5]), mindspore.float32)
>>> sigmoid = P.Sigmoid()
>>> sigmoid(input_x)
[0.73105866, 0.880797, 0.9525742, 0.98201376, 0.9933071]
"""
@prim_attr_register
def __init__(self):
self.init_prim_io_names(inputs=['x'], outputs=['output'])
def infer_shape(self, input_x):
return input_x
def infer_dtype(self, input_x):
validator.check_tensor_type_same({"input_x": input_x}, (mstype.float16, mstype.float32), self.name)
return input_x
class HSigmoid(PrimitiveWithInfer):
r"""
Hard sigmoid activation function.
Applies hard sigmoid activation element-wise. The input is a Tensor with any valid shape.
Hard sigmoid is defined as:
.. math::
\text{hsigmoid}(x_{i}) = max(0, min(1, \frac{x_{i} + 3}{6})),
where :math:`x_{i}` is the :math:`i`-th slice in the given dimension of the input Tensor.
Inputs:
- **input_data** (Tensor) - The input of HSigmoid, data type should be float16 or float32.
Outputs:
Tensor, with the same type and shape as the `input_data`.
Examples:
>>> hsigmoid = P.HSigmoid()
>>> input_x = Tensor(np.array([-1, -2, 0, 2, 1]), mindspore.float16)
>>> result = hsigmoid(input_x)
"""
@prim_attr_register
def __init__(self):
self.init_prim_io_names(inputs=['x'], outputs=['output'])
def infer_shape(self, x_shape):
return x_shape
def infer_dtype(self, x_dtype):
validator.check_tensor_type_same({"x": x_dtype}, (mstype.float16, mstype.float32), self.name)
return x_dtype
class Tanh(PrimitiveWithInfer):
r"""
Tanh activation function.
Computes hyperbolic tangent of input element-wise. The Tanh function is defined as:
.. math::
tanh(x_i) = \frac{\exp(x_i) - \exp(-x_i)}{\exp(x_i) + \exp(-x_i)} = \frac{\exp(2x_i) - 1}{\exp(2x_i) + 1},
where :math:`x_i` is an element of the input Tensor.
Inputs:
- **input_x** (Tensor) - The input of Tanh.
Outputs:
Tensor, with the same type and shape as the input_x.
Examples:
>>> input_x = Tensor(np.array([1, 2, 3, 4, 5]), mindspore.float32)
>>> tanh = P.Tanh()
>>> tanh(input_x)
[0.7615941, 0.9640276, 0.9950548, 0.9993293, 0.99990916]
"""
@prim_attr_register
def __init__(self):
pass
def infer_shape(self, input_x):
return input_x
def infer_dtype(self, input_x):
validator.check_subclass("input_x", input_x, mstype.tensor, self.name)
return input_x
class FusedBatchNorm(Primitive):
r"""
FusedBatchNorm is a BatchNorm that moving mean and moving variance will be computed instead of being loaded.
Batch Normalization is widely used in convolutional networks. This operation applies
Batch Normalization over input to avoid internal covariate shift as described in the
paper `Batch Normalization: Accelerating Deep Network Training by Reducing Internal
Covariate Shift <https://arxiv.org/abs/1502.03167>`_. It rescales and recenters the
feature using a mini-batch of data and the learned parameters which can be described
in the following formula.
.. math::
y = \frac{x - mean}{\sqrt{variance + \epsilon}} * \gamma + \beta
where :math:`\gamma` is scale, :math:`\beta` is bias, :math:`\epsilon` is epsilon.
Args:
mode (int): Mode of batch normalization, value is 0 or 1. Default: 0.
epsilon (float): A small value added for numerical stability. Default: 1e-5.
momentum (float): The hyper parameter to compute moving average for running_mean and running_var
(e.g. :math:`new\_running\_mean = momentum * running\_mean + (1 - momentum) * current\_mean`).
Momentum value should be [0, 1]. Default: 0.9.
Inputs:
- **input_x** (Tensor) - Tensor of shape :math:`(N, C)`.
- **scale** (Tensor) - Tensor of shape :math:`(C,)`.
- **bias** (Tensor) - Tensor of shape :math:`(C,)`.
- **mean** (Tensor) - Tensor of shape :math:`(C,)`.
- **variance** (Tensor) - Tensor of shape :math:`(C,)`.
Outputs:
Tuple of 5 Tensor, the normalized input and the updated parameters.
- **output_x** (Tensor) - The same type and shape as the `input_x`.
- **updated_scale** (Tensor) - Tensor of shape :math:`(C,)`.
- **updated_bias** (Tensor) - Tensor of shape :math:`(C,)`.
- **updated_moving_mean** (Tensor) - Tensor of shape :math:`(C,)`.
- **updated_moving_variance** (Tensor) - Tensor of shape :math:`(C,)`.
Examples:
>>> input_x = Tensor(np.ones([128, 64, 32, 64]), mindspore.float32)
>>> scale = Tensor(np.ones([64]), mindspore.float32)
>>> bias = Tensor(np.ones([64]), mindspore.float32)
>>> mean = Tensor(np.ones([64]), mindspore.float32)
>>> variance = Tensor(np.ones([64]), mindspore.float32)
>>> op = P.FusedBatchNorm()
>>> output = op(input_x, scale, bias, mean, variance)
"""
@prim_attr_register
def __init__(self, mode=0, epsilon=1e-5, momentum=0.1):
self.init_prim_io_names(inputs=['x', 'scale', 'b', 'mean', 'variance'],
outputs=['y', 'running_mean', 'running_variance', 'save_mean', 'save_inv_variance'])
self.mode = validator.check_integer('mode', mode, [0, 1], Rel.IN, self.name)
self.epsilon = validator.check_number_range('epsilon', epsilon, 0, 1, Rel.INC_RIGHT, self.name)
self.momentum = validator.check_number_range('momentum', momentum, 0, 1, Rel.INC_BOTH, self.name)
self._update_parameter = True
class FusedBatchNormEx(PrimitiveWithInfer):
r"""
FusedBatchNormEx is an extension of FusedBatchNorm, FusedBatchNormEx has one more output(output reserve)
than FusedBatchNorm, reserve will be used in backpropagation phase. FusedBatchNorm is a BatchNorm that
moving mean and moving variance will be computed instead of being loaded.
Batch Normalization is widely used in convolutional networks. This operation applies
Batch Normalization over input to avoid internal covariate shift as described in the
paper `Batch Normalization: Accelerating Deep Network Training by Reducing Internal
Covariate Shift <https://arxiv.org/abs/1502.03167>`_. It rescales and recenters the
feature using a mini-batch of data and the learned parameters which can be described
in the following formula.
.. math::
y = \frac{x - mean}{\sqrt{variance + \epsilon}} * \gamma + \beta
where :math:`\gamma` is scale, :math:`\beta` is bias, :math:`\epsilon` is epsilon.
Args:
mode (int): Mode of batch normalization, value is 0 or 1. Default: 0.
epsilon (float): A small value added for numerical stability. Default: 1e-5.
momentum (float): The hyper parameter to compute moving average for running_mean and running_var
(e.g. :math:`new\_running\_mean = momentum * running\_mean + (1 - momentum) * current\_mean`).
Momentum value should be [0, 1]. Default: 0.9.
Inputs:
- **input_x** (Tensor) - The input of FusedBatchNormEx, Tensor of shape :math:`(N, C)`,
data type: float16 or float32.
- **scale** (Tensor) - Parameter scale, same with gamma above-mentioned, Tensor of shape :math:`(C,)`,
data type: float32.
- **bias** (Tensor) - Parameter bias, same with beta above-mentioned, Tensor of shape :math:`(C,)`,
data type: float32.
- **mean** (Tensor) - mean value, Tensor of shape :math:`(C,)`, data type: float32.
- **variance** (Tensor) - variance value, Tensor of shape :math:`(C,)`, data type: float32.
Outputs:
Tuple of 6 Tensors, the normalized input, the updated parameters and reserve.
- **output_x** (Tensor) - The input of FusedBatchNormEx, same type and shape as the `input_x`.
- **updated_scale** (Tensor) - Updated parameter scale, Tensor of shape :math:`(C,)`, data type: float32.
- **updated_bias** (Tensor) - Updated parameter bias, Tensor of shape :math:`(C,)`, data type: float32.
- **updated_moving_mean** (Tensor) - Updated mean value, Tensor of shape :math:`(C,)`, data type: float32.
- **updated_moving_variance** (Tensor) - Updated variance value, Tensor of shape :math:`(C,)`,
data type: float32.
- **reserve** (Tensor) - reserve space, Tensor of shape :math:`(C,)`, data type: float32.
Examples:
>>> input_x = Tensor(np.ones([128, 64, 32, 64]), mindspore.float32)
>>> scale = Tensor(np.ones([64]), mindspore.float32)
>>> bias = Tensor(np.ones([64]), mindspore.float32)
>>> mean = Tensor(np.ones([64]), mindspore.float32)
>>> variance = Tensor(np.ones([64]), mindspore.float32)
>>> op = P.FusedBatchNormEx()
>>> output = op(input_x, scale, bias, mean, variance)
"""
__mindspore_signature__ = (
sig.make_sig('input_x', dtype=sig.sig_dtype.T2),
sig.make_sig('scale', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('bias', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('mean', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('variance', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
)
@prim_attr_register
def __init__(self, mode=0, epsilon=1e-5, momentum=0.1):
self.init_prim_io_names(inputs=['x', 'scale', 'b', 'mean', 'variance'],
outputs=['y', 'save_scale', 'save_bias', 'save_mean', 'save_inv_variance', 'reserve'])
self.mode = validator.check_integer('mode', mode, [0, 1], Rel.IN, self.name)
self.epsilon = validator.check_number_range('epsilon', epsilon, 0, 1, Rel.INC_RIGHT, self.name)
self.momentum = validator.check_number_range('momentum', momentum, 0, 1, Rel.INC_BOTH, self.name)
self._update_parameter = True
self.add_prim_attr('data_format', "NCHW")
def infer_shape(self, input_x, scale, bias, mean, variance):
validator.check_integer("scale rank", len(scale), 1, Rel.EQ, self.name)
validator.check("scale shape", scale, "bias shape", bias, Rel.EQ, self.name)
validator.check("scale shape[0]", scale[0], "input_x shape[1]", input_x[1], Rel.EQ, self.name)
validator.check_integer("mean rank", len(mean), 1, Rel.EQ, self.name)
validator.check("mean shape", mean, "variance shape", variance, Rel.EQ, self.name)
validator.check("mean shape", mean, "scale shape", scale, Rel.EQ, self.name)
return (input_x, scale, scale, scale, scale, scale)
def infer_dtype(self, input_x, scale, bias, mean, variance):
validator.check_tensor_type_same({"input_x": input_x}, [mstype.float16, mstype.float32], self.name)
args = {"scale": scale, "bias": bias}
validator.check_tensor_type_same(args, [mstype.float32], self.name)
args_moving = {"mean": mean, "variance": variance}
valid_types = [mstype.tensor_type(mstype.float32)]
validator.check_type_same(args_moving, valid_types, self.name)
return (input_x, scale, scale, scale, scale, scale)
class BNTrainingReduce(PrimitiveWithInfer):
"""
reduce sum at axis [0, 2, 3].
Inputs:
- **x** (Tensor) - Tensor of shape :math:`(N, C)`.
Outputs:
- **sum** (Tensor) - Tensor of shape :math:`(C,)`.
- **square_sum** (Tensor) - Tensor of shape :math:`(C,)`.
"""
@prim_attr_register
def __init__(self):
self.init_prim_io_names(inputs=['x'], outputs=['sum', 'square_sum'])
def infer_shape(self, x_shape):
validator.check_integer("x rank", len(x_shape), 4, Rel.EQ, self.name)
return ([x_shape[1]], [x_shape[1]])
def infer_dtype(self, x_type):
return (x_type, x_type)
class BNTrainingUpdate(PrimitiveWithInfer):
"""
The primitive operator of the register and info descriptor in bn_training_update.
"""
@prim_attr_register
def __init__(self, isRef=True, epsilon=1e-5, factor=0.1):
self.init_prim_io_names(inputs=['x', 'sum', 'square_sum', 'scale', 'b', 'mean', 'variance'],
outputs=['y', 'running_mean', 'running_variance', 'save_mean', 'save_inv_variance'])
#self.isRef = validator.check_integer('isRef', isRef, [0, 1], Rel.IN)
self.epsilon = validator.check_number_range('epsilon', epsilon, 0, 1, Rel.INC_RIGHT, 'BNTrainingUpdate')
self.factor = validator.check_number_range('factor', factor, 0, 1, Rel.INC_BOTH, 'BNTrainingUpdate')
def infer_shape(self, x, sum, square_sum, scale, b, mean, variance):
return (x, variance, variance, variance, variance)
def infer_dtype(self, x, sum, square_sum, scale, b, mean, variance):
return (x, variance, variance, variance, variance)
class BatchNorm(PrimitiveWithInfer):
r"""
Batch Normalization for input data and updated parameters.
Batch Normalization is widely used in convolutional neural networks. This operation
applies Batch Normalization over input to avoid internal covariate shift as described
in the paper `Batch Normalization: Accelerating Deep Network Training by Reducing Internal
Covariate Shift <https://arxiv.org/abs/1502.03167>`_. It rescales and recenters the
features using a mini-batch of data and the learned parameters which can be described
in the following formula,
.. math::
y = \frac{x - mean}{\sqrt{variance + \epsilon}} * \gamma + \beta
where :math:`\gamma` is scale, :math:`\beta` is bias, :math:`\epsilon` is epsilon.
Args:
is_training (bool): If `is_training` is True, `mean` and `variance` are computed during training.
If `is_training` is False, they're loaded from checkpoint during inference. Default: False.
epsilon (float): A small value added for numerical stability. Default: 1e-5.
Inputs:
- **input_x** (Tensor) - Tensor of shape :math:`(N, C)`, with float16 or float32 data type.
- **scale** (Tensor) - Tensor of shape :math:`(C,)`, with float16 or float32 data type.
- **bias** (Tensor) - Tensor of shape :math:`(C,)`, has the same data type with `scale`.
- **mean** (Tensor) - Tensor of shape :math:`(C,)`, with float16 or float32 data type.
- **variance** (Tensor) - Tensor of shape :math:`(C,)`, has the same data type with `mean`.
Outputs:
Tuple of 5 Tensor, the normalized inputs and the updated parameters.
- **output_x** (Tensor) - The same type and shape as the input_x. The shape is :math:`(N, C)`.
- **updated_scale** (Tensor) - Tensor of shape :math:`(C,)`.
- **updated_bias** (Tensor) - Tensor of shape :math:`(C,)`.
- **reserve_space_1** (Tensor) - Tensor of shape :math:`(C,)`.
- **reserve_space_2** (Tensor) - Tensor of shape :math:`(C,)`.
Examples:
>>> input_x = Tensor(np.ones([128, 64, 32, 64]), mindspore.float32)
>>> scale = Tensor(np.ones([64]), mindspore.float32)
>>> bias = Tensor(np.ones([64]), mindspore.float32)
>>> mean = Tensor(np.ones([64]), mindspore.float32)
>>> variance = Tensor(np.ones([64]), mindspore.float32)
>>> batch_norm = P.BatchNorm()
>>> output = batch_norm(input_x, scale, bias, mean, variance)
"""
@prim_attr_register
def __init__(self, is_training=False, epsilon=1e-5):
validator.check_value_type('is_training', is_training, (bool,), self.name)
validator.check_number_range('epsilon', epsilon, 0, 1, Rel.INC_RIGHT, self.name)
self.add_prim_attr('data_format', "NCHW")
self.init_prim_io_names(inputs=['x', 'scale', 'offset', 'mean', 'variance'],
outputs=['y', 'batch_mean', 'batch_variance', 'reserve_space_1', 'reserve_space_2'])
def infer_shape(self, input_x, scale, bias, mean, variance):
validator.check_integer("scale rank", len(scale), 1, Rel.EQ, self.name)
validator.check("scale shape", scale, "bias shape", bias, Rel.EQ, self.name)
validator.check("scale shape[0]", scale[0], "input_x shape[1]", input_x[1], Rel.EQ, self.name)
if not self.is_training:
validator.check_integer("mean rank", len(mean), 1, Rel.EQ, self.name)
validator.check("mean shape", mean, "variance shape", variance, Rel.EQ, self.name)
validator.check("mean shape", mean, "scale shape", scale, Rel.EQ, self.name)
return (input_x, scale, scale, scale, scale)
def infer_dtype(self, input_x, scale, bias, mean, variance):
validator.check_tensor_type_same({"input_x": input_x}, [mstype.float16, mstype.float32], self.name)
args = {"scale": scale, "bias": bias}
validator.check_tensor_type_same(args, [mstype.float16, mstype.float32], self.name)
args_moving = {"mean": mean, "variance": variance}
if self.is_training:
valid_types = [mstype.tensor_type(mstype.float16), mstype.tensor_type(mstype.float32), None]
validator.check_type_same(args_moving, valid_types, self.name)
else:
args_moving = {"mean": mean, "variance": variance}
validator.check_tensor_type_same(args_moving, [mstype.float16, mstype.float32], self.name)
return (input_x, scale, bias, input_x, input_x)
class Conv2D(PrimitiveWithInfer):
r"""
2D convolution layer.
Applies a 2D convolution over an input tensor which is typically of shape :math:`(N, C_{in}, H_{in}, W_{in})`,
where :math:`N` is batch size and :math:`C_{in}` is channel number. For each batch of shape
:math:`(C_{in}, H_{in}, W_{in})`, the formula is defined as:
.. math::
out_j = \sum_{i=0}^{C_{in} - 1} ccor(W_{ij}, X_i) + b_j,
where :math:`ccor` is the cross correlation operator, :math:`C_{in}` is the input channel number, :math:`j` ranges
from :math:`0` to :math:`C_{out} - 1`, :math:`W_{ij}` corresponds to the :math:`i`-th channel of the :math:`j`-th
filter and :math:`out_{j}` corresponds to the :math:`j`-th channel of the output. :math:`W_{ij}` is a slice
of kernel and it has shape :math:`(\text{ks_h}, \text{ks_w})`, where :math:`\text{ks_h}` and
:math:`\text{ks_w}` are the height and width of the convolution kernel. The full kernel has shape
:math:`(C_{out}, C_{in} // \text{group}, \text{ks_h}, \text{ks_w})`, where group is the group number
to split the input in the channel dimension.
If the 'pad_mode' is set to be "valid", the output height and width will be
:math:`\left \lfloor{1 + \frac{H_{in} + 2 \times \text{padding} - \text{ks_h} -
(\text{ks_h} - 1) \times (\text{dilation} - 1) }{\text{stride}}} \right \rfloor` and
:math:`\left \lfloor{1 + \frac{W_{in} + 2 \times \text{padding} - \text{ks_w} -
(\text{ks_w} - 1) \times (\text{dilation} - 1) }{\text{stride}}} \right \rfloor` respectively.
The first introduction can be found in paper `Gradient Based Learning Applied to Document Recognition
<http://vision.stanford.edu/cs598_spring07/papers/Lecun98.pdf>`_. More detailed introduction can be found here:
http://cs231n.github.io/convolutional-networks/.
Args:
out_channel (int): The dimension of the output.
kernel_size (Union[int, tuple[int]]): The kernel size of the 2D convolution.
mode (int): Modes for different convolutions. 0 Math convolutiuon, 1 cross-correlation convolution ,
2 deconvolution, 3 depthwise convolution. Default: 1.
pad_mode (str): Modes to fill padding. It could be "valid", "same", or "pad". Default: "valid".
pad (Union(int, tuple[int])): The pad value to be filled. Default: 0. If `pad` is an integer, the paddings of
top, bottom, left and right are the same, equal to pad. If `pad` is a tuple of four integers, the
padding of top, bottom, left and right equal to pad[0], pad[1], pad[2], and pad[3] correspondingly.
stride (Union(int, tuple[int])): The stride to be applied to the convolution filter. Default: 1.
dilation (Union(int, tuple[int])): Specify the space to use between kernel elements. Default: 1.
group (int): Split input into groups. Default: 1.
Returns:
Tensor, the value that applied 2D convolution.
Inputs:
- **input** (Tensor) - Tensor of shape :math:`(N, C_{in}, H_{in}, W_{in})`.
- **weight** (Tensor) - Set size of kernel is :math:`(K_1, K_2)`, then the shape is
:math:`(C_{out}, C_{in}, K_1, K_2)`.
Outputs:
Tensor of shape :math:`(N, C_{out}, H_{out}, W_{out})`.
Examples:
>>> input = Tensor(np.ones([10, 32, 32, 32]), mindspore.float32)
>>> weight = Tensor(np.ones([32, 32, 3, 3]), mindspore.float32)
>>> conv2d = P.Conv2D(out_channel=32, kernel_size=3)
>>> conv2d(input, weight)
"""
@prim_attr_register
def __init__(self,
out_channel,
kernel_size,
mode=1,
pad_mode="valid",
pad=0,
stride=1,
dilation=1,
group=1):
"""init Conv2D"""
self.init_prim_io_names(inputs=['x', 'w'], outputs=['output'])
self.kernel_size = _check_positive_int_or_tuple('kernel_size', kernel_size, self.name)
self.stride = _check_positive_int_or_tuple('stride', stride, self.name, allow_four=True, ret_four=True)
self.add_prim_attr('stride', self.stride)
self.dilation = _check_positive_int_or_tuple('dilation', dilation, self.name, allow_four=True, ret_four=True)
self.add_prim_attr('dilation', self.dilation)
validator.check_value_type('pad', pad, (int, tuple), self.name)
if isinstance(pad, int):
pad = (pad,) * 4
else:
validator.check_integer('pad size', len(pad), 4, Rel.EQ, self.name)
self.padding = pad
self.pad_mode = validator.check_string('pad_mode', pad_mode, ['valid', 'same', 'pad'], self.name)
if pad_mode != 'pad' and pad != (0, 0, 0, 0):
raise ValueError(f"For '{self.name}', padding must be zero when pad_mode is '{pad_mode}'.")
if self.pad_mode == 'pad':
for item in pad:
validator.check_integer('pad item', item, 0, Rel.GE, self.name)
self.mode = validator.check_integer('mode', mode, 1, Rel.EQ, self.name)
self.add_prim_attr('data_format', "NCHW")
self.out_channel = validator.check_integer('out_channel', out_channel, 0, Rel.GT, self.name)
self.group = validator.check_integer('group', group, 0, Rel.GT, self.name)
self.add_prim_attr('offset_a', 0)
def infer_shape(self, x_shape, w_shape, b_shape=None):
validator.check_integer("weight rank", len(w_shape), 4, Rel.EQ, self.name)
validator.check_integer("x rank", len(x_shape), 4, Rel.EQ, self.name)
validator.check(f"x_shape[1] / group", x_shape[1] // self.group, "w_shape[1]", w_shape[1], Rel.EQ, self.name)
validator.check('out_channel', self.out_channel, 'w_shape[0]', w_shape[0], Rel.EQ, self.name)
validator.check('kernel_size', self.kernel_size, 'w_shape[2:4]', tuple(w_shape[2:4]), Rel.EQ, self.name)
kernel_size_h = w_shape[2]
kernel_size_w = w_shape[3]
stride_h = self.stride[2]
stride_w = self.stride[3]
dilation_h = self.dilation[2]
dilation_w = self.dilation[3]
if self.pad_mode == "valid":
h_out = math.ceil((x_shape[2] - dilation_h * (kernel_size_h - 1)) / stride_h)
w_out = math.ceil((x_shape[3] - dilation_w * (kernel_size_w - 1)) / stride_w)
pad_top, pad_bottom, pad_left, pad_right = 0, 0, 0, 0
elif self.pad_mode == "same":
h_out = math.ceil(x_shape[2] / stride_h)
w_out = math.ceil(x_shape[3] / stride_w)
pad_needed_h = max(0, (h_out - 1) * stride_h + dilation_h * (kernel_size_h - 1) + 1 - x_shape[2])
pad_top = math.floor(pad_needed_h / 2)
pad_bottom = pad_needed_h - pad_top
pad_needed_w = max(0, (w_out - 1) * stride_w + dilation_w * (kernel_size_w - 1) + 1 - x_shape[3])
pad_left = math.floor(pad_needed_w / 2)
pad_right = pad_needed_w - pad_left
elif self.pad_mode == 'pad':
pad_top, pad_bottom, pad_left, pad_right = self.padding
h_out = 1 + (x_shape[2] + pad_top + pad_bottom - kernel_size_h - (kernel_size_h - 1) * (dilation_h - 1)) \
/ stride_h
w_out = 1 + (x_shape[3] + pad_left + pad_right - kernel_size_w - (kernel_size_w - 1) * (dilation_w - 1)) \
/ stride_w
h_out = math.floor(h_out)
w_out = math.floor(w_out)
self.pad_list = [pad_top, pad_bottom, pad_left, pad_right]
self.add_prim_attr('pad_list', (pad_top, pad_bottom, pad_left, pad_right))
out_channel = self.out_channel
out_shape = [x_shape[0], out_channel, h_out, w_out]
return out_shape
def infer_dtype(self, x_dtype, w_dtype, b_dtype=None):
args = {'x': x_dtype, 'w': w_dtype}
valid_types = [mstype.int8, mstype.int32, mstype.float16, mstype.float32]
validator.check_tensor_type_same(args, valid_types, self.name)
if x_dtype.element_type() == mstype.int8:
return mstype.tensor_type(mstype.int32)
return x_dtype
class DepthwiseConv2dNative(PrimitiveWithInfer):
r"""
Returns the depth-wise convolution value for the input.
Applies depthwise conv2d for the input, which will generate more channels with channel_multiplier.
Given an input tensor of shape :math:`(N, C_{in}, H_{in}, W_{in})` where :math:`N` is the batch size and a
filter tensor with kernel size :math:`(ks_{h}, ks_{w})`, containing :math:`C_{in} * \text{channel_multiplier}`
convolutional filters of depth 1; it applies different filters to each input channel (channel_multiplier channels
for each input channel has the default value 1), then concatenates the results together. The output has
:math:`\text{in_channels} * \text{channel_multiplier}` channels.
Args:
channel_multiplier (int): The multipiler for the original output convolution. Its value must be greater than 0.
kernel_size (Union[int, tuple[int]]): The size of the convolution kernel.
mode (int): Modes for different convolutions. 0 Math convolution, 1 cross-correlation convolution ,
2 deconvolution, 3 depthwise convolution. Default: 3.
pad_mode (str): Modes to fill padding. It could be "valid", "same", or "pad". Default: "valid".
pad (Union[int, tuple[int]]): The pad value to be filled. If `pad` is an integer, the paddings of
top, bottom, left and right are the same, equal to pad. If `pad` is a tuple of four integers, the padding
of top, bottom, left and right equal to pad[0], pad[1], pad[2], and pad[3] correspondingly. Default: 0.
stride (Union[int, tuple[int]]): The stride to be applied to the convolution filter. Default: 1.
dilation (Union[int, tuple[int]]): Specifies the dilation rate to be used for the dilated convolution.
Default: 1.
group (int): Splits input into groups. Default: 1.
Inputs:
- **input** (Tensor) - Tensor of shape :math:`(N, C_{in}, H_{in}, W_{in})`.
- **weight** (Tensor) - Set the size of kernel as :math:`(K_1, K_2)`, then the shape is
:math:`(K, C_{in}, K_1, K_2)`, `K` must be 1.
Outputs:
Tensor of shape :math:`(N, C_{in} * \text{channel_multiplier}, H_{out}, W_{out})`.
Examples:
>>> input = Tensor(np.ones([10, 32, 32, 32]), mindspore.float32)
>>> weight = Tensor(np.ones([1, 32, 3, 3]), mindspore.float32)
>>> depthwise_conv2d = P.DepthwiseConv2dNative(channel_multiplier = 3, kernel_size = (3, 3))
>>> output = depthwise_conv2d(input, weight)
>>> output.shape == (10, 96, 30, 30)
"""
@prim_attr_register
def __init__(self,
channel_multiplier,
kernel_size,
mode=3,
pad_mode="valid",
pad=0,
stride=1,
dilation=1,
group=1):
"""init DepthwiseConv2dNative"""
self.init_prim_io_names(inputs=['x', 'w'], outputs=['output'])
self.kernel_size = _check_positive_int_or_tuple('kernel_size', kernel_size, self.name)
self.stride = _check_positive_int_or_tuple('stride', stride, self.name)
if self.stride[0] != self.stride[1]:
raise ValueError("The height and width of stride should be equal,"
f"but got height:{self.stride[0]}, width:{self.stride[1]}")
self.add_prim_attr('stride', (1, 1, self.stride[0], self.stride[1]))
self.dilation = _check_positive_int_or_tuple('dilation', dilation, self.name)
if self.dilation[0] != self.dilation[1]:
raise ValueError("The height and width of dilation should be equal,"
f"but got height:{self.dilation[0]}, width:{self.dilation[1]}")
self.add_prim_attr('dilation', (1, 1, self.dilation[0], self.dilation[1]))
validator.check_value_type('pad', pad, (int, tuple), self.name)
if isinstance(pad, int):
pad = (pad,) * 4
else:
validator.check_integer('pad size', len(pad), 4, Rel.EQ, self.name)
self.padding = pad
self.pad_mode = validator.check_string('pad_mode', pad_mode, ['valid', 'same', 'pad'], self.name)
if pad_mode != 'pad' and pad != (0, 0, 0, 0):
raise ValueError(f"For '{self.name}', padding must be zero when pad_mode is '{pad_mode}'.")
if self.pad_mode == 'pad':
for item in pad:
validator.check_integer('pad item', item, 0, Rel.GE, self.name)
self.mode = validator.check_integer("mode", mode, 3, Rel.EQ, self.name)
self.add_prim_attr('data_format', "NCHW")
self.channel_multiplier = validator.check_integer("channel_multiplier", channel_multiplier, 0, Rel.GT,
self.name)
self.group = validator.check_integer("group", group, 0, Rel.GT, self.name)
self.add_prim_attr('offset_a', 0)
def infer_shape(self, x_shape, w_shape, b_shape=None):
validator.check_integer("weight rank", len(w_shape), 4, Rel.EQ, self.name)
validator.check_integer("x rank", len(x_shape), 4, Rel.EQ, self.name)
validator.check("x_shape[1]", x_shape[1], "w_shape[1]", w_shape[1], Rel.EQ, self.name)
validator.check('kernel_size', self.kernel_size, 'w_shape[2:4]', tuple(w_shape[2:4]), Rel.EQ, self.name)
kernel_size_n, _, kernel_size_h, kernel_size_w = w_shape
_, _, stride_h, stride_w = self.stride
_, _, dilation_h, dilation_w = self.dilation
if kernel_size_n != 1:
raise ValueError(f"The batch of input weight should be 1, but got {kernel_size_n}")
if self.pad_mode == "valid":
h_out = math.ceil((x_shape[2] - dilation_h * (kernel_size_h - 1)) / stride_h)
w_out = math.ceil((x_shape[3] - dilation_w * (kernel_size_w - 1)) / stride_w)
pad_top, pad_bottom, pad_left, pad_right = 0, 0, 0, 0
elif self.pad_mode == "same":
h_out = math.ceil(x_shape[2] / stride_h)
w_out = math.ceil(x_shape[3] / stride_w)
pad_needed_h = max(0, (h_out - 1) * stride_h + dilation_h * (kernel_size_h - 1) + 1 - x_shape[2])
pad_top = math.floor(pad_needed_h / 2)
pad_bottom = pad_needed_h - pad_top
pad_needed_w = max(0, (w_out - 1) * stride_w + dilation_w * (kernel_size_w - 1) + 1 - x_shape[3])
pad_left = math.floor(pad_needed_w / 2)
pad_right = pad_needed_w - pad_left
elif self.pad_mode == 'pad':
pad_top, pad_bottom, pad_left, pad_right = self.padding
h_out = 1 + (x_shape[2] + pad_top + pad_bottom - kernel_size_h - (kernel_size_h - 1) * (dilation_h - 1)) \
/ stride_h
w_out = 1 + (x_shape[3] + pad_left + pad_right - kernel_size_w - (kernel_size_w - 1) * (dilation_w - 1)) \
/ stride_w
h_out = math.floor(h_out)
w_out = math.floor(w_out)
self.pad_list = (pad_top, pad_bottom, pad_left, pad_right)
self.add_prim_attr('pads', self.pad_list)
out_channel = self.channel_multiplier * x_shape[1]
out_shape = [x_shape[0], out_channel, h_out, w_out]
return out_shape
def infer_dtype(self, x_dtype, w_dtype, b_dtype=None):
args = {'x': x_dtype, 'w': w_dtype}
validator.check_tensor_type_same(args, mstype.number_type, self.name)
if x_dtype.element_type() == mstype.int8:
return mstype.tensor_type(mstype.int32)
return x_dtype
class _Pool(PrimitiveWithInfer):
r"""
Performs max/avg pooling operation.
Args:
ksize (Union[int, tuple[int]]): The size of the kernel, that should be a tuple
of two `int` for height and width. Default: 1.
strides (Union[int, tuple[int]]): The stride of the window, that should be
a tuple of two `int` for height and width. Default: 1.
padding (str): The optional value for pad mode, is "same" or "valid", not case sensitive.
Default: "valid".
"""
@prim_attr_register
def __init__(self, ksize=1, strides=1, padding="valid"):
self.init_prim_io_names(inputs=['x'], outputs=['output'])
validator.check_value_type('ksize', ksize, [int, tuple], self.name)
validator.check_value_type('strides', strides, [int, tuple], self.name)
self.padding = validator.check_string('padding', padding.upper(), ['VALID', 'SAME'], self.name)
self.add_prim_attr("padding", self.padding)
self.is_maxpoolwithargmax = (self.name == "MaxPoolWithArgmax")
if not self.is_maxpoolwithargmax:
self.add_prim_attr('data_format', "NCHW")
self.ksize = _check_positive_int_or_tuple("ksize", ksize, self.name, allow_four=False, ret_four=True)
if self.is_maxpoolwithargmax:
self.ksize = (1, self.ksize[-2], self.ksize[-1], 1)
self.add_prim_attr("ksize", self.ksize)
self.strides = _check_positive_int_or_tuple("strides", strides, self.name, allow_four=False, ret_four=True)
if self.is_maxpoolwithargmax:
self.strides = (1, self.strides[-2], self.strides[-1], 1)
self.add_prim_attr("strides", self.strides)
def infer_shape(self, x_shape):
validator.check_integer("x rank", len(x_shape), 4, Rel.EQ, self.name)
batch, channel, input_h, input_w = x_shape
if self.is_maxpoolwithargmax:
_, kernel_h, kernel_w, _ = self.ksize
_, stride_h, stride_w, _ = self.strides
else:
_, _, kernel_h, kernel_w = self.ksize
_, _, stride_h, stride_w = self.strides
if self.padding == "VALID":
out_h = math.ceil((input_h - (kernel_h - 1)) / stride_h)
out_w = math.ceil((input_w - (kernel_w - 1)) / stride_w)
elif self.padding == "SAME":
out_h = math.ceil(input_h / stride_h)
out_w = math.ceil(input_w / stride_w)
out_shape = [batch, channel, out_h, out_w]
for shape_value in out_shape:
if shape_value <= 0:
raise ValueError(f"For '{self.name}' The kernel size is not valid, "
f"please check it if is larger than data's shape size.")
return out_shape
def infer_dtype(self, x_dtype):
validator.check_subclass("input", x_dtype, mstype.tensor, self.name)
return x_dtype
class MaxPool(_Pool):
r"""
Max pooling operation.
Applies a 2D max pooling over an input Tensor which can be regarded as a composition of 2D planes.
Typically the input is of shape :math:`(N_{in}, C_{in}, H_{in}, W_{in})`, MaxPool outputs
regional maximum in the :math:`(H_{in}, W_{in})`-dimension. Given kernel size
:math:`ks = (h_{ker}, w_{ker})` and stride :math:`s = (s_0, s_1)`, the operation is as follows.
.. math::
\text{output}(N_i, C_j, h, w) = \max_{m=0, \ldots, h_{ker}-1} \max_{n=0, \ldots, w_{ker}-1}
\text{input}(N_i, C_j, s_0 \times h + m, s_1 \times w + n)
Args:
ksize (Union[int, tuple[int]]): The size of kernel used to take the maximum value,
is an int number that represents height and width are both ksize, or a tuple
of two int numbers that represent height and width respectively. Default: 1.
strides (Union[int, tuple[int]]): The distance of kernel moving, an int number that represents
the height and width of movement are both strides, or a tuple of two int numbers that
represent height and width of movement respectively. Default: 1.
padding (str): The optional value for pad mode, is "same" or "valid", not case sensitive.
Default: "valid".
- same: Adopts the way of completion. The height and width of the output will be the same as
the input. The total number of padding will be calculated in horizontal and vertical
directions and evenly distributed to top and bottom, left and right if possible.
Otherwise, the last extra padding will be done from the bottom and the right side.
- valid: Adopts the way of discarding. The possible largest height and width of output
will be returned without padding. Extra pixels will be discarded.
Inputs:
- **input** (Tensor) - Tensor of shape :math:`(N, C_{in}, H_{in}, W_{in})`.
Outputs:
Tensor, with shape :math:`(N, C_{out}, H_{out}, W_{out})`.
Examples:
>>> input_tensor = Tensor(np.arange(1 * 3 * 3 * 4).reshape((1, 3, 3, 4)), mindspore.float32)
>>> maxpool_op = P.MaxPool(padding="VALID", ksize=2, strides=1)
>>> output_tensor = maxpool_op(input_tensor)
"""
@prim_attr_register
def __init__(self, ksize=1, strides=1, padding="valid"):
super(MaxPool, self).__init__(ksize, strides, padding)
class MaxPoolWithArgmax(_Pool):
r"""
Performs max pooling on the input Tensor and return both max values and indices.
Typically the input is of shape :math:`(N_{in}, C_{in}, H_{in}, W_{in})`, MaxPool outputs
regional maximum in the :math:`(H_{in}, W_{in})`-dimension. Given kernel size
:math:`ks = (h_{ker}, w_{ker})` and stride :math:`s = (s_0, s_1)`, the operation is as follows.
.. math::
\text{output}(N_i, C_j, h, w) = \max_{m=0, \ldots, h_{ker}-1} \max_{n=0, \ldots, w_{ker}-1}
\text{input}(N_i, C_j, s_0 \times h + m, s_1 \times w + n)
Args:
ksize (Union[int, tuple[int]]): The size of kernel used to take the maximum value and arg value,
is an int number that represents height and width are both ksize, or a tuple of
two int numbers that represent height and width respectively. Default: 1.
strides (Union[int, tuple[int]]): The distance of kernel moving, an int number that represents
the height and width of movement are both strides, or a tuple of two int numbers that
represent height and width of movement respectively. Default: 1.
padding (str): The optional value for pad mode, is "same" or "valid", not case sensitive.
Default: "valid".
- same: Adopts the way of completion. The height and width of the output will be the same as
the input. The total number of padding will be calculated in horizontal and vertical
directions and evenly distributed to top and bottom, left and right if possible.
Otherwise, the last extra padding will be done from the bottom and the right side.
- valid: Adopts the way of discarding. The possible largest height and width of output
will be returned without padding. Extra pixels will be discarded.
Inputs:
- **input** (Tensor) - Tensor of shape :math:`(N, C_{in}, H_{in}, W_{in})`.
Data type should be float16 or float32.
Outputs:
Tuple of 2 Tensor, the maxpool result and where max values from.
- **output** (Tensor) - Maxpooling result, with shape :math:`(N, C_{out}, H_{out}, W_{out})`.
- **mask** (Tensor) - Max values' index represented by the mask.
Examples:
>>> input_tensor = Tensor(np.arange(1 * 3 * 3 * 4).reshape((1, 3, 3, 4)), mindspore.float32)
>>> maxpool_arg_op = P.MaxPoolWithArgmax(padding="VALID", ksize=2, strides=1)
>>> output_tensor, argmax = maxpool_arg_op(input_tensor)
"""
def __init__(self, ksize=1, strides=1, padding="valid"):
super(MaxPoolWithArgmax, self).__init__(ksize, strides, padding)
self.is_tbe = context.get_context("device_target") == "Ascend"
self.is_gpu = context.get_context("device_target") == "GPU"
def infer_shape(self, x_shape):
out_shape = _Pool.infer_shape(self, x_shape)
_, _, out_h, out_w = out_shape
_, kernel_h, kernel_w, _ = self.ksize
argmax_shape = []
if self.is_tbe:
for i in range(4):
if i == 2:
dim = kernel_h * kernel_w
argmax_shape.append(dim)
elif i == 3:
dim = math.ceil(out_h * out_w / 16) + 1
argmax_shape.append(dim)
else:
argmax_shape.append(x_shape[i])
else:
argmax_shape = out_shape
return out_shape, argmax_shape
def infer_dtype(self, x_dtype):
out_dtype = x_dtype
validator.check_tensor_type_same({"x": x_dtype}, (mstype.float16, mstype.float32), self.name)
argmax_dtype = mstype.uint16
if self.is_gpu:
argmax_dtype = mstype.int32
return out_dtype, argmax_dtype
class AvgPool(_Pool):
r"""
Average pooling operation.
Applies a 2D average pooling over an input Tensor which can be regarded as a composition of 2D input planes.
Typically the input is of shape :math:`(N_{in}, C_{in}, H_{in}, W_{in})`, AvgPool2d outputs
regional average in the :math:`(H_{in}, W_{in})`-dimension. Given kernel size
:math:`ks = (h_{ker}, w_{ker})` and stride :math:`s = (s_0, s_1)`, the operation is as follows.
.. math::
\text{output}(N_i, C_j, h, w) = \frac{1}{h_{ker} * w_{ker}} \sum_{m=0}^{h_{ker}-1} \sum_{n=0}^{w_{ker}-1}
\text{input}(N_i, C_j, s_0 \times h + m, s_1 \times w + n)
Args:
ksize (Union[int, tuple[int]]): The size of kernel used to take the average value,
is an int number that represents height and width are both ksize, or a tuple
of two int numbers that represent height and width respectively. Default: 1.
strides (Union[int, tuple[int]]): The distance of kernel moving, an int number that represents
the height and width of movement are both strides, or a tuple of two int numbers that
represent height and width of movement respectively. Default: 1.
padding (str): The optional value for pad mode, is "same" or "valid", not case sensitive.
Default: "valid".
- same: Adopts the way of completion. The height and width of the output will be the same as
the input. The total number of padding will be calculated in horizontal and vertical
directions and evenly distributed to top and bottom, left and right if possible.
Otherwise, the last extra padding will be done from the bottom and the right side.
- valid: Adopts the way of discarding. The possible largest height and width of output
will be returned without padding. Extra pixels will be discarded.
Inputs:
- **input** (Tensor) - Tensor of shape :math:`(N, C_{in}, H_{in}, W_{in})`.
Outputs:
Tensor, with shape :math:`(N, C_{out}, H_{out}, W_{out})`.
Examples:
>>> import mindspore
>>> import mindspore.nn as nn
>>> import numpy as np
>>> from mindspore import Tensor
>>> from mindspore.ops import operations as P
>>> class Net(nn.Cell):
>>> def __init__(self):
>>> super(Net, self).__init__()
>>> self.avgpool_op = P.AvgPool(padding="VALID", ksize=2, strides=1)
>>>
>>> def construct(self, x):
>>> result = self.avgpool_op(x)
>>> return result
>>>
|
[ 6.5 7.5 8.5]]
[[ 14.5 15.5 16.5]
[ 18.5 19.5 20.5]]
[[ 26.5 27.5 28.5]
[ 30.5 31.5 32.5]]]]
"""
@prim_attr_register
def __init__(self, ksize=1, strides=1, padding="valid"):
if context.get_context("device_target") == "GPU":
self.target = "GPU"
elif context.get_context("enable_ge"):
self.target = "GE"
else:
self.target = "OTHER"
super(AvgPool, self).__init__(ksize, strides, padding)
class Conv2DBackpropInput(PrimitiveWithInfer):
"""
Computes the gradients of convolution with respect to the input.
Args:
out_channel (int): The dimensionality of the output space.
kernel_size (Union[int, tuple[int]]): The size of the convolution window.
pad_mode (str): Modes to fill padding. It could be "valid", "same", or "pad". Default: "valid".
pad (Union[int, tuple[int]]): The pad value to be filled. Default: 0. If `pad` is an integer, the paddings of
top, bottom, left and right are the same, equal to pad. If `pad` is a tuple of four integers, the
padding of top, bottom, left and right equal to pad[0], pad[1], pad[2], and pad[3] correspondingly.
mode (int): Modes for different convolutions. 0 Math convolutiuon, 1 cross-correlation convolution ,
2 deconvolution, 3 depthwise convolution. Default: 1.
stride (Union[int. tuple[int]]): The stride to be applied to the convolution filter. Default: 1.
dilation (Union[int. tuple[int]]): Specifies the dilation rate to be used for the dilated convolution.
Default: 1.
group (int): Splits input into groups. Default: 1.
Returns:
Tensor, the gradients of convolution.
Examples:
>>> dout = Tensor(np.ones([10, 32, 30, 30]), mindspore.float32)
>>> weight = Tensor(np.ones([32, 32, 3, 3]), mindspore.float32)
>>> x = Tensor(np.ones([10, 32, 32, 32]))
>>> conv2d_backprop_input = P.Conv2DBackpropInput(out_channel=32, kernel_size=3)
>>> conv2d_backprop_input(dout, weight, F.shape(x))
"""
@prim_attr_register
def __init__(self,
out_channel,
kernel_size,
pad_mode="valid",
pad=0,
pad_list=None,
mode=1,
stride=1,
dilation=1,
group=1):
"""init Conv2DBackpropInput"""
self.init_prim_io_names(inputs=['out_backprop', 'filter', 'input_sizes'], outputs=['output'])
self.out_channel = validator.check_integer('out_channel', out_channel, 0, Rel.GT, self.name)
self.kernel_size = _check_positive_int_or_tuple('kernel_size', kernel_size, self.name)
self.stride = _check_positive_int_or_tuple('stride', stride, self.name, allow_four=True, ret_four=False)
self.add_prim_attr('stride', self.stride)
self.dilation = _check_positive_int_or_tuple('dilation', dilation, self.name, allow_four=True, ret_four=True)
self.add_prim_attr('dilation', self.dilation)
validator.check_value_type('pad', pad, (int, tuple), self.name)
if isinstance(pad, int):
pad = (pad,) * 4
else:
validator.check_integer('pad size', len(pad), 4, Rel.EQ, self.name)
self.padding = pad
self.pad_mode = validator.check_string('pad_mode', pad_mode, ['valid', 'same', 'pad'], self.name)
if pad_mode != 'pad' and pad != (0, 0, 0, 0):
raise ValueError(f"For '{self.name}', padding must be zero when pad_mode is '{pad_mode}'.")
if self.pad_mode == 'pad':
for item in pad:
validator.check_integer('pad item', item, 0, Rel.GE, self.name)
pad_mode = pad_mode.upper()
self.add_prim_attr('pad_mode', pad_mode)
self.mode = validator.check_integer('mode', mode, 1, Rel.EQ, self.name)
self.group = validator.check_integer('group', group, 0, Rel.GT, self.name)
self.add_prim_attr('data_format', "NCHW")
if pad_list:
for x in pad_list:
validator.check_integer('element of pad_list', x, 0, Rel.GE, self.name)
self.pad_list = pad_list
def __infer__(self, doutput, w, x_size):
x_size_v = x_size['value']
validator.check_value_type('x_size', x_size_v, [tuple], self.name)
for i, dim_len in enumerate(x_size_v):
validator.check_value_type("x_size[%d]" % i, dim_len, [int], self.name)
args = {'doutput': doutput['dtype'], 'w': w['dtype']}
valid_types = [mstype.int8, mstype.int32, mstype.float16, mstype.float32]
validator.check_tensor_type_same(args, valid_types, self.name)
# infer shape
dout_shape = doutput['shape']
kernel_h = self.kernel_size[0]
kernel_w = self.kernel_size[1]
stride_h = self.stride[0]
stride_w = self.stride[1]
dilation_h = self.dilation[2]
dilation_w = self.dilation[3]
# default pad mode is valid
pad_list = (0, 0, 0, 0)
if self.pad_list:
pad_list = tuple(self.pad_list)
elif self.pad_mode == "SAME":
pad_needed_h = max(0, (dout_shape[2] - 1) * stride_h + dilation_h * (kernel_h - 1) + 1 - x_size_v[2])
pad_top = math.floor(pad_needed_h / 2)
pad_bottom = pad_needed_h - pad_top
pad_needed_w = max(0, (dout_shape[3] - 1) * stride_w + dilation_w * (kernel_w - 1) + 1 - x_size_v[3])
pad_left = math.floor(pad_needed_w / 2)
pad_right = pad_needed_w - pad_left
pad_list = (pad_top, pad_bottom, pad_left, pad_right)
elif self.pad_mode == 'PAD':
pad_list = self.padding
self.add_prim_attr('pad_list', pad_list)
out = {
'value': None,
'shape': x_size_v,
'dtype': doutput['dtype'],
}
return out
class BiasAdd(PrimitiveWithInfer):
r"""
Returns sum of input and bias tensor.
Adds the 1-D bias tensor to the input tensor, and broadcasts the shape on all axis
except for the channel axis.
Inputs:
- **input_x** (Tensor) - The input tensor. The shape can be 2-4 dimensions.
- **bias** (Tensor) - The bias tensor, with shape :math:`(C)`.
The shape of `bias` must be the same as `input_x` in the second dimension.
Outputs:
Tensor, with the same shape and type as `input_x`.
Examples:
>>> input_x = Tensor(np.arange(6).reshape((2, 3)), mindspore.float32)
>>> bias = Tensor(np.random.random(3).reshape((3,)), mindspore.float32)
>>> bias_add = P.BiasAdd()
>>> bias_add(input_x, bias)
"""
@prim_attr_register
def __init__(self):
self.init_prim_io_names(inputs=['x', 'b'], outputs=['output'])
self.add_prim_attr('data_format', 'NCHW')
def infer_shape(self, x_shape, b_shape):
validator.check_integer("x rank", len(x_shape), 2, Rel.GE, self.name)
validator.check_integer("bias rank", len(b_shape), 1, Rel.EQ, self.name)
validator.check("b_shape[0]", b_shape[0], "x_shape[1]", x_shape[1], Rel.EQ, self.name)
return x_shape
def infer_dtype(self, x_type, b_type):
args = {"input_x": x_type, "bias": b_type}
validator.check_tensor_type_same(args, mstype.number_type, self.name)
return x_type
class TopK(PrimitiveWithInfer):
"""
Finds values and indices of the `k` largest entries along the last dimension.
Args:
sorted (bool): If true, the resulting elements will
be sorted by the values in descending order. Default: False.
Inputs:
- **input_x** (Tensor) - Input to be computed, data type should be float16, float32 or int32.
- **k** (int) - Number of top elements to be computed along the last dimension, constant input is needed.
Outputs:
Tuple of 2 Tensor, the values and the indices.
- **values** (Tensor) - The `k` largest elements along each last dimensional slice.
- **indices** (Tensor) - The indices of values within the last dimension of input.
Examples:
>>> topk = P.TopK(sorted=True)
>>> input_x = Tensor([1, 2, 3, 4, 5], mindspore.float16)
>>> k = 3
>>> values, indices = topk(input_x, k)
>>> assert values == Tensor(np.array([5, 4, 3]), mstype.float16)
>>> assert indices == Tensor(np.array([4, 3, 2]), mstype.int32)
"""
@prim_attr_register
def __init__(self, sorted=False):
validator.check_value_type("sorted", sorted, [bool], self.name)
self.init_prim_io_names(inputs=['input', 'k'],
outputs=['values', 'indices'])
def __infer__(self, input_x, k):
x_dtype = input_x['dtype']
valid_types = (mstype.int32, mstype.float16, mstype.float32)
validator.check_tensor_type_same({'x': x_dtype}, valid_types, self.name)
k_v = k['value']
validator.check_value_type('k', k_v, (int,), self.name)
x_shape = list(input_x['shape'])
ndim = len(x_shape) - 1
x_shape[ndim] = k_v
return {'shape': (x_shape, x_shape),
'dtype': (x_dtype, mstype.int32),
'value': None}
class SoftmaxCrossEntropyWithLogits(PrimitiveWithInfer):
r"""
Gets the softmax cross-entropy value between logits and labels which shoule be one-hot encoding.
Note:
Sets input logits as `X`, input label as `Y`, output as `loss`. Then,
.. math::
p_{ij} = softmax(X_{ij}) = \frac{exp(x_i)}{\sum_{j = 0}^{N-1}\exp(x_j)}
.. math::
loss_{ij} = -\sum_j{Y_{ij} * ln(p_{ij})}
Inputs:
- **logits** (Tensor) - Input logits, with shape :math:`(N, C)`. Data type should be float16 or float32.
- **labels** (Tensor) - Ground truth labels, with shape :math:`(N, C)`, has the same data type with `logits`.
Outputs:
Tuple of 2 Tensor, the loss shape is `(N,)`, and the dlogits with the same shape as `logits`.
Examples:
>>> logits = Tensor([[2, 4, 1, 4, 5], [2, 1, 2, 4, 3]], mindspore.float32)
>>> labels = Tensor([[0, 0, 0, 0, 1], [0, 0, 0, 1, 0]], mindspore.float32)
>>> softmax_cross = P.SoftmaxCrossEntropyWithLogits()
>>> loss, backprop = softmax_cross(logits, labels)
([0.5899297, 0.52374405], [[0.02760027, 0.20393994, 0.01015357, 0.20393994, -0.44563377],
[0.08015892, 0.02948882, 0.08015892, -0.4077012, 0.21789455]])
"""
@prim_attr_register
def __init__(self):
pass
def infer_shape(self, logits_shape, labels_shape):
validator.check("logits_shape", logits_shape, "labels_shape", labels_shape, Rel.EQ, self.name)
loss_shape = [logits_shape[0]]
dlogits_shape = logits_shape
return (loss_shape, dlogits_shape)
def infer_dtype(self, logits_type, labels_type):
args = {"logits": logits_type, "labels": labels_type}
validator.check_tensor_type_same(args, (mstype.float16, mstype.float32), self.name)
return (logits_type, logits_type)
class SparseSoftmaxCrossEntropyWithLogits(PrimitiveWithInfer):
r"""
Computes the softmax cross-entropy value between logits and sparse encoding labels.
Note:
Sets input logits as `X`, input label as `Y`, output as `loss`. Then,
.. math::
p_{ij} = softmax(X_{ij}) = \frac{exp(x_i)}{\sum_{j = 0}^{N-1}\exp(x_j)}
.. math::
loss_{ij} = \begin{cases} -ln(p_{ij}), &j = y_i \cr -ln(1 - p_{ij}), & j \neq y_i \end{cases}
.. math::
loss = \sum_{ij} loss_{ij}
Args:
is_grad (bool): If it's true, this operation returns the computed gradient. Default: False.
Inputs:
- **logits** (Tensor) - Input logits, with shape :math:`(N, C)`. Data type should be float16 or float32.
- **labels** (Tensor) - Ground truth labels, with shape :math:`(N)`.
Data type should be int32 or int64.
Outputs:
Tensor, if `is_grad` is False, the output tensor is the value of loss which is a scalar tensor;
if `is_grad` is True, the output tensor is the gradient of input with the same shape as `logits`.
Examples:
Please refer to the usage in nn.SoftmaxCrossEntropyWithLogits source code.
"""
@prim_attr_register
def __init__(self, is_grad=False):
self.init_prim_io_names(inputs=['features', 'labels'], outputs=['output'])
self.is_grad = is_grad
self.add_prim_attr('sens', 1.0)
def infer_shape(self, logits_shape, labels_shape):
validator.check("logits_shape[0]", logits_shape[0], "labels_shape[0]", labels_shape[0], Rel.EQ, self.name)
loss_shape = []
if self.is_grad:
return logits_shape
return loss_shape
def infer_dtype(self, logits_type, labels_type):
validator.check_tensor_type_same({"logits": logits_type}, (mstype.float16, mstype.float32), self.name)
validator.check_tensor_type_same({"labels": labels_type}, (mstype.int32, mstype.int64), self.name)
return logits_type
class ApplyMomentum(PrimitiveWithInfer):
"""
Optimizer that implements the Momentum algorithm.
Refer to the paper `On the importance of initialization and momentum in deep
learning <https://dl.acm.org/doi/10.5555/3042817.3043064>`_ for more details.
Inputs of `variable`, `accumulation` and `gradient` comply with the implicit type conversion rules
to make the data types consistent.
If they have different data types, lower priority data type will be converted to
relatively highest priority data type.
Data type conversion of Parameter is not supported. RuntimeError exception will be thrown.
Args:
use_locking (bool): Enable a lock to protect the update of variable and accumlation tensors. Default: False.
use_nesterov (bool): Enable Nesterov momentum. Default: False.
gradient_scale (float): The scale of the gradient. Default: 1.0.
Inputs:
- **variable** (Parameter) - Weights to be updated. data type should be float.
- **accumulation** (Parameter) - Accumulated gradient value by moment weight.
Has the same data type with `variable`.
- **learning_rate** (Union[Number, Tensor]) - The learning rate value, should be a float number or
a scalar tensor with float data type.
- **gradient** (Tensor) - Gradients, has the same data type as `variable`.
- **momentum** (Union[Number, Tensor]) - Momentum, should be a float number or
a scalar tensor with float data type.
Outputs:
Tensor, parameters to be updated.
Examples:
Please refer to the usage in nn.ApplyMomentum.
"""
__mindspore_signature__ = (
sig.make_sig('variable', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('accumulation', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('learning_rate', dtype=sig.sig_dtype.T1),
sig.make_sig('gradient', dtype=sig.sig_dtype.T),
sig.make_sig('momentum', dtype=sig.sig_dtype.T2),
)
@prim_attr_register
def __init__(self, use_nesterov=False, use_locking=False, gradient_scale=1.0):
self.init_prim_io_names(inputs=['variable', 'accumulation', 'learning_rate', 'gradient', 'momentum'],
outputs=['output'])
self.is_tbe = context.get_context("device_target") == "Ascend"
self.is_ge = context.get_context("enable_ge")
def infer_shape(self, v_shape, a_shape, l_shape, g_shape, m_shape):
if not self.is_ge and self.is_tbe:
return v_shape, v_shape
return v_shape
def infer_dtype(self, v_dtype, a_dtype, l_dtype, g_dtype, m_dtype):
valid_types = [mstype.float16, mstype.float32, mstype.float64]
if v_dtype != mstype.type_refkey and a_dtype != mstype.type_refkey:
validator.check_tensor_type_same({"v": v_dtype}, valid_types, self.name)
validator.check_tensor_type_same({"a": a_dtype}, valid_types, self.name)
validator.check_scalar_or_tensor_type_same({"l_dtype": l_dtype}, valid_types, self.name)
validator.check_scalar_or_tensor_type_same({"g_dtype": g_dtype}, valid_types, self.name)
validator.check_scalar_or_tensor_type_same({"m_dtype": m_dtype}, valid_types, self.name)
if not self.is_ge and self.is_tbe:
return g_dtype, g_dtype
return g_dtype
class SmoothL1Loss(PrimitiveWithInfer):
r"""
Computes smooth L1 loss, a robust L1 loss.
SmoothL1Loss is a Loss similar to MSELoss but less sensitive to outliers as described in the
`Fast R-CNN <https://arxiv.org/abs/1504.08083>`_ by Ross Girshick.
Note:
Sets input prediction as `X`, input target as `Y`, output as `loss`. Then,
.. math::
\text{SmoothL1Loss} = \begin{cases} \frac{0.5 x^{2}}{\text{beta}}, &if \left |x \right | < \text{beta} \cr
\left |x \right|-0.5 \text{beta}, &\text{otherwise}\end{cases}
Args:
beta (float): A parameter used to control the point where the function will change from
quadratic to linear. Default: 1.0.
Inputs:
- **prediction** (Tensor) - Predict data. Data type should be float16 or float32.
- **target** (Tensor) - Ground truth data, with the same type and shape as `prediction`.
Outputs:
Tensor, with the same type and shape as `prediction`.
Examples:
>>> loss = P.SmoothL1Loss()
>>> input_data = Tensor(np.array([1, 2, 3]), mindspore.float32)
>>> target_data = Tensor(np.array([1, 2, 2]), mindspore.float32)
>>> loss(input_data, target_data)
[0, 0, 0.5]
"""
@prim_attr_register
def __init__(self, beta=1.0):
validator.check_value_type('beta', beta, [float], self.name)
validator.check('beta', beta, '', 0, Rel.GT, self.name)
self.init_prim_io_names(inputs=['prediction', 'target'], outputs=['output'])
def infer_shape(self, prediction, target):
validator.check('prediction shape', prediction, 'target shape', target, Rel.EQ, self.name)
return prediction
def infer_dtype(self, prediction, target):
args = {"prediction": prediction, "target": target}
validator.check_tensor_type_same(args, (mstype.float16, mstype.float32), self.name)
return prediction
class L2Loss(PrimitiveWithInfer):
"""
Calculates half of the L2 norm of a tensor without using the `sqrt`.
Set `input_x` as x and output as loss.
.. math::
loss = sum(x ** 2) / nelement(x)
:math:`nelement(x)` represents the number of `input_x`.
Inputs:
- **input_x** (Tensor) - A input Tensor. Data type should be float16 or float32.
Outputs:
Tensor, has the same dtype as `input_x`. The output tensor is the value of loss which is a scalar tensor.
Examples
>>> input_x = Tensor(np.array([1, 2, 3]), mindspore.float16)
>>> l2_loss = P.L2Loss()
>>> l2_loss(input_x)
7.0
"""
@prim_attr_register
def __init__(self):
"""init L2Loss"""
def infer_shape(self, input_x):
loss_shape = []
return loss_shape
def infer_dtype(self, x_type):
validator.check_subclass("x_type", x_type, mstype.tensor, self.name)
valid_types = [mstype.float16, mstype.float32]
validator.check_tensor_type_same({'x_type': x_type}, valid_types, self.name)
return x_type
class DataFormatDimMap(PrimitiveWithInfer):
"""
Returns the dimension index in the destination data format given in the source data format.
Args:
src_format (string): An optional value for source data format. Default: 'NHWC'.
dst_format (string): An optional value for destination data format. Default: 'NCHW'.
Inputs:
- **input_x** (Tensor) - A Tensor with each element as a dimension index in source data format.
The suggested values is in the range [-4, 4). It's type is int32.
Outputs:
Tensor, has the same type as the `input_x`.
Examples:
>>> x = Tensor([0, 1, 2, 3], mindspore.int32)
>>> dfdm = P.DataFormatDimMap()
>>> dfdm(x)
[0 3 1 2]
"""
@prim_attr_register
def __init__(self, src_format='NHWC', dst_format='NCHW'):
valid_values = ['NHWC', 'NCHW']
self.src_format = validator.check_string("src_format", src_format, valid_values, self.name)
self.dst_format = validator.check_string("dst_format", dst_format, valid_values, self.name)
self.init_prim_io_names(inputs=['input_x'], outputs=['output'])
def infer_shape(self, x_shape):
return x_shape
def infer_dtype(self, x_type):
validator.check_subclass("x", x_type, mstype.tensor, self.name)
valid_types = [mstype.int32]
validator.check_tensor_type_same({"x": x_type}, valid_types, self.name)
return x_type
class RNNTLoss(PrimitiveWithInfer):
"""
Computes the RNNTLoss and its gradient with respect to the softmax outputs.
Args:
blank_label (int): blank label. Default: 0.
Inputs:
- **acts** (Tensor) - Tensor of shape :math:`(B, T, U, V)`. Data type should be float16 or float32.
- **labels** (Tensor[int32]) - Tensor of shape :math:`(B, U-1)`.
- **input_lengths** (Tensor[int32]) - Tensor of shape :math:`(B,)`.
- **label_lebgths** (Tensor[int32]) - Tensor of shape :math:`(B,)`.
Outputs:
- **costs** (Tensor[int32]) - Tensor of shape :math:`(B,)`.
- **grads** (Tensor[int32]) - Has the same shape as `acts`.
Examples:
>>> B, T, U, V = 1, 2, 3, 5
>>> acts = np.random.random((B, T, U, V)).astype(np.float32)
>>> labels = np.array([[1, 2]]).astype(np.int32)
>>> input_length = np.array([T] * B).astype(np.int32)
>>> label_length = np.array([len(l) for l in labels]).astype(np.int32)
>>> rnnt_loss = P.RNNTLoss(blank_label=blank)
>>> costs, grads = rnnt_loss(Tensor(acts), Tensor(labels), Tensor(input_length), Tensor(label_length))
"""
@prim_attr_register
def __init__(self, blank_label=0):
validator.check_value_type('blank_label', blank_label, [int], self.name)
self.init_prim_io_names(inputs=['acts', 'labels', 'input_length', 'label_length'],
outputs=['costs', 'grads'])
def infer_shape(self, acts_shape, labels_shape, input_length_shape, label_length_shape):
validator.check_integer('acts_rank', len(acts_shape), 4, Rel.EQ, self.name)
validator.check_integer('labels_rank', len(labels_shape), 2, Rel.EQ, self.name)
validator.check_integer('input_length_rank', len(input_length_shape), 1, Rel.EQ, self.name)
validator.check_integer('label_length_rank', len(label_length_shape), 1, Rel.EQ, self.name)
validator.check('labels shape[0]', labels_shape[0], 'acts shape[0]', acts_shape[0], Rel.EQ, self.name)
validator.check('labels shape[1]', labels_shape[1], 'acts shape[2]-1', acts_shape[2]-1, Rel.EQ, self.name)
validator.check('input_length size', input_length_shape[0], 'acts shape[0]', acts_shape[0], Rel.EQ, self.name)
validator.check('label_length size', label_length_shape[0], 'acts shape[0]', acts_shape[0], Rel.EQ, self.name)
costs_shape = (acts_shape[0],)
return (costs_shape, acts_shape)
def infer_dtype(self, acts_type, labels_type, input_length_type, label_length_type):
validator.check_subclass("acts_type", acts_type, mstype.tensor, self.name)
validator.check_subclass("labels_type", labels_type, mstype.tensor, self.name)
validator.check_subclass("input_length_type", input_length_type, mstype.tensor, self.name)
validator.check_subclass("label_length_type", label_length_type, mstype.tensor, self.name)
validator.check_tensor_type_same({"acts_type": acts_type}, [mstype.float32, mstype.float16], self.name)
validator.check_tensor_type_same({"labels_type": labels_type}, [mstype.int32], self.name)
validator.check_tensor_type_same({"input_length_type": input_length_type}, [mstype.int32], self.name)
validator.check_tensor_type_same({"label_length_type": label_length_type}, [mstype.int32], self.name)
return (acts_type, acts_type)
class SGD(PrimitiveWithInfer):
"""
Computes stochastic gradient descent (optionally with momentum).
Nesterov momentum is based on the formula from On the importance of
initialization and momentum in deep learning.
Note:
For details, please refer to `nn.SGD` source code.
Args:
dampening (float): The dampening for momentum. Default: 0.0.
weight_decay (float): Weight decay (L2 penalty). Default: 0.0.
nesterov (bool): Enable Nesterov momentum. Default: False.
Inputs:
- **parameters** (Tensor) - Parameters to be updated. With float16 or float32 data type.
- **gradient** (Tensor) - Gradients. With float16 or float32 data type.
- **learning_rate** (Tensor) - Learning rate, a scalar tensor with float16 or float32 data type.
e.g. Tensor(0.1, mindspore.float32)
- **accum** (Tensor) - Accum(velocity) to be updated. With float16 or float32 data type.
- **momentum** (Tensor) - Momentum, a scalar tensor with float16 or float32 data type.
e.g. Tensor(0.1, mindspore.float32).
- **stat** (Tensor) - States to be updated with the same shape as gradient. With float16 or float32 data type.
Outputs:
Tensor, parameters to be updated.
Examples:
>>> sgd = P.SGD()
>>> parameters = Tensor(np.array([2, -0.5, 1.7, 4]), mindspore.float32)
>>> gradient = Tensor(np.array([1, -1, 0.5, 2]), mindspore.float32)
>>> learning_rate = Tensor(0.01, mindspore.float32)
>>> accum = Tensor(np.array([0.1, 0.3, -0.2, -0.1]), mindspore.float32)
>>> momentum = Tensor(0.1, mindspore.float32)
>>> stat = Tensor(np.array([1.5, -0.3, 0.2, -0.7]), mindspore.float32)
>>> result = sgd(parameters, gradient, learning_rate, accum, momentum, stat)
"""
@prim_attr_register
def __init__(self, dampening=0.0, weight_decay=0.0, nesterov=False):
validator.check_value_type("nesterov", nesterov, [bool], self.name)
if nesterov and dampening != 0:
raise ValueError(f"Nesterov need zero dampening!")
self.init_prim_io_names(inputs=['parameters', 'gradient', 'learning_rate', 'accum', 'momentum', 'stat'],
outputs=['output'])
def infer_shape(self, parameters_shape, gradient_shape, learning_rate_shape,
accum_shape, momentum_shape, stat_shape):
validator.check_integer(f'parameters rank', len(parameters_shape), 0, Rel.GT, self.name)
validator.check_integer(f'gradient rank', len(gradient_shape), 0, Rel.GE, self.name)
validator.check_integer(f'learning rate rank', len(learning_rate_shape), 0, Rel.GE, self.name)
validator.check_integer(f'accumulation rank', len(accum_shape), 0, Rel.GT, self.name)
validator.check_integer(f'momentum rank', len(momentum_shape), 0, Rel.GE, self.name)
validator.check_integer(f'stat rank', len(stat_shape), 0, Rel.GE, self.name)
validator.check("gradient shape", gradient_shape, "stat shape", stat_shape, Rel.EQ, self.name)
return parameters_shape
def infer_dtype(self, parameters_dtype, gradient_dtype, learning_rate_dtype,
accum_dtype, momentum_dtype, stat_dtype):
valid_types = [mstype.float16, mstype.float32]
validator.check_tensor_type_same({"parameters": parameters_dtype}, valid_types, self.name)
validator.check_tensor_type_same({"gradient": gradient_dtype}, valid_types, self.name)
validator.check_tensor_type_same({"learning_rate": learning_rate_dtype}, valid_types, self.name)
validator.check_tensor_type_same({"accum": accum_dtype}, valid_types, self.name)
validator.check_tensor_type_same({"momentum": momentum_dtype}, valid_types, self.name)
validator.check_tensor_type_same({"stat": stat_dtype}, valid_types, self.name)
return parameters_dtype
class ApplyRMSProp(PrimitiveWithInfer):
"""
Optimizer that implements the Root Mean Square prop(RMSProp) algorithm.
Please refer to the usage in source code of `nn.RMSProp`.
Note:
Update `var` according to the RMSProp algorithm.
.. math::
s_{t} = \\rho s_{t-1} + (1 - \\rho)(\\nabla Q_{i}(w))^2
.. math::
m_{t} = \\beta m_{t-1} + \\frac{\\eta} {\\sqrt{s_{t} + \\epsilon}} \\nabla Q_{i}(w)
.. math::
w = w - m_{t}
where :math:`w` represents `var`, which will be updated.
:math:`s_{t}` represents `mean_square`, :math:`s_{t-1}` is the last momentent of :math:`s_{t}`,
:math:`m_{t}` represents `moment`, :math:`m_{t-1}` is the last momentent of :math:`m_{t}`.
:math:`\\rho` represents `decay`. :math:`\\beta` is the momentum term, represents `momentum`.
:math:`\\epsilon` is a smoothing term to avoid division by zero, represents `epsilon`.
:math:`\\eta` represents `learning_rate`. :math:`\\nabla Q_{i}(w)` represents `grad`.
Args:
use_locking (bool): Enable a lock to protect the update of variable tensors. Default: False.
Inputs:
- **var** (Tensor) - Weights to be update.
- **mean_square** (Tensor) - Mean square gradients, must have the same type as `var`.
- **moment** (Tensor) - Delta of `var`, must have the same type as `var`.
- **learning_rate** (Union[Number, Tensor]) - Learning rate. Should be a float number or
a scalar tensor with float16 or float32 data type.
- **grad** (Tensor) - Gradients, must have the same type as `var`.
- **decay** (float) - Decay rate. Only constant value is allowed.
- **momentum** (float) - Momentum. Only constant value is allowed.
- **epsilon** (float) - Ridge term. Only constant value is allowed.
Outputs:
Tensor, parameters to be update.
Examples:
>>> apply_rms = P.ApplyRMSProp()
>>> input_x = Tensor(1., mindspore.float32)
>>> mean_square = Tensor(2., mindspore.float32)
>>> moment = Tensor(1., mindspore.float32)
>>> grad = Tensor(2., mindspore.float32 )
>>> learning_rate = Tensor(0.9, mindspore.float32)
>>> decay = 0.0
>>> momentum = 1e-10
>>> epsilon = 0.001
>>> result = apply_rms(input_x, mean_square, moment, learning_rate, grad, decay, momentum, epsilon)
(-2.9977674, 0.80999994, 1.9987665)
"""
@prim_attr_register
def __init__(self, use_locking=False):
self.use_locking = validator.check_value_type("use_locking", use_locking, [bool], self.name)
self.init_prim_io_names(inputs=['var', 'mean_square', 'moment', 'learning_rate', 'grad',
'rho', 'momentum', 'epsilon'], outputs=['output'])
self.is_ge = context.get_context("enable_ge")
self.is_d = context.get_context("device_target") == "Ascend"
def infer_shape(self, var_shape, mean_square_shape, moment_shape, learning_rate_shape, grad_shape, decay_shape,
momentum_shape, epsilon_shape):
validator.check("var_shape", var_shape, "mean_square_shape", mean_square_shape, Rel.EQ, self.name)
validator.check("var_shape", var_shape, "moment_shape", moment_shape, Rel.EQ, self.name)
validator.check("var_shape", var_shape, "grad_shape", grad_shape, Rel.EQ, self.name)
if not self.is_ge and self.is_d:
return var_shape, var_shape, var_shape
return var_shape
def infer_dtype(self, var_dtype, mean_square_dtype, moment_dtype, learning_rate_dtype, grad_dtype, decay_dtype,
momentum_dtype, epsilon_dtype):
args = {"var": var_dtype, "mean_square": mean_square_dtype, "moment": moment_dtype, "grad": grad_dtype}
validator.check_tensor_type_same(args, mstype.number_type, self.name)
valid_types = [mstype.float16, mstype.float32]
args_decay = {"decay": decay_dtype, 'momentum': momentum_dtype, "epsilon": epsilon_dtype}
validator.check_type_same(args_decay, valid_types, self.name)
args_lr = {"learning_rate": learning_rate_dtype, "decay": decay_dtype}
validator.check_scalar_or_tensor_type_same(args_lr, valid_types, self.name, allow_mix=True)
if not self.is_ge and self.is_d:
return var_dtype, var_dtype, var_dtype
return var_dtype
def infer_value(self, var, mean_square, moment, learning_rate, grad, decay, momentum, epsilon):
if decay is None or momentum is None or epsilon is None:
raise ValueError(f"For {self.name}, decay, momentum, epsilon must be const.")
class ApplyCenteredRMSProp(PrimitiveWithInfer):
"""
Optimizer that implements the centered RMSProp algorithm.
Please refer to the usage in source code of `nn.RMSProp`.
Note:
Update `var` according to the centered RMSProp algorithm.
.. math::
g_{t} = \\rho g_{t-1} + (1 - \\rho)\\nabla Q_{i}(w)
.. math::
s_{t} = \\rho s_{t-1} + (1 - \\rho)(\\nabla Q_{i}(w))^2
.. math::
m_{t} = \\beta m_{t-1} + \\frac{\\eta} {\\sqrt{s_{t} - g_{t}^2 + \\epsilon}} \\nabla Q_{i}(w)
.. math::
w = w - m_{t}
where :math:`w` represents `var`, which will be updated.
:math:`g_{t}` represents `mean_gradient`, :math:`g_{t-1}` is the last momentent of :math:`g_{t}`.
:math:`s_{t}` represents `mean_square`, :math:`s_{t-1}` is the last momentent of :math:`s_{t}`,
:math:`m_{t}` represents `moment`, :math:`m_{t-1}` is the last momentent of :math:`m_{t}`.
:math:`\\rho` represents `decay`. :math:`\\beta` is the momentum term, represents `momentum`.
:math:`\\epsilon` is a smoothing term to avoid division by zero, represents `epsilon`.
:math:`\\eta` represents `learning_rate`. :math:`\\nabla Q_{i}(w)` represents `grad`.
Args:
use_locking (bool): Enable a lock to protect the update of variable tensors. Default: False.
Inputs:
- **var** (Tensor) - Weights to be update.
- **mean_gradient** (Tensor) - Mean gradients, must have the same type as `var`.
- **mean_square** (Tensor) - Mean square gradients, must have the same type as `var`.
- **moment** (Tensor) - Delta of `var`, must have the same type as `var`.
- **grad** (Tensor) - Gradients, must have the same type as `var`.
- **learning_rate** (Union[Number, Tensor]) - Learning rate. Should be a float number or
a scalar tensor with float16 or float32 data type.
- **decay** (float) - Decay rate.
- **momentum** (float) - Momentum.
- **epsilon** (float) - Ridge term.
Outputs:
Tensor, parameters to be update.
Examples:
>>> centered_rms_prop = P.ApplyCenteredRMSProp()
>>> input_x = Tensor(np.arange(-6, 6).astype(np.float32).reshape(2, 3, 2), mindspore.float32)
>>> mean_grad = Tensor(np.arange(12).astype(np.float32).reshape(2, 3, 2), mindspore.float32)
>>> mean_square = Tensor(np.arange(-8, 4).astype(np.float32).reshape(2, 3, 2), mindspore.float32)
>>> moment = Tensor(np.arange(12).astype(np.float32).reshape(2, 3, 2), mindspore.float32)
>>> grad = Tensor(np.arange(12).astype(np.float32).reshape(2, 3, 2), mindspore.float32)
>>> learning_rate = Tensor(0.9, mindspore.float32)
>>> decay = 0.0
>>> momentum = 1e-10
>>> epsilon = 0.05
>>> result = centered_rms_prop(input_x, mean_grad, mean_square, moment, grad,
>>> learning_rate, decay, momentum, epsilon)
[[[ -6. -9.024922]
[-12.049845 -15.074766]
[-18.09969 -21.124613]]
[[-24.149532 -27.174456]
[-30.199379 -33.2243 ]
[-36.249226 -39.274143]]]
"""
@prim_attr_register
def __init__(self, use_locking=False):
self.use_locking = validator.check_value_type("use_locking", use_locking, [bool], self.name)
self.is_ascend = context.get_context("device_target") == "Ascend"
def infer_shape(self, var_shape, mean_gradient_shape, mean_square_shape, moment_shape, grad_shape,
learning_rate_shape, decay_shape, momentum_shape, epsilon_shape):
validator.check("var_shape", var_shape, "mean_gradient_shape", mean_gradient_shape, Rel.EQ, self.name)
validator.check("var_shape", var_shape, "mean_square_shape", mean_square_shape, Rel.EQ, self.name)
validator.check("var_shape", var_shape, "moment_shape", moment_shape, Rel.EQ, self.name)
validator.check("var_shape", var_shape, "grad_shape", grad_shape, Rel.EQ, self.name)
if self.is_ascend:
return var_shape, mean_gradient_shape, mean_square_shape, moment_shape
return var_shape
def infer_dtype(self, var_dtype, mean_gradient_dtype, mean_square_dtype, moment_dtype, grad_dtype,
learning_rate_dtype, rho_dtype, momentum_dtype, epsilon_dtype):
args = {"var": var_dtype, "mean_gradient": mean_gradient_dtype,
"mean_square": mean_square_dtype, "moment": moment_dtype, "grad": grad_dtype}
validator.check_tensor_type_same(args, mstype.number_type, self.name)
valid_types = [mstype.float16, mstype.float32]
args_rho = {"rho": rho_dtype, 'momentum': momentum_dtype, "epsilon": epsilon_dtype}
validator.check_type_same(args_rho, valid_types, self.name)
args_lr = {"learning_rate": learning_rate_dtype, "rho": rho_dtype}
validator.check_scalar_or_tensor_type_same(args_lr, valid_types, self.name, allow_mix=True)
if self.is_ascend:
return var_dtype, mean_gradient_dtype, mean_square_dtype, moment_dtype
return var_dtype
class LayerNorm(Primitive):
r"""
Applies the Layer Normalization to the input tensor.
This operator will normalize the input tensor on given axis. LayerNorm is described in the paper
`Layer Normalization <https://arxiv.org/abs/1607.06450>`_.
.. math::
y = \frac{x - mean}{\sqrt{variance + \epsilon}} * \gamma + \beta
where :math:`\gamma` is scale, :math:`\beta` is bias, :math:`\epsilon` is epsilon.
Args:
begin_norm_axis (int): The begin axis of the `input_x` to apply LayerNorm,
the value should be in [-1, rank(input)). Default: 1.
begin_params_axis (int): The begin axis of the parameter input (`gamma`, `beta`) to
apply LayerNorm, the value should be in [-1, rank(input)). Default: 1.
epsilon (float): A value added to the denominator for numerical stability. Default: 1e-7.
Inputs:
- **input_x** (Tensor) - Tensor of shape :math:`(N, \ldots)`.
The input of LayerNorm.
- **gamma** (Tensor) - Tensor of shape :math:`(P_0, \ldots, P_\text{begin_params_axis})`.
The learnable parameter `gamma` as the scale on norm.
- **beta** (Tensor) - Tensor of shape :math:`(P_0, \ldots, P_\text{begin_params_axis})`.
The learnable parameter `beta` as the scale on norm.
Outputs:
tuple[Tensor], tuple of 3 tensors, the normalized input and the updated parameters.
- **output_x** (Tensor) - The normalized input, has the same type and shape as the `input_x`.
The shape is :math:`(N, C)`.
- **mean** (Tensor) - Tensor of shape :math:`(C,)`.
- **variance** (Tensor) - Tensor of shape :math:`(C,)`.
Examples:
>>> input_x = Tensor(np.array([[1, 2, 3], [1, 2, 3]]), mindspore.float32)
>>> gamma = Tensor(np.ones([3]), mindspore.float32)
>>> beta = Tensor(np.ones([3]), mindspore.float32)
>>> layer_norm = P.LayerNorm()
>>> output = layer_norm(input_x, gamma, beta)
([[-0.22474492, 1., 2.2247488], [-0.22474492, 1., 2.2247488]],
[[2.], [2.]], [[0.6666667], [0.6666667]])
"""
@prim_attr_register
def __init__(self, begin_norm_axis=1, begin_params_axis=1, epsilon=1e-7):
validator.check_value_type('begin_norm_axis', begin_norm_axis, [int], self.name)
validator.check_value_type('begin_params_axis', begin_params_axis, [int], self.name)
validator.check_value_type('epsilon', epsilon, [float], self.name)
class L2Normalize(PrimitiveWithInfer):
r"""
L2 normalization Operator.
This operator will normalizes the input using the given axis. The function is shown as follows:
.. math::
\text{output} = \frac{x}{\sqrt{\text{max}(\text{sum} (\text{input_x}^2), \epsilon)}},
where :math:`\epsilon` is epsilon.
Args:
axis (int): The begin axis for the input to apply L2 normalize. Default: 0.
epsilon (float): A small value added for numerical stability. Default: 1e-4.
Inputs:
- **input_x** (Tensor) - Input to compute the normalization. Data type should be float16 or float32.
Outputs:
Tensor, with the same type and shape as the input.
Examples:
>>> l2_normalize = P.L2Normalize()
>>> input_x = Tensor(np.random.randint(-256, 256, (2, 3, 4)), mindspore.float32)
>>> result = l2_normalize(input_x)
[[[-0.47247353 -0.30934513 -0.4991462 0.8185567 ]
[-0.08070751 -0.9961299 -0.5741758 0.09262337]
[-0.9916556 -0.3049123 0.5730487 -0.40579924]
[[-0.88134485 0.9509498 -0.86651784 0.57442576]
[ 0.99673784 0.08789381 -0.8187321 0.9957012 ]
[ 0.12891524 -0.9523804 -0.81952125 0.91396334]]]
"""
@prim_attr_register
def __init__(self, axis=0, epsilon=1e-4):
validator.check_value_type('axis', axis, [int], self.name)
validator.check_value_type('epsilon', epsilon, [int, float], self.name)
def infer_shape(self, input_x):
dim = len(input_x)
validator.check_int_range('axis value', self.axis, -dim, dim, Rel.INC_LEFT, self.name)
return input_x
def infer_dtype(self, input_x):
validator.check_subclass("x", input_x, mstype.tensor, self.name)
validator.check_tensor_type_same({"input_x": input_x}, [mstype.float16, mstype.float32], self.name)
return input_x
class DropoutGenMask(Primitive):
"""
Generates the mask value for the input shape.
Args:
Seed0 (int): Seed0 value for random generating. Default: 0.
Seed1 (int): Seed1 value for random generating. Default: 0.
Inputs:
- **shape** (tuple[int]) - The shape of target mask.
- **keep_prob** (Tensor) - The keep rate, between 0 and 1, e.g. keep_prob = 0.9,
means dropping out 10% of input units.
Outputs:
Tensor, the value of generated mask for input shape.
Examples:
>>> dropout_gen_mask = P.DropoutGenMask()
>>> shape = (20, 16, 50)
>>> keep_prob = Tensor(0.5, mindspore.float32)
>>> mask = dropout_gen_mask(shape, keep_prob)
"""
@prim_attr_register
def __init__(self, Seed0=0, Seed1=0):
self.init_prim_io_names(inputs=['shape', 'keep_prob'], outputs=['output'])
validator.check_value_type("Seed0", Seed0, [int], self.name)
validator.check_value_type("Seed1", Seed1, [int], self.name)
self.add_prim_attr("_random_effect", True)
class DropoutDoMask(PrimitiveWithInfer):
"""
Applies dropout mask on the input tensor.
Take the mask output of DropoutGenMask as input, and apply dropout on the input.
Inputs:
- **input_x** (Tensor) - The input tensor.
- **mask** (Tensor) - The mask to be applied on `input_x`, which is the output of `DropoutGenMask`. And the
shape of `input_x` must be the same as the value of `DropoutGenMask`'s input `shape`. If input wrong `mask`,
the output of `DropoutDoMask` are unpredictable.
- **keep_prob** (Tensor) - The keep rate, between 0 and 1, e.g. keep_prob = 0.9,
means dropping out 10% of input units. The value of `keep_prob` is the same as the input `keep_prob` of
`DropoutGenMask`.
Outputs:
Tensor, the value that applied dropout on.
Examples:
>>> x = Tensor(np.ones([20, 16, 50]), mindspore.float32)
>>> shape = (20, 16, 50)
>>> keep_prob = Tensor(0.5, mindspore.float32)
>>> dropout_gen_mask = P.DropoutGenMask()
>>> dropout_do_mask = P.DropoutDoMask()
>>> mask = dropout_gen_mask(shape, keep_prob)
>>> output = dropout_do_mask(x, mask, keep_prob)
>>> assert output.shape == (20, 16, 50)
"""
@prim_attr_register
def __init__(self):
pass
def __infer__(self, input_x, mask, keep_prob):
input_x_shape = input_x['shape']
mask_shape = mask['shape']
keep_prob_shape = keep_prob['shape']
validator.check("keep_prob's dim", len(keep_prob_shape), '0(scalar)', 0, Rel.EQ, self.name)
size_x = reduce(lambda x, y: x * y, input_x_shape)
if len(mask_shape) != 1:
raise ValueError("DropoutDoMask mask shape should be 1-dimension.")
size_y = mask_shape[0] * 8
if size_x > size_y:
raise ValueError(f"DropoutDoMask y mask do not math input input_x shape:"
"{input_x_shape}, mask shape: {mask_shape}.")
validator.check_tensor_type_same({"input_x": input_x['dtype']}, [mstype.float32, mstype.float16, mstype.int32],
self.name)
validator.check_tensor_type_same({"input_mask": mask['dtype']}, [mstype.uint8], self.name)
keep_prob_v = keep_prob['value']
if keep_prob_v is not None:
validator.check_number_range('keep_prob', keep_prob_v.asnumpy(), 0, 1, Rel.INC_BOTH, self.name)
out = {'shape': input_x_shape,
'dtype': input_x['dtype'],
'value': None}
return out
class ResizeBilinear(PrimitiveWithInfer):
r"""
Resizes the image to certain size using bilinear interpolation.
The resizing only affects the lower two dimensions which represent the height and width. The input images
can be represented by different data types, but the data types of output images are always float32.
Args:
size (tuple[int]): A tuple of 2 int elements `(new_height, new_width)`, the new size for the images.
align_corners (bool): If it's true, rescale input by `(new_height - 1) / (height - 1)`,
which exactly aligns the 4 corners of images and resized images. If it's false,
rescale by `new_height / height`. Default: False.
Inputs:
- **input** (Tensor) - Image to be resized. Tensor of shape `(N_i, ..., N_n, height, width)`,
with data type of float32 or float16.
Outputs:
Tensor, resized image. Tensor of shape `(N_i, ..., N_n, new_height, new_width)` in `float32`.
Examples:
>>> tensor = Tensor([[[[1, 2, 3, 4, 5], [1, 2, 3, 4, 5]]]], mindspore.float32)
>>> resize_bilinear = P.ResizeBilinear((5, 5))
>>> result = resize_bilinear(tensor)
>>> assert result.shape == (1, 1, 5, 5)
"""
@prim_attr_register
def __init__(self, size, align_corners=False):
pass
def infer_shape(self, input_shape):
input_shape = list(input_shape)
batch, channel, _, _ = input_shape
out_shape = [batch, channel]
for i in self.size:
out_shape.append(int(i))
return out_shape
def infer_dtype(self, input_dtype):
validator.check_tensor_type_same({'input_dtype': input_dtype}, [mstype.float16, mstype.float32], self.name)
return mstype.tensor_type(mstype.float32)
class OneHot(PrimitiveWithInfer):
r"""
Computes a one-hot tensor.
Makes a new tensor, whose locations represented by indices in `indices` take value `on_value`, while all
other locations take value `off_value`.
Note:
If the input indices is rank `N`, the output will have rank `N+1`. The new axis is created at dimension `axis`.
Args:
axis (int): Position to insert the value. e.g. If `indices` shape is [n, c], and `axis` is `-1` the output shape
will be [n, c, depth], If `axis` is `0` the output shape will be [depth, n, c]. Default: -1.
Inputs:
- **indices** (Tensor) - A tensor of indices. Tensor of shape :math:`(X_0, \ldots, X_n)`.
Data type must be int32.
- **depth** (int) - A scalar defining the depth of the one hot dimension.
- **on_value** (Tensor) - A value to fill in output when `indices[j] = i`. With data type of float16 or float32.
- **off_value** (Tensor) - A value to fill in output when `indices[j] != i`.
Has the same data type with as `on_value`.
Outputs:
Tensor, one_hot tensor. Tensor of shape :math:`(X_0, \ldots, X_{axis}, \text{depth} ,X_{axis+1}, \ldots, X_n)`.
Examples:
>>> indices = Tensor(np.array([0, 1, 2]), mindspore.int32)
>>> depth, on_value, off_value = 3, Tensor(1.0, mindspore.float32), Tensor(0.0, mindspore.float32)
>>> onehot = P.OneHot()
>>> result = onehot(indices, depth, on_value, off_value)
[[1, 0, 0], [0, 1, 0], [0, 0, 1]]
"""
@prim_attr_register
def __init__(self, axis=-1):
self.init_prim_io_names(inputs=['indices', 'depth', 'on_value', 'off_value'], outputs=['output'])
validator.check_value_type("axis", axis, [int], self.name)
def __infer__(self, indices, depth, on_value, off_value):
# check type
validator.check_tensor_type_same({"indices": indices['dtype']}, (mstype.int32,), self.name)
validator.check_type_name("depth", depth['dtype'], mstype.int_type, self.name)
args = {"on_value": on_value['dtype'], "off_value": off_value['dtype']}
validator.check_tensor_type_same(args, (mstype.float16, mstype.float32), self.name)
# check shape
indices_shp = indices['shape']
validator.check_int_range("axis", self.axis, -1, len(indices_shp), Rel.INC_BOTH, self.name)
depth_val = depth['value']
validator.check_integer("depth", depth_val, 0, Rel.GE, self.name)
# create new dimension at end if self.axis is -1
_ = indices_shp.insert(self.axis, depth_val) if self.axis >= 0 else indices_shp.append(depth_val)
return {'shape': indices_shp,
'dtype': on_value['dtype'],
'value': None}
class Gelu(PrimitiveWithInfer):
r"""
Gaussian Error Linear Units activation function.
GeLU is described in the paper `Gaussian Error Linear Units (GELUs) <https://arxiv.org/abs/1606.08415>`_.
And also please refer to `BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding
<https://arxiv.org/abs/1810.04805>`_.
Gelu is defined as follows:
.. math::
\text{output} = 0.5 * x * (1 + erf(x / \sqrt{2})),
where :math:`erf` is the "Gauss error function" .
Inputs:
- **input_x** (Tensor) - Input to compute the Gelu with data type of float16 or float32.
Outputs:
Tensor, with the same type and shape as input.
Examples:
>>> tensor = Tensor(np.array([1.0, 2.0, 3.0]), mindspore.float32)
>>> gelu = P.Gelu()
>>> result = gelu(tensor)
"""
@prim_attr_register
def __init__(self):
"""init GeLU"""
self.init_prim_io_names(inputs=['x'], outputs=['output'])
def infer_shape(self, input_x):
return input_x
def infer_dtype(self, input_x):
validator.check_tensor_type_same({"input_x": input_x}, (mstype.float16, mstype.float32), self.name)
return input_x
class GetNext(PrimitiveWithInfer):
"""
Returns the next element in the dataset queue.
Note:
The GetNext operation needs to be associated with network and it also depends on the init_dataset interface,
it can't be used directly as a single operation.
For details, please refer to `nn.DataWrapper` source code.
Args:
types (list[:class:`mindspore.dtype`]): The type of the outputs.
shapes (list[tuple[int]]): The dimensionality of the outputs.
output_num (int): The output number, length of `types` and `shapes`.
shared_name (str): The queue name of `init_dataset` interface.
Inputs:
No inputs.
Outputs:
tuple[Tensor], the output of Dataset. The shape is described in `shapes`
and the type is described is `types`.
Examples:
>>> get_next = P.GetNext([mindspore.float32, mindspore.int32], [[32, 1, 28, 28], [10]], 2, 'shared_name')
>>> feature, label = get_next()
"""
@prim_attr_register
def __init__(self, types, shapes, output_num, shared_name):
validator.check_value_type("types", types, [list, tuple], self.name)
validator.check_value_type("shapes", shapes, [list, tuple], self.name)
validator.check("types length", len(types), "shapes length", len(shapes), Rel.EQ, self.name)
validator.check_value_type("output_num", output_num, [int], self.name)
def infer_shape(self):
return tuple(self.shapes)
def infer_dtype(self):
return tuple(self.types)
class PReLU(PrimitiveWithInfer):
r"""
Parametric Rectified Linear Unit activation function.
PReLU is described in the paper `Delving Deep into Rectifiers: Surpassing Human-Level Performance on
ImageNet Classification <https://arxiv.org/abs/1502.01852>`_. Defined as follows:
.. math::
prelu(x_i)= \max(0, x_i) + \min(0, w * x_i),
where :math:`x_i` is an element of an channel of the input.
Note:
1-dimensional input_x is not supported.
Inputs:
- **input_x** (Tensor) - Float tensor, representing the output of the preview layer.
With data type of float16 or float32.
- **weight** (Tensor) - Float Tensor, w > 0, there is only two shapes are legitimate,
1 or the number of channels at input. With data type of float16 or float32.
Outputs:
Tensor, with the same type as `input_x`.
Detailed information, please refer to `nn.PReLU`.
Examples:
>>> import mindspore
>>> import mindspore.nn as nn
>>> import numpy as np
>>> from mindspore import Tensor
>>> from mindspore.ops import operations as P
>>> class Net(nn.Cell):
>>> def __init__(self):
>>> super(Net, self).__init__()
>>> self.prelu = P.PReLU()
>>> def construct(self, input_x, weight):
>>> result = self.prelu(input_x, weight)
>>> return result
>>>
>>> input_x = Tensor(np.random.randint(-3, 3, (2, 3, 2)), mindspore.float32)
>>> weight = Tensor(np.array([0.1, 0.6, -0.3]), mindspore.float32)
>>> net = Net()
>>> result = net(input_x, weight)
[[[-0.1 1. ]
[ 0. 2. ]
[0. 0. ]]
[[-0.2 -0.1 ]
[2. -1.8000001]
[0.6 0.6 ]]]
"""
@prim_attr_register
def __init__(self):
pass
def infer_shape(self, input_x_shape, weight_shape):
input_x_dim = len(input_x_shape)
weight_dim = len(weight_shape)
if input_x_dim == 1:
raise ValueError(f'For \'{self.name}\' input_x rank 1 is not supported.')
if weight_dim != 1:
raise ValueError(f'For \'{self.name}\' weight_dim must be 1, while weight_dim is {weight_dim}.')
if weight_shape[0] != input_x_shape[1] and weight_shape[0] != 1:
raise ValueError(f'For \'{self.name}\' channel of input_x and weight must be matched,'
f' while channel of input_x is {input_x_shape[1]},'
f' weight_shape[0] is {weight_shape[0]}.')
return input_x_shape
def infer_dtype(self, input_x_dtype, weight_dtype):
valid_types = (mstype.float16, mstype.float32)
validator.check_tensor_type_same({"input_x": input_x_dtype}, valid_types, self.name)
validator.check_tensor_type_same({"weight": weight_dtype}, valid_types, self.name)
return input_x_dtype
class LSTM(PrimitiveWithInfer):
"""
Performs the long short term memory(LSTM) on the input.
Detailed information, please refer to `nn.LSTM`.
"""
@prim_attr_register
def __init__(self, input_size, hidden_size, num_layers, has_bias, bidirectional, dropout):
self.input_size = validator.check_integer("input_size", input_size, 0, Rel.GT, self.name)
self.hidden_size = validator.check_integer("hidden_size", hidden_size, 0, Rel.GT, self.name)
self.num_layers = validator.check_integer("num_layers", num_layers, 0, Rel.GT, self.name)
self.has_bias = validator.check_value_type("has_bias", has_bias, (bool,), self.name)
self.bidirectional = validator.check_value_type("bidirectional", bidirectional, (bool,), self.name)
self.dropout = validator.check_value_type("dropout", dropout, [float], self.name)
self.dropout = validator.check_number_range('dropout', dropout, 0, 1, Rel.INC_BOTH, self.name)
if bidirectional:
self.num_directions = 2
else:
self.num_directions = 1
def infer_shape(self, x_shape, h_shape, c_shape, w_shape):
# (seq, batch_size, feature)
validator.check_integer("x rank", len(x_shape), 3, Rel.EQ, self.name)
validator.check_integer("x[2]", x_shape[2], self.input_size, Rel.EQ, self.name)
# h and c should be same shape
validator.check_integer("h rank", len(h_shape), 3, Rel.EQ, self.name)
validator.check("h_shape", h_shape, "c_shape", c_shape, Rel.EQ, self.name)
# (num_layers * num_directions, batch, hidden_size)
validator.check_integer("h[0]", h_shape[0], self.num_layers * self.num_directions, Rel.EQ, self.name)
validator.check_integer("h[1]", h_shape[1], x_shape[1], Rel.EQ, self.name)
validator.check_integer("h[2]", h_shape[2], self.hidden_size, Rel.EQ, self.name)
y_shape = (x_shape[0], x_shape[1], self.hidden_size * self.num_directions)
# set arbitrary shape for reserved space
type_size = 4
gates_ws_ld = self.get_good_ld(self.hidden_size * 4, type_size)
states_ws_ld = self.get_good_ld(max(self.hidden_size, self.input_size), type_size)
self.ws_gates_size = self.num_layers * self.num_directions * x_shape[0] * x_shape[1] * gates_ws_ld * type_size
self.ws_states_size = (self.num_layers + 1) * self.num_directions * (x_shape[0] + 1) * x_shape[
1] * states_ws_ld * type_size
self.ws_c_states_size = (self.num_layers + 1) * self.num_directions * (x_shape[0] + 1) * x_shape[
1] * states_ws_ld * type_size
self.ws_diff_states_size = (self.num_layers + 1) * self.num_directions * (x_shape[0] + 1) * (2 + 1) * x_shape[
1] * states_ws_ld * type_size
self.ws_grid_comp_size = 0
self.page_size = 4096
current_offset = 0
current_offset += self.ws_gates_size
current_offset = self.rnd_up(current_offset, self.page_size)
current_offset += self.ws_states_size
current_offset = self.rnd_up(current_offset, self.page_size)
current_offset += self.ws_c_states_size
current_offset = self.rnd_up(current_offset, self.page_size)
current_offset += self.ws_diff_states_size
current_offset = self.rnd_up(current_offset, self.page_size)
current_offset += self.ws_grid_comp_size
reserved_shape = (current_offset, 1)
state_shape = (1, 1)
return (y_shape, h_shape, c_shape, reserved_shape, state_shape)
def infer_dtype(self, x_dtype, h_dtype, c_dtype, w_dtype):
args = {'x': x_dtype, 'h': h_dtype, 'c': c_dtype, 'w': w_dtype}
validator.check_tensor_type_same(args, (mstype.float32, mstype.float16), self.name)
return (x_dtype, x_dtype, x_dtype, x_dtype, x_dtype)
def rnd_up(self, current_offset, page_size):
return ((current_offset + page_size - 1) // page_size) * page_size
def get_good_ld(self, dim, type_size):
ld = self.rnd_up(dim, 64 // type_size)
if ld * 256 == 0:
return ld + 64 // type_size
return ld
class SigmoidCrossEntropyWithLogits(PrimitiveWithInfer):
r"""
Uses the given logits to compute sigmoid cross entropy.
Note:
Sets input logits as `X`, input label as `Y`, output as `loss`. Then,
.. math::
p_{ij} = sigmoid(X_{ij}) = \frac{1}{1 + e^{-X_{ij}}}
.. math::
loss_{ij} = -[Y_{ij} * ln(p_{ij}) + (1 - Y_{ij})ln(1 - p_{ij})]
Inputs:
- **logits** (Tensor) - Input logits.
- **label** (Tensor) - Ground truth label.
Outputs:
Tensor, with the same shape and type as input `logits`.
Examples:
>>> logits = Tensor(np.random.randn(2, 3).astype(np.float16))
>>> labels = Tensor(np.random.randn(2, 3).astype(np.float16))
>>> sigmoid = P.SigmoidCrossEntropyWithLogits()
>>> sigmoid(logits, labels)
"""
@prim_attr_register
def __init__(self):
"""Init SigmoidCrossEntropyWithLogits"""
self.init_prim_io_names(inputs=['predict', 'target'], outputs=['loss'])
def infer_shape(self, x_shape, y_shape):
validator.check("x_shape", x_shape, "y_shape", y_shape, Rel.EQ, self.name)
return x_shape
def infer_dtype(self, x_dtype, y_dtype):
args = {"x_dtype": x_dtype, "y_dtype": y_dtype}
validator.check_tensor_type_same(args, mstype.number_type, self.name)
return x_dtype
class Pad(PrimitiveWithInfer):
"""
Pads input tensor according to the paddings.
Args:
paddings (tuple): The shape of parameter `paddings` is (N, 2). N is the rank of input data. All elements of
paddings are int type. For the input in `D` th dimension, paddings[D, 0] indicates how many sizes to be
extended ahead of the input tensor in the `D` th dimension, and paddings[D, 1] indicates how many sizes to
be extended behind of the input tensor in the `D` th dimension.
Inputs:
- **input_x** (Tensor) - The input tensor.
Outputs:
Tensor, the tensor after padding.
Examples:
>>> input_tensor = Tensor(np.array([[-0.1, 0.3, 3.6], [0.4, 0.5, -3.2]]), mindspore.float32)
>>> pad_op = P.Pad(((1, 2), (2, 1)))
>>> output_tensor = pad_op(input_tensor)
>>> assert output_tensor == Tensor(np.array([[ 0. , 0. , 0. , 0. , 0. , 0. ],
>>> [ 0. , 0. , -0.1, 0.3, 3.6, 0. ],
>>> [ 0. , 0. , 0.4, 0.5, -3.2, 0. ],
>>> [ 0. , 0. , 0. , 0. , 0. , 0. ],
>>> [ 0. , 0. , 0. , 0. , 0. , 0. ]]), mindspore.float32)
"""
@prim_attr_register
def __init__(self, paddings):
"""Init Pad"""
self.init_prim_io_names(inputs=['x'], outputs=['y'])
if not isinstance(paddings, tuple):
raise TypeError('Paddings must be tuple type.')
for item in paddings:
if len(item) != 2:
raise ValueError('The shape of paddings must be (n, 2).')
self.paddings = paddings
def infer_shape(self, x):
paddings = np.array(self.paddings)
validator.check_integer('paddings.shape', paddings.size, len(x) * 2, Rel.EQ, self.name)
if not np.all(paddings >= 0):
raise ValueError('All elements of paddings must be >= 0.')
y_shape = ()
for i in range(int(paddings.size / 2)):
y_shape += ((x[i] + paddings[i, 0] + paddings[i, 1]),)
return y_shape
def infer_dtype(self, x):
validator.check_subclass("input_x", x, mstype.tensor, self.name)
return x
class MirrorPad(PrimitiveWithInfer):
"""
Pads the input tensor according to the paddings and mode.
Args:
mode (str): Specifies padding mode. The optional values are "REFLECT", "SYMMETRIC".
Default: "REFLECT".
Inputs:
- **input_x** (Tensor) - The input tensor.
- **paddings** (Tensor) - The paddings tensor. The value of `paddings` is a matrix(list),
and its shape is (N, 2). N is the rank of input data. All elements of paddings
are int type. For the input in `D` th dimension, paddings[D, 0] indicates how many sizes to be
extended ahead of the input tensor in the `D` th dimension, and paddings[D, 1] indicates how many sizes to
be extended behind of the input tensor in the `D` th dimension.
Outputs:
Tensor, the tensor after padding.
- If `mode` is "REFLECT", it uses a way of symmetrical copying throught the axis of symmetry to fill in.
If the `input_x` is [[1,2,3],[4,5,6],[7,8,9]] and `paddings` is [[1,1],[2,2]], then the
Outputs is [[6,5,4,5,6,5,4],[3,2,1,2,3,2,1],[6,5,4,5,6,5,4],[9,8,7,8,9,8,7],[6,5,4,5,6,5,4]].
- If `mode` is "SYMMETRIC", the filling method is similar to the "REFLECT". It is also copied
according to the symmetry axis, except that it includes the symmetry axis. If the `input_x`
is [[1,2,3],[4,5,6],[7,8,9]] and `paddings` is [[1,1],[2,2]], then the Outputs is
[[2,1,1,2,3,3,2],[2,1,1,2,3,3,2],[5,4,4,5,6,6,5],[8,7,7,8,9,9,8],[8,7,7,8,9,9,8]].
Examples:
>>> from mindspore import Tensor
>>> from mindspore.ops import operations as P
>>> import mindspore.nn as nn
>>> import numpy as np
>>> class Net(nn.Cell):
>>> def __init__(self):
>>> super(Net, self).__init__()
>>> self.pad = P.MirrorPad(mode="REFLECT")
>>> def construct(self, x, paddings):
>>> return self.pad(x, paddings)
>>> x = np.random.random(size=(2, 3)).astype(np.float32)
>>> paddings = Tensor([[1,1],[2,2]])
>>> pad = Net()
>>> ms_output = pad(Tensor(x), paddings)
"""
@prim_attr_register
def __init__(self, mode='REFLECT'):
"""Init Pad"""
validator.check_string('mode', mode, ['REFLECT', 'SYMMETRIC'], self.name)
self.mode = mode
self.set_const_input_indexes([1])
def __infer__(self, input_x, paddings):
validator.check_subclass("input_x", input_x['dtype'], mstype.tensor, self.name)
validator.check_subclass("paddings", paddings['dtype'], mstype.tensor, self.name)
x_shape = list(input_x['shape'])
paddings_value = paddings['value'].asnumpy()
paddings_size = paddings_value.size
validator.check_integer('paddings.shape', paddings_size, len(x_shape) * 2, Rel.EQ, self.name)
if not np.all(paddings_value >= 0):
raise ValueError('All elements of paddings must be >= 0.')
adjust = 0
if self.mode == 'SYMMETRIC':
adjust = 1
for i in range(0, int(paddings_size / 2)):
if (paddings_value[i, 0] >= x_shape[i] + adjust) or (paddings_value[i, 1] >= x_shape[i] + adjust):
raise ValueError('At least one dim has too high a padding value for this input and mode')
y_shape = ()
for i in range(0, int(paddings_size / 2)):
y_shape += ((x_shape[i] + paddings_value[i, 0] + paddings_value[i, 1]),)
return {'shape': y_shape,
'dtype': input_x['dtype'],
'value': None}
class ROIAlign(PrimitiveWithInfer):
"""
Computes Region of Interest (RoI) Align operator.
The operator computes the value of each sampling point by bilinear interpolation from the nearby grid points on the
feature map. No quantization is performed on any coordinates involved in the RoI, its bins, or the sampling
points. The details of (RoI) Align operator are described in `Mask R-CNN <https://arxiv.org/abs/1703.06870>`_.
Args:
pooled_height (int): The output features' height.
pooled_width (int): The output features' width.
spatial_scale (float): A scaling factor that maps the raw image coordinates to the input
feature map coordinates. Suppose the height of a RoI is `ori_h` in the raw image and `fea_h` in the
input feature map, the `spatial_scale` should be `fea_h / ori_h`.
sample_num (int): Number of sampling points. Default: 2.
roi_end_mode (int): Number must be 0 or 1. Default: 1.
Inputs:
- **features** (Tensor) - The input features, whose shape should be `(N, C, H, W)`.
- **rois** (Tensor) - The shape is `(rois_n, 5)`. With data type of float16 or float32.
`rois_n` represents the number of RoI. The size of the second dimension should be `5` and the `5` colunms
are `(image_index, top_left_x, top_left_y, bottom_right_x, bottom_right_y)`. `image_index` represents the
index of image. `top_left_x` and `top_left_y` represent the `x, y` coordinates of the top left corner
of corresponding RoI, respectively. `bottom_right_x` and `bottom_right_y` represent the `x, y`
coordinates of the bottom right corner of corresponding RoI, respectively.
Outputs:
Tensor, the shape is `(rois_n, C, pooled_height, pooled_width)`.
Examples:
>>> input_tensor = Tensor(np.array([[[[1., 2.], [3., 4.]]]]), mindspore.float32)
>>> rois = Tensor(np.array([[0, 0.2, 0.3, 0.2, 0.3]]), mindspore.float32)
>>> roi_align = P.ROIAlign(2, 2, 0.5, 2)
>>> output_tensor = roi_align(input_tensor, rois)
>>> assert output_tensor == Tensor(np.array([[[[2.15]]]]), mindspore.float32)
"""
@prim_attr_register
def __init__(self, pooled_height, pooled_width, spatial_scale, sample_num=2, roi_end_mode=1):
"""init ROIAlign"""
validator.check_value_type("pooled_height", pooled_height, [int], self.name)
validator.check_value_type("pooled_width", pooled_width, [int], self.name)
validator.check_value_type("spatial_scale", spatial_scale, [float], self.name)
validator.check_value_type("sample_num", sample_num, [int], self.name)
validator.check_value_type("roi_end_mode", roi_end_mode, [int], self.name)
validator.check_int_range("roi_end_mode", roi_end_mode, 0, 1, Rel.INC_BOTH, self.name)
self.pooled_height = pooled_height
self.pooled_width = pooled_width
self.spatial_scale = spatial_scale
self.sample_num = sample_num
self.roi_end_mode = roi_end_mode
def infer_shape(self, inputs_shape, rois_shape):
return [rois_shape[0], inputs_shape[1], self.pooled_height, self.pooled_width]
def infer_dtype(self, inputs_type, rois_type):
valid_types = (mstype.float16, mstype.float32)
validator.check_tensor_type_same({"inputs_type": inputs_type}, valid_types, self.name)
validator.check_tensor_type_same({"rois_type": rois_type}, valid_types, self.name)
return inputs_type
class Adam(PrimitiveWithInfer):
r"""
Updates gradients by Adaptive Moment Estimation (Adam) algorithm.
The Adam algorithm is proposed in `Adam: A Method for Stochastic Optimization <https://arxiv.org/abs/1412.6980>`_.
The updating formulas are as follows,
.. math::
\begin{array}{ll} \\
m = \beta_1 * m + (1 - \beta_1) * g \\
v = \beta_2 * v + (1 - \beta_2) * g * g \\
l = \alpha * \frac{\sqrt{1-\beta_2^t}}{1-\beta_1^t} \\
w = w - l * \frac{m}{\sqrt{v} + \epsilon}
\end{array}
:math:`m` represents the 1st moment vector, :math:`v` represents the 2nd moment vector, :math:`g` represents
`gradient`, :math:`l` represents scaling factor `lr`, :math:`\beta_1, \beta_2` represent `beta1` and `beta2`,
:math:`t` represents updating step while :math:`beta_1^t` and :math:`beta_2^t` represent `beta1_power` and
`beta2_power`, :math:`\alpha` represents `learning_rate`, :math:`w` represents `var`, :math:`\epsilon` represents
`epsilon`.
Args:
use_locking (bool): Whether to enable a lock to protect variable tensors from being updated.
If true, updates of the var, m, and v tensors will be protected by a lock.
If false, the result is unpredictable. Default: False.
use_nesterov (bool): Whether to use Nesterov Accelerated Gradient (NAG) algorithm to update the gradients.
If true, update the gradients using NAG.
If true, update the gradients without using NAG. Default: False.
Inputs:
- **var** (Tensor) - Weights to be updated.
- **m** (Tensor) - The 1st moment vector in the updating formula, has the same type as `var`.
- **v** (Tensor) - the 2nd moment vector in the updating formula.
Mean square gradients with the same type as `var`.
- **beta1_power** (float) - :math:`beta_1^t` in the updating formula.
- **beta2_power** (float) - :math:`beta_2^t` in the updating formula.
- **lr** (float) - :math:`l` in the updating formula.
- **beta1** (float) - The exponential decay rate for the 1st moment estimations.
- **beta2** (float) - The exponential decay rate for the 2nd moment estimations.
- **epsilon** (float) - Term added to the denominator to improve numerical stability.
- **gradient** (Tensor) - Gradients, has the same type as `var`.
Outputs:
Tuple of 3 Tensor, the updated parameters.
- **var** (Tensor) - The same shape and data type as `var`.
- **m** (Tensor) - The same shape and data type as `m`.
- **v** (Tensor) - The same shape and data type as `v`.
Examples:
>>> import numpy as np
>>> import mindspore.nn as nn
>>> from mindspore import Tensor, Parameter
>>> from mindspore.ops import operations as P
>>> class Net(nn.Cell):
>>> def __init__(self):
>>> super(Net, self).__init__()
>>> self.apply_adam = P.Adam()
>>> self.var = Parameter(Tensor(np.ones([3, 3, 3]).astype(np.float32)), name="var")
>>> self.m = Parameter(Tensor(np.ones([3, 3, 3]).astype(np.float32)), name="m")
>>> self.v = Parameter(Tensor(np.ones([3, 3, 3]).astype(np.float32)), name="v")
>>> def construct(self, beta1_power, beta2_power, lr, beta1, beta2, epsilon, grad):
>>> out = self.apply_adam(self.var, self.m, self.v, beta1_power, beta2_power, lr, beta1, beta2,
>>> epsilon, grad)
>>> return out
>>> net = Net()
>>> gradient = Tensor(np.random.rand(3, 3, 3).astype(np.float32))
>>> result = net(0.9, 0.999, 0.001, 0.9, 0.999, 1e-8, gradient)
"""
@prim_attr_register
def __init__(self, use_locking=False, use_nesterov=False):
validator.check_value_type("use_locking", use_locking, [bool], self.name)
validator.check_value_type("use_nesterov", use_nesterov, [bool], self.name)
def infer_shape(self, var_shape, m_shape, v_shape, beta1_power_shape, beta2_power_shape, lr_shape,
beta1_shape, beta2_shape, epsilon_shape, grad_shape):
validator.check("var_shape", var_shape, "m_shape", m_shape, Rel.EQ, self.name)
validator.check("var_shape", var_shape, "v_shape", v_shape, Rel.EQ, self.name)
validator.check("var_shape", var_shape, "grad_shape", grad_shape, Rel.EQ, self.name)
return var_shape, m_shape, v_shape
def infer_dtype(self, var_dtype, m_dtype, v_dtype, beta1_power_dtype, beta2_power_dtype, lr_dtype,
beta1_dtype, beta2_dtype, epsilon_dtype, grad_dtype):
args = {"var": var_dtype, "m": m_dtype, "v": v_dtype, "grad": grad_dtype}
validator.check_tensor_type_same(args, mstype.number_type, self.name)
args = {"beta1_power": beta1_power_dtype, "beta2_power": beta2_power_dtype, 'lr': lr_dtype,
"beta1": beta1_dtype, "beta2": beta2_dtype, "epsilon": epsilon_dtype}
validator.check_scalar_or_tensor_type_same(args, [mstype.float16, mstype.float32], self.name, True)
return var_dtype, m_dtype, v_dtype
class FusedSparseAdam(PrimitiveWithInfer):
r"""
Merge the duplicate value of the gradient and then update parameters by Adaptive Moment Estimation (Adam)
algorithm. This operator is used when the gradient is sparse.
The Adam algorithm is proposed in `Adam: A Method for Stochastic Optimization <https://arxiv.org/abs/1412.6980>`_.
The updating formulas are as follows,
.. math::
\begin{array}{ll} \\
m = \beta_1 * m + (1 - \beta_1) * g \\
v = \beta_2 * v + (1 - \beta_2) * g * g \\
l = \alpha * \frac{\sqrt{1-\beta_2^t}}{1-\beta_1^t} \\
w = w - l * \frac{m}{\sqrt{v} + \epsilon}
\end{array}
:math:`m` represents the 1st moment vector, :math:`v` represents the 2nd moment vector, :math:`g` represents
`gradient`, :math:`l` represents scaling factor `lr`, :math:`\beta_1, \beta_2` represent `beta1` and `beta2`,
:math:`t` represents updating step while :math:`beta_1^t` and :math:`beta_2^t` represent `beta1_power` and
`beta2_power`, :math:`\alpha` represents `learning_rate`, :math:`w` represents `var`, :math:`\epsilon` represents
`epsilon`.
All of inputs except `indices` comply with the implicit type conversion rules to make the data types consistent.
If they have different data types, lower priority data type will be converted to
relatively highest priority data type.
RuntimeError exception will be thrown when the data type conversion of Parameter is required.
Args:
use_locking (bool): Whether to enable a lock to protect variable tensors from being updated.
If true, updates of the var, m, and v tensors will be protected by a lock.
If false, the result is unpredictable. Default: False.
use_nesterov (bool): Whether to use Nesterov Accelerated Gradient (NAG) algorithm to update the gradients.
If true, update the gradients using NAG.
If true, update the gradients without using NAG. Default: False.
Inputs:
- **var** (Parameter) - Parameters to be updated with float32 data type.
- **m** (Parameter) - The 1st moment vector in the updating formula, has the same type as `var` with
float32 data type.
- **v** (Parameter) - The 2nd moment vector in the updating formula. Mean square gradients, has the same type as
`var` with float32 data type.
- **beta1_power** (Tensor) - :math:`beta_1^t` in the updating formula with float32 data type.
- **beta2_power** (Tensor) - :math:`beta_2^t` in the updating formula with float32 data type.
- **lr** (Tensor) - :math:`l` in the updating formula. With float32 data type.
- **beta1** (Tensor) - The exponential decay rate for the 1st moment estimations with float32 data type.
- **beta2** (Tensor) - The exponential decay rate for the 2nd moment estimations with float32 data type.
- **epsilon** (Tensor) - Term added to the denominator to improve numerical stability with float32 data type.
- **gradient** (Tensor) - Gradient value with float32 data type.
- **indices** (Tensor) - Gradient indices with int32 data type.
Outputs:
Tuple of 3 Tensors, this operator will update the input parameters directly, the outputs are useless.
- **var** (Tensor) - A Tensor with shape (1,).
- **m** (Tensor) - A Tensor with shape (1,).
- **v** (Tensor) - A Tensor with shape (1,).
Examples:
>>> import numpy as np
>>> import mindspore.nn as nn
>>> from mindspore import Tensor, Parameter
>>> from mindspore.ops import operations as P
>>> import mindspore.common.dtype as mstype
>>> class Net(nn.Cell):
>>> def __init__(self):
>>> super(Net, self).__init__()
>>> self.sparse_apply_adam = P.FusedSparseAdam()
>>> self.var = Parameter(Tensor(np.ones([3, 1, 2]).astype(np.float32)), name="var")
>>> self.m = Parameter(Tensor(np.ones([3, 1, 2]).astype(np.float32)), name="m")
>>> self.v = Parameter(Tensor(np.ones([3, 1, 2]).astype(np.float32)), name="v")
>>> def construct(self, beta1_power, beta2_power, lr, beta1, beta2, epsilon, grad, indices):
>>> out = self.sparse_apply_adam(self.var, self.m, self.v, beta1_power, beta2_power, lr, beta1, beta2,
>>> epsilon, grad, indices)
>>> return out
>>> net = Net()
>>> beta1_power = Tensor(0.9, mstype.float32)
>>> beta2_power = Tensor(0.999, mstype.float32)
>>> lr = Tensor(0.001, mstype.float32)
>>> beta1 = Tensor(0.9, mstype.float32)
>>> beta2 = Tensor(0.999, mstype.float32)
>>> epsilon = Tensor(1e-8, mstype.float32)
>>> gradient = Tensor(np.random.rand(2, 1, 2), mstype.float32)
>>> indices = Tensor([0, 1], mstype.int32)
>>> result = net(beta1_power, beta2_power, lr, beta1, beta2, epsilon, gradient, indices)
"""
__mindspore_signature__ = (
sig.make_sig('var', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('m', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('v', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('beta1_power', dtype=sig.sig_dtype.T),
sig.make_sig('beta2_power', dtype=sig.sig_dtype.T),
sig.make_sig('lr', dtype=sig.sig_dtype.T),
sig.make_sig('beta1', dtype=sig.sig_dtype.T),
sig.make_sig('beta2', dtype=sig.sig_dtype.T),
sig.make_sig('epsilon', dtype=sig.sig_dtype.T),
sig.make_sig('grad', dtype=sig.sig_dtype.T),
sig.make_sig('indices', dtype=sig.sig_dtype.T1),
)
@prim_attr_register
def __init__(self, use_locking=False, use_nesterov=False):
validator.check_value_type("use_locking", use_locking, [bool], self.name)
validator.check_value_type("use_nesterov", use_nesterov, [bool], self.name)
self.init_prim_io_names(inputs=['var', 'm', 'v', 'beta1_power', 'beta2_power', 'lr', 'beta1', 'beta2',
'epsilon', 'grad', 'indices'],
outputs=['var', 'm', 'v'])
def infer_shape(self, var_shape, m_shape, v_shape, beta1_power_shape, beta2_power_shape, lr_shape,
beta1_shape, beta2_shape, epsilon_shape, grad_shape, indices_shape):
validator.check("var_shape", var_shape, "m_shape", m_shape, Rel.EQ, self.name)
validator.check("var_shape", var_shape, "v_shape", v_shape, Rel.EQ, self.name)
validator.check_integer("indices rank", len(indices_shape), 1, Rel.EQ, self.name)
validator.check('grad_shape[0]', grad_shape[0], 'indices_shape[0]', indices_shape[0], Rel.EQ, self.name)
if len(var_shape) > 1 and grad_shape != indices_shape + var_shape[1:]:
raise ValueError(f"For '{self.name}', the shape of updates should be [] or "
f"grad_shape = indices_shape + var_shape[1:], but got var_shape: {var_shape}, "
f"indices_shape: {indices_shape}, grad_shape: {grad_shape}.")
return [1], [1], [1]
def infer_dtype(self, var_dtype, m_dtype, v_dtype, beta1_power_dtype, beta2_power_dtype, lr_dtype,
beta1_dtype, beta2_dtype, epsilon_dtype, grad_dtype, indices_dtype):
args = {"var": var_dtype, "m": m_dtype, "v": v_dtype, "grad": grad_dtype}
validator.check_tensor_type_same(args, mstype.number_type, self.name)
args = {"beta1_power": beta1_power_dtype, "beta2_power": beta2_power_dtype, 'lr': lr_dtype,
"beta1": beta1_dtype, "beta2": beta2_dtype, "epsilon": epsilon_dtype}
validator.check_scalar_or_tensor_type_same(args, [mstype.float16, mstype.float32], self.name, True)
validator.check_tensor_type_same({"indices_dtype": indices_dtype}, [mstype.int32], self.name)
return var_dtype, m_dtype, v_dtype
class FusedSparseLazyAdam(PrimitiveWithInfer):
r"""
Merge the duplicate value of the gradient and then update parameters by Adaptive Moment Estimation (Adam)
algorithm. This operator is used when the gradient is sparse. The behavior is not equivalent to the
original Adam algorithm, as only the current indices parameters will be updated.
The Adam algorithm is proposed in `Adam: A Method for Stochastic Optimization <https://arxiv.org/abs/1412.6980>`_.
The updating formulas are as follows,
.. math::
\begin{array}{ll} \\
m = \beta_1 * m + (1 - \beta_1) * g \\
v = \beta_2 * v + (1 - \beta_2) * g * g \\
l = \alpha * \frac{\sqrt{1-\beta_2^t}}{1-\beta_1^t} \\
w = w - l * \frac{m}{\sqrt{v} + \epsilon}
\end{array}
:math:`m` represents the 1st moment vector, :math:`v` represents the 2nd moment vector, :math:`g` represents
`gradient`, :math:`l` represents scaling factor `lr`, :math:`\beta_1, \beta_2` represent `beta1` and `beta2`,
:math:`t` represents updating step while :math:`beta_1^t` and :math:`beta_2^t` represent `beta1_power` and
`beta2_power`, :math:`\alpha` represents `learning_rate`, :math:`w` represents `var`, :math:`\epsilon` represents
`epsilon`.
All of inputs except `indices` comply with the implicit type conversion rules to make the data types consistent.
If they have different data types, lower priority data type will be converted to
relatively highest priority data type.
RuntimeError exception will be thrown when the data type conversion of Parameter is required.
Args:
use_locking (bool): Whether to enable a lock to protect variable tensors from being updated.
If true, updates of the var, m, and v tensors will be protected by a lock.
If false, the result is unpredictable. Default: False.
use_nesterov (bool): Whether to use Nesterov Accelerated Gradient (NAG) algorithm to update the gradients.
If true, update the gradients using NAG.
If true, update the gradients without using NAG. Default: False.
Inputs:
- **var** (Parameter) - Parameters to be updated with float32 data type.
- **m** (Parameter) - The 1st moment vector in the updating formula, has the same type as `var` with
float32 data type.
- **v** (Parameter) - The 2nd moment vector in the updating formula. Mean square gradients, has the same type as
`var` with float32 data type.
- **beta1_power** (Tensor) - :math:`beta_1^t` in the updating formula with float32 data type.
- **beta2_power** (Tensor) - :math:`beta_2^t` in the updating formula with float32 data type.
- **lr** (Tensor) - :math:`l` in the updating formula with float32 data type.
- **beta1** (Tensor) - The exponential decay rate for the 1st moment estimations with float32 data type.
- **beta2** (Tensor) - The exponential decay rate for the 2nd moment estimations with float32 data type.
- **epsilon** (Tensor) - Term added to the denominator to improve numerical stability with float32 data type.
- **gradient** (Tensor) - Gradient value with float32 data type.
- **indices** (Tensor) - Gradient indices with int32 data type.
Outputs:
Tuple of 3 Tensors, this operator will update the input parameters directly, the outputs are useless.
- **var** (Tensor) - A Tensor with shape (1,).
- **m** (Tensor) - A Tensor with shape (1,).
- **v** (Tensor) - A Tensor with shape (1,).
Examples:
>>> import numpy as np
>>> import mindspore.nn as nn
>>> from mindspore import Tensor, Parameter
>>> from mindspore.ops import operations as P
>>> import mindspore.common.dtype as mstype
>>> class Net(nn.Cell):
>>> def __init__(self):
>>> super(Net, self).__init__()
>>> self.sparse_apply_lazyadam = P.FusedSparseLazyAdam()
>>> self.var = Parameter(Tensor(np.ones([3, 1, 2]).astype(np.float32)), name="var")
>>> self.m = Parameter(Tensor(np.ones([3, 1, 2]).astype(np.float32)), name="m")
>>> self.v = Parameter(Tensor(np.ones([3, 1, 2]).astype(np.float32)), name="v")
>>> def construct(self, beta1_power, beta2_power, lr, beta1, beta2, epsilon, grad, indices):
>>> out = self.sparse_apply_lazyadam(self.var, self.m, self.v, beta1_power, beta2_power, lr, beta1,
>>> beta2, epsilon, grad, indices)
>>> return out
>>> net = Net()
>>> beta1_power = Tensor(0.9, mstype.float32)
>>> beta2_power = Tensor(0.999, mstype.float32)
>>> lr = Tensor(0.001, mstype.float32)
>>> beta1 = Tensor(0.9, mstype.float32)
>>> beta2 = Tensor(0.999, mstype.float32)
>>> epsilon = Tensor(1e-8, mstype.float32)
>>> gradient = Tensor(np.random.rand(2, 1, 2), mstype.float32)
>>> indices = Tensor([0, 1], mstype.int32)
>>> result = net(beta1_power, beta2_power, lr, beta1, beta2, epsilon, gradient, indices)
"""
__mindspore_signature__ = (
sig.make_sig('var', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('m', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('v', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('beta1_power', dtype=sig.sig_dtype.T),
sig.make_sig('beta2_power', dtype=sig.sig_dtype.T),
sig.make_sig('lr', dtype=sig.sig_dtype.T),
sig.make_sig('beta1', dtype=sig.sig_dtype.T),
sig.make_sig('beta2', dtype=sig.sig_dtype.T),
sig.make_sig('epsilon', dtype=sig.sig_dtype.T),
sig.make_sig('grad', dtype=sig.sig_dtype.T),
sig.make_sig('indices', dtype=sig.sig_dtype.T1),
)
@prim_attr_register
def __init__(self, use_locking=False, use_nesterov=False):
validator.check_value_type("use_locking", use_locking, [bool], self.name)
validator.check_value_type("use_nesterov", use_nesterov, [bool], self.name)
self.init_prim_io_names(inputs=['var', 'm', 'v', 'beta1_power', 'beta2_power', 'lr', 'beta1', 'beta2',
'epsilon', 'grad', 'indices'],
outputs=['var', 'm', 'v'])
def infer_shape(self, var_shape, m_shape, v_shape, beta1_power_shape, beta2_power_shape, lr_shape,
beta1_shape, beta2_shape, epsilon_shape, grad_shape, indices_shape):
validator.check("var_shape", var_shape, "m_shape", m_shape, Rel.EQ, self.name)
validator.check("var_shape", var_shape, "v_shape", v_shape, Rel.EQ, self.name)
validator.check_integer("indices rank", len(indices_shape), 1, Rel.EQ, self.name)
validator.check('grad_shape[0]', grad_shape[0], 'indices_shape[0]', indices_shape[0], Rel.EQ, self.name)
if len(var_shape) > 1 and grad_shape != indices_shape + var_shape[1:]:
raise ValueError(f"For '{self.name}', the shape of updates should be [] or "
f"grad_shape = indices_shape + var_shape[1:], but got var_shape: {var_shape}, "
f"indices_shape: {indices_shape}, grad_shape: {grad_shape}.")
return [1], [1], [1]
def infer_dtype(self, var_dtype, m_dtype, v_dtype, beta1_power_dtype, beta2_power_dtype, lr_dtype,
beta1_dtype, beta2_dtype, epsilon_dtype, grad_dtype, indices_dtype):
args = {"var": var_dtype, "m": m_dtype, "v": v_dtype, "grad": grad_dtype}
validator.check_tensor_type_same(args, mstype.number_type, self.name)
args = {"beta1_power": beta1_power_dtype, "beta2_power": beta2_power_dtype, 'lr': lr_dtype,
"beta1": beta1_dtype, "beta2": beta2_dtype, "epsilon": epsilon_dtype}
validator.check_scalar_or_tensor_type_same(args, [mstype.float16, mstype.float32], self.name, True)
validator.check_tensor_type_same({"indices_dtype": indices_dtype}, [mstype.int32], self.name)
return var_dtype, m_dtype, v_dtype
class FusedSparseFtrl(PrimitiveWithInfer):
"""
Merge the duplicate value of the gradient and then update relevant entries according to the FTRL-proximal scheme.
All of inputs except `indices` comply with the implicit type conversion rules to make the data types consistent.
If they have different data types, lower priority data type will be converted to
relatively highest priority data type.
RuntimeError exception will be thrown when the data type conversion of Parameter is required.
Args:
lr (float): The learning rate value, must be positive.
l1 (float): l1 regularization strength, must be greater than or equal to zero.
l2 (float): l2 regularization strength, must be greater than or equal to zero.
lr_power (float): Learning rate power controls how the learning rate decreases during training,
must be less than or equal to zero. Use fixed learning rate if `lr_power` is zero.
use_locking (bool): Use locks for updating operation if True . Default: False.
Inputs:
- **var** (Parameter) - The variable to be updated. The data type must be float32.
- **accum** (Parameter) - The accumulation to be updated, must be same type and shape as `var`.
- **linear** (Parameter) - the linear coefficient to be updated, must be same type and shape as `var`.
- **grad** (Tensor) - A tensor of the same type as `var`, for the gradient.
- **indices** (Tensor) - A vector of indices into the first dimension of `var` and `accum`. The shape
of `indices` must be the same as `grad` in first dimension. The type must be int32.
Outputs:
Tuple of 3 Tensor, this operator will update the input parameters directly, the outputs are useless.
- **var** (Tensor) - A Tensor with shape (1,).
- **accum** (Tensor) - A Tensor with shape (1,).
- **linear** (Tensor) - A Tensor with shape (1,).
Examples:
>>> import mindspore
>>> import mindspore.nn as nn
>>> import numpy as np
>>> from mindspore import Parameter
>>> from mindspore import Tensor
>>> from mindspore.ops import operations as P
>>> class SparseApplyFtrlNet(nn.Cell):
>>> def __init__(self):
>>> super(SparseApplyFtrlNet, self).__init__()
>>> self.sparse_apply_ftrl = P.FusedSparseFtrl(lr=0.01, l1=0.0, l2=0.0, lr_power=-0.5)
>>> self.var = Parameter(Tensor(np.random.rand(3, 1, 2).astype(np.float32)), name="var")
>>> self.accum = Parameter(Tensor(np.random.rand(3, 1, 2).astype(np.float32)), name="accum")
>>> self.linear = Parameter(Tensor(np.random.rand(3, 1, 2).astype(np.float32)), name="linear")
>>>
>>> def construct(self, grad, indices):
>>> out = self.sparse_apply_ftrl(self.var, self.accum, self.linear, grad, indices)
>>> return out
>>>
>>> net = SparseApplyFtrlNet()
>>> grad = Tensor(np.random.rand(2, 1, 2).astype(np.float32))
>>> indices = Tensor(np.array([0, 1]).astype(np.int32))
>>> output = net(grad, indices)
"""
__mindspore_signature__ = (
sig.make_sig('var', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('accum', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('linear', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('grad', dtype=sig.sig_dtype.T),
sig.make_sig('indices', dtype=sig.sig_dtype.T1),
)
@prim_attr_register
def __init__(self, lr, l1, l2, lr_power, use_locking=False):
self.init_prim_io_names(inputs=['var', 'accum', 'linear', 'grad', 'indices'],
outputs=['output'])
validator.check_value_type("lr", lr, [float], self.name)
validator.check_value_type("l1", l1, [float], self.name)
validator.check_value_type("l2", l2, [float], self.name)
validator.check_value_type("lr_power", lr_power, [float], self.name)
self.lr = validator.check_number_range("lr", lr, 0.0, float("inf"), Rel.INC_NEITHER, self.name)
self.l1 = validator.check_number_range("l1", l1, 0.0, float("inf"), Rel.INC_LEFT, self.name)
self.l2 = validator.check_number_range("l2", l2, 0.0, float("inf"), Rel.INC_LEFT, self.name)
self.lr_power = validator.check_number("lr_power", lr_power, 0, Rel.LE, self.name)
self.use_locking = validator.check_value_type("use_locking", use_locking, [bool], self.name)
def infer_shape(self, var_shape, accum_shape, linear_shape, grad_shape, indices_shape):
validator.check('var shape', var_shape, 'accum shape', accum_shape, Rel.EQ, self.name)
validator.check('var shape', var_shape, 'linear shape', linear_shape, Rel.EQ, self.name)
if len(var_shape) > 1:
validator.check('var_shape[1:]', var_shape[1:], 'grad_shape[1:]', grad_shape[1:], Rel.EQ, self.name)
validator.check_integer("indices rank", len(indices_shape), 1, Rel.EQ, self.name)
validator.check('grad_shape[0]', grad_shape[0], 'indices_shape[0]', indices_shape[0], Rel.EQ, self.name)
return [1], [1], [1]
def infer_dtype(self, var_dtype, accum_dtype, linear_dtype, grad_dtype, indices_dtype):
args = {"var_dtype": var_dtype, "accum_dtype": accum_dtype,
"linear_dtype": linear_dtype, "grad_dtype": grad_dtype}
validator.check_tensor_type_same(args, [mstype.float32], self.name)
validator.check_tensor_type_same({"indices_dtype": indices_dtype}, [mstype.int32], self.name)
return var_dtype, accum_dtype, linear_dtype
class FusedSparseProximalAdagrad(PrimitiveWithInfer):
r"""
Merge the duplicate value of the gradient and then update relevant entries according to the proximal adagrad
algorithm.
.. math::
accum += grad * grad
.. math::
\text{prox_v} = var - lr * grad * \frac{1}{\sqrt{accum}}
.. math::
var = \frac{sign(\text{prox_v})}{1 + lr * l2} * \max(\left| \text{prox_v} \right| - lr * l1, 0)
All of inputs except `indices` comply with the implicit type conversion rules to make the data types consistent.
If they have different data types, lower priority data type will be converted to
relatively highest priority data type.
RuntimeError exception will be thrown when the data type conversion of Parameter is required.
Args:
use_locking (bool): If true, the variable and accumulation tensors will be protected from being updated.
Default: False.
Inputs:
- **var** (Parameter) - Variable tensor to be updated. The data type must be float32.
- **accum** (Parameter) - Variable tensor to be updated, has the same dtype as `var`.
- **lr** (Tensor) - The learning rate value. The data type must be float32.
- **l1** (Tensor) - l1 regularization strength. The data type must be float32.
- **l2** (Tensor) - l2 regularization strength. The data type must be float32.
- **grad** (Tensor) - A tensor of the same type as `var`, for the gradient. The data type must be float32.
- **indices** (Tensor) - A vector of indices into the first dimension of `var` and `accum`. The data type
must be int32.
Outputs:
Tuple of 2 Tensors, this operator will update the input parameters directly, the outputs are useless.
- **var** (Tensor) - A Tensor with shape (1,).
- **accum** (Tensor) - A Tensor with shape (1,).
Examples:
>>> import numpy as np
>>> import mindspore.nn as nn
>>> from mindspore import Tensor, Parameter
>>> from mindspore.ops import operations as P
>>> class Net(nn.Cell):
>>> def __init__(self):
>>> super(Net, self).__init__()
>>> self.sparse_apply_proximal_adagrad = P.FusedSparseProximalAdagrad()
>>> self.var = Parameter(Tensor(np.random.rand(3, 1, 2).astype(np.float32)), name="var")
>>> self.accum = Parameter(Tensor(np.random.rand(3, 1, 2).astype(np.float32)), name="accum")
>>> self.lr = Tensor(0.01, mstype.float32)
>>> self.l1 = Tensor(0.0, mstype.float32)
>>> self.l2 = Tensor(0.0, mstype.float32)
>>> def construct(self, grad, indices):
>>> out = self.sparse_apply_proximal_adagrad(self.var, self.accum, self.lr, self.l1,
>>> self.l2, grad, indices)
>>> return out
>>> net = Net()
>>> grad = Tensor(np.random.rand(2, 1, 2).astype(np.float32))
>>> indices = Tensor(np.array([0, 1]).astype(np.int32))
>>> output = net(grad, indices)
"""
__mindspore_signature__ = (
sig.make_sig('var', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('accum', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('lr', dtype=sig.sig_dtype.T),
sig.make_sig('l1', dtype=sig.sig_dtype.T),
sig.make_sig('l2', dtype=sig.sig_dtype.T),
sig.make_sig('grad', dtype=sig.sig_dtype.T),
sig.make_sig('indices', dtype=sig.sig_dtype.T1),
)
@prim_attr_register
def __init__(self, use_locking=False):
self.init_prim_io_names(inputs=['var', 'accum', 'lr', 'l1', 'l2', 'grad', 'indices'],
outputs=['output'])
self.use_locking = validator.check_value_type("use_locking", use_locking, [bool], self.name)
def infer_shape(self, var_shape, accum_shape, lr_shape, l1_shape, l2_shape, grad_shape, indices_shape):
validator.check_integer("indices rank", len(indices_shape), 1, Rel.EQ, self.name)
return [1], [1]
def infer_dtype(self, var_dtype, accum_dtype, lr_dtype, l1_dtype, l2_dtype, grad_dtype, indices_dtype):
args = {'var': var_dtype, 'accum': accum_dtype, 'grad': grad_dtype}
validator.check_tensor_type_same(args, [mstype.float32], self.name)
validator.check_scalar_or_tensor_type_same({"lr": lr_dtype}, [mstype.float32], self.name)
validator.check_scalar_or_tensor_type_same({"l1": l1_dtype}, [mstype.float32], self.name)
validator.check_scalar_or_tensor_type_same({"l2": l2_dtype}, [mstype.float32], self.name)
valid_types = [mstype.int16, mstype.int32, mstype.int64,
mstype.uint16, mstype.uint32, mstype.uint64]
validator.check_tensor_type_same({'indices': indices_dtype}, valid_types, self.name)
return var_dtype, accum_dtype
class KLDivLoss(PrimitiveWithInfer):
r"""
Computes the Kullback-Leibler divergence between the target and the output.
Note:
Sets input as :math:`x`, input label as :math:`y`, output as :math:`\ell(x, y)`.
Let,
.. math::
L = \{l_1,\dots,l_N\}^\top, \quad
l_n = y_n \cdot (\log y_n - x_n)
Then,
.. math::
\ell(x, y) = \begin{cases}
L, & \text{if reduction} = \text{`none';}\\
\operatorname{mean}(L), & \text{if reduction} = \text{`mean';}\\
\operatorname{sum}(L), & \text{if reduction} = \text{`sum'.}
\end{cases}
Args:
reduction (str): Specifies the reduction to be applied to the output.
Its value should be one of 'none', 'mean', 'sum'. Default: 'mean'.
Inputs:
- **input_x** (Tensor) - The input Tensor. The data type must be float32.
- **input_y** (Tensor) - The label Tensor which has the same shape as `input_x`. The data type must be float32.
Outputs:
Tensor or Scalar, if `reduction` is 'none', then output is a tensor and has the same shape as `input_x`.
Otherwise it is a scalar.
Examples:
>>> import mindspore
>>> import mindspore.nn as nn
>>> import numpy as np
>>> from mindspore import Tensor
>>> from mindspore.ops import operations as P
>>> class Net(nn.Cell):
>>> def __init__(self):
>>> super(Net, self).__init__()
>>> self.kldiv_loss = P.KLDivLoss()
>>> def construct(self, x, y):
>>> result = self.kldiv_loss(x, y)
>>> return result
>>>
>>> net = Net()
>>> input_x = Tensor(np.array([0.2, 0.7, 0.1]), mindspore.float32)
>>> input_y = Tensor(np.array([0., 1., 0.]), mindspore.float32)
>>> result = net(input_x, input_y)
"""
@prim_attr_register
def __init__(self, reduction='mean'):
self.reduction = validator.check_string('reduction', reduction, ['none', 'mean', 'sum'], self.name)
def infer_shape(self, x_shape, y_shape):
validator.check('x_shape', x_shape, 'y_shape', y_shape, Rel.EQ, self.name)
if self.reduction in ('mean', 'sum'):
shape = []
else:
shape = x_shape
return shape
def infer_dtype(self, x_type, y_type):
args = {'x': x_type, 'y': y_type}
valid_types = (mstype.float16, mstype.float32)
validator.check_tensor_type_same(args, valid_types, self.name)
return x_type
class BinaryCrossEntropy(PrimitiveWithInfer):
r"""
Computes the Binary Cross Entropy between the target and the output.
Note:
Sets input as :math:`x`, input label as :math:`y`, output as :math:`\ell(x, y)`.
Let,
.. math::
L = \{l_1,\dots,l_N\}^\top, \quad
l_n = - w_n \left[ y_n \cdot \log x_n + (1 - y_n) \cdot \log (1 - x_n) \right]
Then,
.. math::
\ell(x, y) = \begin{cases}
L, & \text{if reduction} = \text{`none';}\\
\operatorname{mean}(L), & \text{if reduction} = \text{`mean';}\\
\operatorname{sum}(L), & \text{if reduction} = \text{`sum'.}
\end{cases}
Args:
reduction (str): Specifies the reduction to be applied to the output.
Its value should be one of 'none', 'mean', 'sum'. Default: 'mean'.
Inputs:
- **input_x** (Tensor) - The input Tensor. The data type should be float16 or float32.
- **input_y** (Tensor) - The label Tensor which has same shape and data type as `input_x`.
- **weight** (Tensor, optional) - A rescaling weight applied to the loss of each batch element.
And it should have same shape and data type as `input_x`. Default: None.
Outputs:
Tensor or Scalar, if `reduction` is 'none', then output is a tensor and has the same shape as `input_x`.
Otherwise, the output is a scalar.
Examples:
>>> import mindspore
>>> import mindspore.nn as nn
>>> import numpy as np
>>> from mindspore import Tensor
>>> from mindspore.ops import operations as P
>>> class Net(nn.Cell):
>>> def __init__(self):
>>> super(Net, self).__init__()
>>> self.binary_cross_entropy = P.BinaryCrossEntropy()
>>> def construct(self, x, y, weight):
>>> result = self.binary_cross_entropy(x, y, weight)
>>> return result
>>>
>>> net = Net()
>>> input_x = Tensor(np.array([0.2, 0.7, 0.1]), mindspore.float32)
>>> input_y = Tensor(np.array([0., 1., 0.]), mindspore.float32)
>>> weight = Tensor(np.array([1, 2, 2]), mindspore.float32)
>>> result = net(input_x, input_y, weight)
0.38240486
"""
@prim_attr_register
def __init__(self, reduction='mean'):
self.reduction = validator.check_string('reduction', reduction, ['none', 'mean', 'sum'], self.name)
def infer_shape(self, x_shape, y_shape, weight_shape):
validator.check('x_shape', x_shape, 'y_shape', y_shape, Rel.EQ, self.name)
if weight_shape:
validator.check('y_shape', y_shape, 'weight_shape', weight_shape, Rel.EQ, self.name)
if self.reduction in ('mean', 'sum'):
shape = []
else:
shape = x_shape
return shape
def infer_dtype(self, x_type, y_type, weight_type):
args = {'x': x_type, 'y': y_type}
valid_types = (mstype.float16, mstype.float32)
validator.check_tensor_type_same(args, valid_types, self.name)
if weight_type:
validator.check_tensor_type_same({'x': x_type, 'weight': weight_type}, valid_types, self.name)
return x_type
class ApplyAdaMax(PrimitiveWithInfer):
r"""
Update relevant entries according to the adamax scheme.
The updating formulas are as follows,
.. math::
\begin{array}{ll} \\
m_{t} = \beta_1 * m_{t-1} + (1 - \beta_1) * g \\
v_{t} = \max(\beta_2 * v_{t-1}, \left| g \right|) \\
var = var - \frac{l}{1 - \beta_1^t} * \frac{m_{t}}{v_{t} + \epsilon}
\end{array}
:math:`t` represents updating step while :math:`m` represents the 1st moment vector, :math:`m_{t-1}`
is the last momentent of :math:`m_{t}`, :math:`v` represents the 2nd moment vector, :math:`v_{t-1}`
is the last momentent of :math:`v_{t}`, :math:`l` represents scaling factor `lr`,
:math:`g` represents `grad`, :math:`\beta_1, \beta_2` represent `beta1` and `beta2`,
:math:`beta_1^t` represents `beta1_power`, :math:`var` represents the variable to be updated,
:math:`\epsilon` represents `epsilon`.
Inputs of `var`, `m`, `v` and `grad` comply with the implicit type conversion rules
to make the data types consistent.
If they have different data types, lower priority data type will be converted to
relatively highest priority data type.
RuntimeError exception will be thrown when the data type conversion of Parameter is required.
Inputs:
- **var** (Parameter) - Variable to be updated. With float32 or float16 data type.
- **m** (Parameter) - The 1st moment vector in the updating formula, has the same shape and type as `var`.
With float32 or float16 data type.
- **v** (Parameter) - The 2nd moment vector in the updating formula. Mean square gradients
with the same shape and type as `var`. With float32 or float16 data type.
- **beta1_power** (Union[Number, Tensor]) - :math:`beta_1^t` in the updating formula, should be scalar.
With float32 or float16 data type.
- **lr** (Union[Number, Tensor]) - Learning rate, :math:`l` in the updating formula, should be scalar.
With float32 or float16 data type.
- **beta1** (Union[Number, Tensor]) - The exponential decay rate for the 1st moment estimations,
should be scalar. With float32 or float16 data type.
- **beta2** (Union[Number, Tensor]) - The exponential decay rate for the 2nd moment estimations,
should be scalar. With float32 or float16 data type.
- **epsilon** (Union[Number, Tensor]) - A small value added for numerical stability, should be scalar.
With float32 or float16 data type.
- **grad** (Tensor) - A tensor for gradient, has the same shape and type as `var`.
With float32 or float16 data type.
Outputs:
Tuple of 3 Tensor, the updated parameters.
- **var** (Tensor) - The same shape and data type as `var`.
- **m** (Tensor) - The same shape and data type as `m`.
- **v** (Tensor) - The same shape and data type as `v`.
Examples:
>>> import numpy as np
>>> import mindspore.nn as nn
>>> from mindspore import Tensor, Parameter
>>> from mindspore.ops import operations as P
>>> import mindspore.common.dtype as mstype
>>> class Net(nn.Cell):
>>> def __init__(self):
>>> super(Net, self).__init__()
>>> self.apply_ada_max = P.ApplyAdaMax()
>>> self.var = Parameter(Tensor(np.random.rand(3, 3).astype(np.float32)), name="var")
>>> self.m = Parameter(Tensor(np.random.rand(3, 3).astype(np.float32)), name="m")
>>> self.v = Parameter(Tensor(np.random.rand(3, 3).astype(np.float32)), name="v")
>>> def construct(self, beta1_power, lr, beta1, beta2, epsilon, grad):
>>> out = self.apply_ada_max(self.var, self.m, self.v, beta1_power, lr, beta1, beta2, epsilon, grad)
>>> return out
>>> net = Net()
>>> beta1_power =Tensor(0.9, mstype.float32)
>>> lr = Tensor(0.001, mstype.float32)
>>> beta1 = Tensor(0.9, mstype.float32)
>>> beta2 = Tensor(0.99, mstype.float32)
>>> epsilon = Tensor(1e-10, mstype.float32)
>>> grad = Tensor(np.random.rand(3, 3).astype(np.float32))
>>> result = net(beta1_power, lr, beta1, beta2, epsilon, grad)
"""
__mindspore_signature__ = (
sig.make_sig('var', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('m', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('v', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('beta1_power', dtype=sig.sig_dtype.T1),
sig.make_sig('lr', dtype=sig.sig_dtype.T2),
sig.make_sig('beta1', dtype=sig.sig_dtype.T3),
sig.make_sig('beta2', dtype=sig.sig_dtype.T4),
sig.make_sig('epsilon', dtype=sig.sig_dtype.T5),
sig.make_sig('grad', dtype=sig.sig_dtype.T),
)
@prim_attr_register
def __init__(self):
"""init ApplyAdaMax"""
def infer_shape(self, var_shape, m_shape, v_shape, beta1_power_shape, lr_shape,
beta1_shape, beta2_shape, epsilon_shape, grad_shape):
validator.check("m_shape", m_shape, "var_shape", var_shape, Rel.EQ, self.name)
validator.check("v_shape", v_shape, "var_shape", var_shape, Rel.EQ, self.name)
validator.check("grad_shape", grad_shape, "var_shape", var_shape, Rel.EQ, self.name)
beta1_power_shp_len = len(beta1_power_shape)
validator.check_integer("beta1 power's rank", beta1_power_shp_len, 1, Rel.LE, self.name)
if beta1_power_shp_len == 1:
validator.check_integer("beta1_power_shape[0]", beta1_power_shape[0], 1, Rel.EQ, self.name)
lr_shp_len = len(lr_shape)
validator.check_integer("lr's rank", lr_shp_len, 1, Rel.LE, self.name)
if lr_shp_len == 1:
validator.check_integer("lr_shape[0]", lr_shape[0], 1, Rel.EQ, self.name)
beta1_shp_len = len(beta1_shape)
validator.check_integer("beta1's rank", beta1_shp_len, 1, Rel.LE, self.name)
if beta1_shp_len == 1:
validator.check_integer("beta1_shape[0]", beta1_shape[0], 1, Rel.EQ, self.name)
beta2_shp_len = len(beta2_shape)
validator.check_integer("beta2's rank", beta2_shp_len, 1, Rel.LE, self.name)
if beta2_shp_len == 1:
validator.check_integer("beta2_shape[0]", beta2_shape[0], 1, Rel.EQ, self.name)
epsilon_shp_len = len(epsilon_shape)
validator.check_integer("epsilon's rank", epsilon_shp_len, 1, Rel.LE, self.name)
if epsilon_shp_len == 1:
validator.check_integer("epsilon_shape[0]", epsilon_shape[0], 1, Rel.EQ, self.name)
return var_shape, m_shape, v_shape
def infer_dtype(self, var_dtype, m_dtype, v_dtype, beta1_power_dtype, lr_dtype,
beta1_dtype, beta2_dtype, epsilon_dtype, grad_dtype):
valid_types = [mstype.float16, mstype.float32]
args = {"var": var_dtype, "m": m_dtype, "v": v_dtype, "grad": grad_dtype}
validator.check_tensor_type_same(args, valid_types, self.name)
validator.check_scalar_or_tensor_type_same({"beta1_power": beta1_power_dtype}, valid_types, self.name)
validator.check_scalar_or_tensor_type_same({"lr": lr_dtype}, valid_types, self.name)
validator.check_scalar_or_tensor_type_same({"beta1": beta1_dtype}, valid_types, self.name)
validator.check_scalar_or_tensor_type_same({"beta2": beta2_dtype}, valid_types, self.name)
validator.check_scalar_or_tensor_type_same({"epsilon": epsilon_dtype}, valid_types, self.name)
return var_dtype, m_dtype, v_dtype
class ApplyAdadelta(PrimitiveWithInfer):
r"""
Update relevant entries according to the adadelta scheme.
.. math::
accum = \rho * accum + (1 - \rho) * grad^2
.. math::
\text{update} = \sqrt{\text{accum_update} + \epsilon} * \frac{grad}{\sqrt{accum + \epsilon}}
.. math::
\text{accum_update} = \rho * \text{accum_update} + (1 - \rho) * update^2
.. math::
var -= lr * update
Inputs of `var`, `accum`, `accum_update` and `grad` comply with the implicit type conversion rules
to make the data types consistent.
If they have different data types, lower priority data type will be converted to
relatively highest priority data type.
RuntimeError exception will be thrown when the data type conversion of Parameter is required.
Inputs:
- **var** (Parameter) - Weights to be updated. With float32 or float16 data type.
- **accum** (Parameter) - Accumulation to be updated, has the same shape and type as `var`.
With float32 or float16 data type.
- **accum_update** (Parameter) - Accum_update to be updated, has the same shape and type as `var`.
With float32 or float16 data type.
- **lr** (Union[Number, Tensor]) - Learning rate, should be scalar. With float32 or float16 data type.
- **rho** (Union[Number, Tensor]) - Decay rate, should be scalar. With float32 or float16 data type.
- **epsilon** (Union[Number, Tensor]) - A small value added for numerical stability, should be scalar.
With float32 or float16 data type.
- **grad** (Tensor) - Gradients, has the same shape and type as `var`. With float32 or float16 data type.
Outputs:
Tuple of 3 Tensor, the updated parameters.
- **var** (Tensor) - The same shape and data type as `var`.
- **accum** (Tensor) - The same shape and data type as `accum`.
- **accum_update** (Tensor) - The same shape and data type as `accum_update`.
Examples:
>>> import numpy as np
>>> import mindspore.nn as nn
>>> from mindspore import Tensor, Parameter
>>> from mindspore.ops import operations as P
>>> import mindspore.common.dtype as mstype
>>> class Net(nn.Cell):
>>> def __init__(self):
>>> super(Net, self).__init__()
>>> self.apply_adadelta = P.ApplyAdadelta()
>>> self.var = Parameter(Tensor(np.random.rand(3, 3).astype(np.float32)), name="var")
>>> self.accum = Parameter(Tensor(np.random.rand(3, 3).astype(np.float32)), name="accum")
>>> self.accum_update = Parameter(Tensor(np.random.rand(3, 3).astype(np.float32)), name="accum_update")
>>> def construct(self, lr, rho, epsilon, grad):
>>> out = self.apply_adadelta(self.var, self.accum, self.accum_update, lr, rho, epsilon, grad)
>>> return out
>>> net = Net()
>>> lr = Tensor(0.001, mstype.float32)
>>> rho = Tensor(0.0, mstype.float32)
>>> epsilon = Tensor(1e-6, mstype.float32)
>>> grad = Tensor(np.random.rand(3, 3).astype(np.float32))
>>> result = net(lr, rho, epsilon, grad)
"""
__mindspore_signature__ = (
sig.make_sig('var', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('accum', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('accum_update', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('lr', dtype=sig.sig_dtype.T1),
sig.make_sig('rho', dtype=sig.sig_dtype.T2),
sig.make_sig('epsilon', dtype=sig.sig_dtype.T3),
sig.make_sig('grad', dtype=sig.sig_dtype.T),
)
@prim_attr_register
def __init__(self):
"""init ApplyAdadelta"""
def infer_shape(self, var_shape, accum_shape, accum_update_shape, lr_shape, rho_shape,
epsilon_shape, grad_shape):
validator.check("accum_shape", accum_shape, "var_shape", var_shape, Rel.EQ, self.name)
validator.check("accum_update_shape", accum_update_shape, "var_shape", var_shape, Rel.EQ, self.name)
validator.check("grad_shape", grad_shape, "var_shape", var_shape, Rel.EQ, self.name)
lr_shp_len = len(lr_shape)
validator.check_integer("lr's rank", lr_shp_len, 1, Rel.LE, self.name)
if lr_shp_len == 1:
validator.check_integer("lr_shape[0]", lr_shape[0], 1, Rel.EQ, self.name)
rho_shp_len = len(rho_shape)
validator.check_integer("rho's rank", rho_shp_len, 1, Rel.LE, self.name)
if rho_shp_len == 1:
validator.check_integer("rho_shape[0]", rho_shape[0], 1, Rel.EQ, self.name)
epsilon_shp_len = len(epsilon_shape)
validator.check_integer("lepsilon's rank", epsilon_shp_len, 1, Rel.LE, self.name)
if epsilon_shp_len == 1:
validator.check_integer("epsilon_shape[0]", epsilon_shape[0], 1, Rel.EQ, self.name)
return var_shape, accum_shape, accum_update_shape
def infer_dtype(self, var_dtype, accum_dtype, accum_update_dtype, lr_dtype, rho_dtype,
epsilon_dtype, grad_dtype):
valid_types = [mstype.float16, mstype.float32]
args = {"var": var_dtype, "accum": accum_dtype, "accum_update": accum_update_dtype, "grad": grad_dtype}
validator.check_tensor_type_same(args, valid_types, self.name)
validator.check_scalar_or_tensor_type_same({"lr": lr_dtype}, valid_types, self.name)
validator.check_scalar_or_tensor_type_same({"rho": rho_dtype}, valid_types, self.name)
validator.check_scalar_or_tensor_type_same({"epsilon": epsilon_dtype}, valid_types, self.name)
return var_dtype, accum_dtype, accum_update_dtype
class ApplyAdagrad(PrimitiveWithInfer):
r"""
Update relevant entries according to the adagrad scheme.
.. math::
accum += grad * grad
.. math::
var -= lr * grad * \frac{1}{\sqrt{accum}}
Inputs of `var`, `accum` and `grad` comply with the implicit type conversion rules
to make the data types consistent..
If they have different data types, lower priority data type will be converted to
relatively highest priority data type.
RuntimeError exception will be thrown when the data type conversion of Parameter is required.
Args:
update_slots (bool): If `True`, `accum` will be updated. Default: True.
Inputs:
- **var** (Parameter) - Variable to be updated. With float32 or float16 data type.
- **accum** (Parameter) - Accumulation to be updated. The shape and dtype should be the same as `var`.
With float32 or float16 data type.
- **lr** (Union[Number, Tensor]) - The learning rate value, should be scalar. With float32 or float16 data type.
- **grad** (Tensor) - A tensor for gradient. The shape and dtype should be the same as `var`.
With float32 or float16 data type.
Outputs:
Tuple of 2 Tensor, the updated parameters.
- **var** (Tensor) - The same shape and data type as `var`.
- **accum** (Tensor) - The same shape and data type as `accum`.
Examples:
>>> import numpy as np
>>> import mindspore.nn as nn
>>> from mindspore import Tensor, Parameter
>>> from mindspore.ops import operations as P
>>> import mindspore.common.dtype as mstype
>>> class Net(nn.Cell):
>>> def __init__(self):
>>> super(Net, self).__init__()
>>> self.apply_adagrad = P.ApplyAdagrad()
>>> self.var = Parameter(Tensor(np.random.rand(3, 3).astype(np.float32)), name="var")
>>> self.accum = Parameter(Tensor(np.random.rand(3, 3).astype(np.float32)), name="accum")
>>> def construct(self, lr, grad):
>>> out = self.apply_adagrad(self.var, self.accum, lr, grad)
>>> return out
>>> net = Net()
>>> lr = Tensor(0.001, mstype.float32)
>>> grad = Tensor(np.random.rand(3, 3).astype(np.float32))
>>> result = net(lr, grad)
"""
__mindspore_signature__ = (
sig.make_sig('var', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('accum', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('lr', dtype=sig.sig_dtype.T1),
sig.make_sig('grad', dtype=sig.sig_dtype.T),
)
@prim_attr_register
def __init__(self, update_slots=True):
validator.check_value_type("update_slots", update_slots, [bool], self.name)
def infer_shape(self, var_shape, accum_shape, lr_shape, grad_shape):
validator.check('accum shape', accum_shape, 'var shape', var_shape, Rel.EQ, self.name)
validator.check('grad shape', grad_shape, 'var shape', var_shape, Rel.EQ, self.name)
lr_shp_len = len(lr_shape)
validator.check_integer("lr's rank", lr_shp_len, 1, Rel.LE, self.name)
if lr_shp_len == 1:
validator.check_integer("lr_shape[0]", lr_shape[0], 1, Rel.EQ, self.name)
return var_shape, accum_shape
def infer_dtype(self, var_dtype, accum_dtype, lr_dtype, grad_dtype):
args = {'var': var_dtype, 'accum': accum_dtype, 'grad': grad_dtype}
valid_types = [mstype.float16, mstype.float32]
validator.check_tensor_type_same(args, valid_types, self.name)
validator.check_scalar_or_tensor_type_same({'lr': lr_dtype}, valid_types, self.name)
return var_dtype, accum_dtype
class ApplyAdagradV2(PrimitiveWithInfer):
r"""
Update relevant entries according to the adagradv2 scheme.
.. math::
accum += grad * grad
.. math::
var -= lr * grad * \frac{1}{\sqrt{accum} + \epsilon}
Inputs of `var`, `accum` and `grad` comply with the implicit type conversion rules
to make the data types consistent.
If they have different data types, lower priority data type will be converted to
relatively highest priority data type.
RuntimeError exception will be thrown when the data type conversion of Parameter is required.
Args:
epsilon (float): A small value added for numerical stability.
update_slots (bool): If `True`, `accum` will be updated. Default: True.
Inputs:
- **var** (Parameter) - Variable to be updated. With float16 or float32 data type.
- **accum** (Parameter) - Accumulation to be updated. The shape and dtype should be the same as `var`.
With float16 or float32 data type.
- **lr** (Union[Number, Tensor]) - The learning rate value, should be a float number or
a scalar tensor with float16 or float32 data type.
- **grad** (Tensor) - A tensor for gradient. The shape and dtype should be the same as `var`.
With float16 or float32 data type.
Outputs:
Tuple of 2 Tensor, the updated parameters.
- **var** (Tensor) - The same shape and data type as `var`.
- **accum** (Tensor) - The same shape and data type as `m`.
Examples:
>>> import numpy as np
>>> import mindspore.nn as nn
>>> from mindspore import Tensor, Parameter
>>> from mindspore.ops import operations as P
>>> import mindspore.common.dtype as mstype
>>> class Net(nn.Cell):
>>> def __init__(self):
>>> super(Net, self).__init__()
>>> self.apply_adagrad_v2 = P.ApplyAdagradV2(epsilon=1e-6)
>>> self.var = Parameter(Tensor(np.random.rand(3, 3).astype(np.float32)), name="var")
>>> self.accum = Parameter(Tensor(np.random.rand(3, 3).astype(np.float32)), name="accum")
>>> def construct(self, lr, grad):
>>> out = self.apply_adagrad_v2(self.var, self.accum, lr, grad)
>>> return out
>>> net = Net()
>>> lr = Tensor(0.001, mstype.float32)
>>> grad = Tensor(np.random.rand(3, 3).astype(np.float32))
>>> result = net(lr, grad)
"""
__mindspore_signature__ = (
sig.make_sig('var', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('accum', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('lr', dtype=sig.sig_dtype.T1),
sig.make_sig('grad', dtype=sig.sig_dtype.T),
)
@prim_attr_register
def __init__(self, epsilon, update_slots=True):
validator.check_value_type("epsilon", epsilon, [float], self.name)
validator.check_value_type("update_slots", update_slots, [bool], self.name)
def infer_shape(self, var_shape, accum_shape, lr_shape, grad_shape):
validator.check('var shape', var_shape, 'accum shape', accum_shape, Rel.EQ, self.name)
validator.check('var shape', var_shape, 'grad shape', grad_shape, Rel.EQ, self.name)
lr_shp_len = len(lr_shape)
validator.check_integer("lr's rank", lr_shp_len, 1, Rel.LE, self.name)
if lr_shp_len == 1:
validator.check_integer("lr_shape[0]", lr_shape[0], 1, Rel.EQ, self.name)
return var_shape, accum_shape
def infer_dtype(self, var_dtype, accum_dtype, lr_dtype, grad_dtype):
args = {'var': var_dtype, 'accum': accum_dtype, 'grad': grad_dtype}
validator.check_tensor_type_same(args, [mstype.float16, mstype.float32], self.name)
validator.check_scalar_or_tensor_type_same({'lr': lr_dtype}, [mstype.float16, mstype.float32], self.name)
return var_dtype, accum_dtype
class SparseApplyAdagrad(PrimitiveWithInfer):
r"""
Update relevant entries according to the adagrad scheme.
.. math::
accum += grad * grad
.. math::
var -= lr * grad * (1 / sqrt(accum))
Inputs of `var`, `accum` and `grad` comply with the implicit type conversion rules
to make the data types consistent.
If they have different data types, lower priority data type will be converted to
relatively highest priority data type.
RuntimeError exception will be thrown when the data type conversion of Parameter is required.
Args:
lr (float): Learning rate.
update_slots (bool): If `True`, `accum` will be updated. Default: True.
use_locking (bool): If true, the var and accumulation tensors will be protected from being updated.
Default: False.
Inputs:
- **var** (Parameter) - Variable to be updated. The data type must be float16 or float32.
- **accum** (Parameter) - Accumulation to be updated. The shape and dtype should be the same as `var`.
- **grad** (Tensor) - Gradient. The shape must be the same as `var`'s shape except first dimension.
Has the same data type as `var`.
- **indices** (Tensor) - A vector of indices into the first dimension of `var` and `accum`.
The shape of `indices` must be the same as `grad` in first dimension, the type must be int32.
Outputs:
Tuple of 2 Tensor, the updated parameters.
- **var** (Tensor) - The same shape and data type as `var`.
- **accum** (Tensor) - The same shape and data type as `accum`.
Examples:
>>> import numpy as np
>>> import mindspore.nn as nn
>>> from mindspore import Tensor, Parameter
>>> from mindspore.ops import operations as P
>>> import mindspore.common.dtype as mstype
>>> class Net(nn.Cell):
>>> def __init__(self):
>>> super(Net, self).__init__()
>>> self.sparse_apply_adagrad = P.SparseApplyAdagrad(lr=1e-8)
>>> self.var = Parameter(Tensor(np.ones([3, 3, 3]).astype(np.float32)), name="var")
>>> self.accum = Parameter(Tensor(np.ones([3, 3, 3]).astype(np.float32)), name="accum")
>>> def construct(self, grad, indices):
>>> out = self.sparse_apply_adagrad(self.var, self.accum, grad, indices)
>>> return out
>>> net = Net()
>>> grad = Tensor(np.random.rand(3, 3, 3).astype(np.float32))
>>> indices = Tensor([0, 1, 2], mstype.int32)
>>> result = net(grad, indices)
"""
__mindspore_signature__ = (
sig.make_sig('var', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('accum', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('grad', dtype=sig.sig_dtype.T),
sig.make_sig('indices', dtype=sig.sig_dtype.T1),
)
@prim_attr_register
def __init__(self, lr, update_slots=True, use_locking=False):
validator.check_value_type("lr", lr, [float], self.name)
validator.check_number_range("lr", lr, float("-inf"), float("inf"), Rel.INC_NEITHER, self.name)
validator.check_value_type("update_slots", update_slots, [bool], self.name)
validator.check_value_type("use_locking", use_locking, [bool], self.name)
def infer_shape(self, var_shape, accum_shape, grad_shape, indices_shape):
validator.check('var shape', var_shape, 'accum shape', accum_shape, Rel.EQ, self.name)
validator.check('len of var shape', len(var_shape), 'len of grad shape', len(grad_shape), Rel.EQ, self.name)
if len(var_shape) > 1:
validator.check('var_shape[1:]', var_shape[1:], 'grad_shape[1:]', grad_shape[1:], Rel.EQ, self.name)
validator.check_integer("indices rank", len(indices_shape), 1, Rel.EQ, self.name)
validator.check('grad_shape[0]', grad_shape[0], 'indices_shape[0]', indices_shape[0], Rel.EQ, self.name)
return var_shape, accum_shape
def infer_dtype(self, var_type, accum_type, grad_type, indices_type):
args = {'var': var_type, 'accum': accum_type, 'grad': grad_type}
validator.check_tensor_type_same(args, [mstype.float16, mstype.float32], self.name)
validator.check_tensor_type_same({'indices': indices_type}, [mstype.int32], self.name)
return var_type, accum_type
class SparseApplyAdagradV2(PrimitiveWithInfer):
r"""
Update relevant entries according to the adagrad scheme.
.. math::
accum += grad * grad
.. math::
var -= lr * grad * \frac{1}{\sqrt{accum} + \epsilon}
Inputs of `var`, `accum` and `grad` comply with the implicit type conversion rules
to make the data types consistent.
If they have different data types, lower priority data type will be converted to
relatively highest priority data type.
RuntimeError exception will be thrown when the data type conversion of Parameter is required.
Args:
lr (float): Learning rate.
epsilon (float): A small value added for numerical stability.
use_locking (bool): If `True`, the var and accumulation tensors will be protected from being updated.
Default: False.
update_slots (bool): If `True`, the computation logic will be different to `False`. Default: True.
Inputs:
- **var** (Parameter) - Variable to be updated. The data type must be float16 or float32.
- **accum** (Parameter) - Accumulation to be updated. The shape and dtype should be the same as `var`.
- **grad** (Tensor) - Gradient. The shape must be the same as `var`'s shape except first dimension.
Has the same data type as `var`.
- **indices** (Tensor) - A vector of indices into the first dimension of `var` and `accum`.
The shape of `indices` must be the same as `grad` in first dimension, the type must be int32.
Outputs:
Tuple of 2 Tensor, the updated parameters.
- **var** (Tensor) - The same shape and data type as `var`.
- **accum** (Tensor) - The same shape and data type as `accum`.
Examples:
>>> import numpy as np
>>> import mindspore.nn as nn
>>> from mindspore import Tensor, Parameter
>>> from mindspore.ops import operations as P
>>> import mindspore.common.dtype as mstype
>>> class Net(nn.Cell):
>>> def __init__(self):
>>> super(Net, self).__init__()
>>> self.sparse_apply_adagrad_v2 = P.SparseApplyAdagradV2(lr=1e-8, epsilon=1e-6)
>>> self.var = Parameter(Tensor(np.ones([3, 3, 3]).astype(np.float32)), name="var")
>>> self.accum = Parameter(Tensor(np.ones([3, 3, 3]).astype(np.float32)), name="accum")
>>>
>>> def construct(self, grad, indices):
>>> out = self.sparse_apply_adagrad_v2(self.var, self.accum, grad, indices)
>>> return out
>>> net = Net()
>>> grad = Tensor(np.random.rand(3, 3, 3).astype(np.float32))
>>> indices = Tensor([0, 1, 2], mstype.int32)
>>> result = net(grad, indices)
"""
__mindspore_signature__ = (
sig.make_sig('var', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('accum', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('grad', dtype=sig.sig_dtype.T),
sig.make_sig('indices', dtype=sig.sig_dtype.T1),
)
@prim_attr_register
def __init__(self, lr, epsilon, use_locking=False, update_slots=True):
self.lr = validator.check_value_type("lr", lr, [float], self.name)
self.epsilon = validator.check_value_type("epsilon", epsilon, [float], self.name)
self.use_locking = validator.check_value_type("update_slots", update_slots, [bool], self.name)
self.update_slots = validator.check_value_type("use_locking", use_locking, [bool], self.name)
def infer_shape(self, var_shape, accum_shape, grad_shape, indices_shape):
validator.check('var shape', var_shape, 'accum shape', accum_shape, Rel.EQ, self.name)
validator.check('len of var shape', len(var_shape), 'len of grad shape', len(grad_shape), Rel.EQ, self.name)
if len(var_shape) > 1:
validator.check('var_shape[1:]', var_shape[1:], 'grad_shape[1:]', grad_shape[1:], Rel.EQ, self.name)
validator.check_integer("indices rank", len(indices_shape), 1, Rel.EQ, self.name)
validator.check('grad_shape[0]', grad_shape[0], 'indices_shape[0]', indices_shape[0], Rel.EQ, self.name)
return var_shape, accum_shape
def infer_dtype(self, var_type, accum_type, grad_type, indices_type):
args = {'var': var_type, 'accum': accum_type, 'grad': grad_type}
validator.check_tensor_type_same(args, [mstype.float16, mstype.float32], self.name)
validator.check_tensor_type_same({'indices': indices_type}, [mstype.int32], self.name)
return var_type, accum_type
class ApplyProximalAdagrad(PrimitiveWithInfer):
r"""
Update relevant entries according to the proximal adagrad algorithm.
.. math::
accum += grad * grad
.. math::
\text{prox_v} = var - lr * grad * \frac{1}{\sqrt{accum}}
.. math::
var = \frac{sign(\text{prox_v})}{1 + lr * l2} * \max(\left| \text{prox_v} \right| - lr * l1, 0)
Inputs of `var`, `accum` and `grad` comply with the implicit type conversion rules
to make the data types consistent.
If they have different data types, lower priority data type will be converted to
relatively highest priority data type.
RuntimeError exception will be thrown when the data type conversion of Parameter is required.
Args:
use_locking (bool): If true, the var and accumulation tensors will be protected from being updated.
Default: False.
Inputs:
- **var** (Parameter) - Variable to be updated. The data type should be float16 or float32.
- **accum** (Parameter) - Accumulation to be updated. Must has the same shape and dtype as `var`.
- **lr** (Union[Number, Tensor]) - The learning rate value, should be scalar. The data type should be
float16 or float32.
- **l1** (Union[Number, Tensor]) - l1 regularization strength, should be scalar. The data type should be
float16 or float32.
- **l2** (Union[Number, Tensor]) - l2 regularization strength, should be scalar. The data type should be
float16 or float32.
- **grad** (Tensor) - Gradient with the same shape and dtype as `var`.
Outputs:
Tuple of 2 Tensor, the updated parameters.
- **var** (Tensor) - The same shape and data type as `var`.
- **accum** (Tensor) - The same shape and data type as `accum`.
Examples:
>>> import numpy as np
>>> import mindspore.nn as nn
>>> from mindspore import Tensor, Parameter
>>> from mindspore.ops import operations as P
>>> class Net(nn.Cell):
>>> def __init__(self):
>>> super(Net, self).__init__()
>>> self.apply_proximal_adagrad = P.ApplyProximalAdagrad()
>>> self.var = Parameter(Tensor(np.random.rand(3, 3).astype(np.float32)), name="var")
>>> self.accum = Parameter(Tensor(np.random.rand(3, 3).astype(np.float32)), name="accum")
>>> self.lr = 0.01
>>> self.l1 = 0.0
>>> self.l2 = 0.0
>>> def construct(self, grad):
>>> out = self.apply_proximal_adagrad(self.var, self.accum, self.lr, self.l1, self.l2, grad)
>>> return out
>>> net = Net()
>>> grad = Tensor(np.random.rand(3, 3).astype(np.float32))
>>> output = net(grad)
"""
__mindspore_signature__ = (
sig.make_sig('var', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('accum', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('lr', dtype=sig.sig_dtype.T1),
sig.make_sig('l1', dtype=sig.sig_dtype.T2),
sig.make_sig('l2', dtype=sig.sig_dtype.T3),
sig.make_sig('grad', dtype=sig.sig_dtype.T),
)
@prim_attr_register
def __init__(self, use_locking=False):
self.init_prim_io_names(inputs=['var', 'accum', 'lr', 'l1', 'l2', 'grad'],
outputs=['var', 'accum'])
self.use_locking = validator.check_value_type("use_locking", use_locking, [bool], self.name)
def infer_shape(self, var_shape, accum_shape, lr_shape, l1_shape, l2_shape, grad_shape):
validator.check('accum shape', accum_shape, 'var shape', var_shape, Rel.EQ, self.name)
validator.check('grad shape', grad_shape, 'var shape', var_shape, Rel.EQ, self.name)
lr_shp_len = len(lr_shape)
validator.check_integer("lr's rank", lr_shp_len, 1, Rel.LE, self.name)
if lr_shp_len == 1:
validator.check_integer("lr_shape[0]", lr_shape[0], 1, Rel.EQ, self.name)
l1_shp_len = len(l1_shape)
validator.check_integer("l1's rank", l1_shp_len, 1, Rel.LE, self.name)
if l1_shp_len == 1:
validator.check_integer("l1_shape[0]", l1_shape[0], 1, Rel.EQ, self.name)
l2_shp_len = len(l2_shape)
validator.check_integer("l2's rank", l2_shp_len, 1, Rel.LE, self.name)
if l2_shp_len == 1:
validator.check_integer("l2_shape[0]", l2_shape[0], 1, Rel.EQ, self.name)
return var_shape, accum_shape
def infer_dtype(self, var_dtype, accum_dtype, lr_dtype, l1_dtype, l2_dtype, grad_dtype):
valid_types = [mstype.float16, mstype.float32]
args = {'var': var_dtype, 'accum': accum_dtype, 'grad': grad_dtype}
validator.check_tensor_type_same(args, valid_types, self.name)
validator.check_scalar_or_tensor_type_same({"lr": lr_dtype}, valid_types, self.name)
validator.check_scalar_or_tensor_type_same({"l1": l1_dtype}, valid_types, self.name)
validator.check_scalar_or_tensor_type_same({"l2": l2_dtype}, valid_types, self.name)
return var_dtype, accum_dtype
class SparseApplyProximalAdagrad(PrimitiveWithCheck):
r"""
Update relevant entries according to the proximal adagrad algorithm. Compared with ApplyProximalAdagrad,
an additional index tensor is input.
.. math::
accum += grad * grad
.. math::
\text{prox_v} = var - lr * grad * \frac{1}{\sqrt{accum}}
.. math::
var = \frac{sign(\text{prox_v})}{1 + lr * l2} * \max(\left| \text{prox_v} \right| - lr * l1, 0)
Inputs of `var`, `accum` and `grad` comply with the implicit type conversion rules
to make the data types consistent.
If they have different data types, lower priority data type will be converted to
relatively highest priority data type.
RuntimeError exception will be thrown when the data type conversion of Parameter is required.
Args:
use_locking (bool): If true, the var and accumulation tensors will be protected from being updated.
Default: False.
Inputs:
- **var** (Parameter) - Variable tensor to be updated. The data type must be float16 or float32.
- **accum** (Parameter) - Variable tensor to be updated, has the same dtype as `var`.
- **lr** (Union[Number, Tensor]) - The learning rate value. Tshould be a float number or
a scalar tensor with float16 or float32 data type.
- **l1** (Union[Number, Tensor]) - l1 regularization strength. should be a float number or
a scalar tensor with float16 or float32 data type.
- **l2** (Union[Number, Tensor]) - l2 regularization strength. should be a float number or
a scalar tensor with float16 or float32 data type..
- **grad** (Tensor) - A tensor of the same type as `var`, for the gradient.
- **indices** (Tensor) - A vector of indices into the first dimension of `var` and `accum`.
Outputs:
Tuple of 2 Tensor, the updated parameters.
- **var** (Tensor) - The same shape and data type as `var`.
- **accum** (Tensor) - The same shape and data type as `accum`.
Examples:
>>> import numpy as np
>>> import mindspore.nn as nn
>>> from mindspore import Tensor, Parameter
>>> from mindspore.ops import operations as P
>>> class Net(nn.Cell):
>>> def __init__(self):
>>> super(Net, self).__init__()
>>> self.sparse_apply_proximal_adagrad = P.SparseApplyProximalAdagrad()
>>> self.var = Parameter(Tensor(np.random.rand(3, 3).astype(np.float32)), name="var")
>>> self.accum = Parameter(Tensor(np.random.rand(3, 3).astype(np.float32)), name="accum")
>>> self.lr = 0.01
>>> self.l1 = 0.0
>>> self.l2 = 0.0
>>> def construct(self, grad, indices):
>>> out = self.sparse_apply_proximal_adagrad(self.var, self.accum, self.lr, self.l1,
self.l2, grad, indices)
>>> return out
>>> net = Net()
>>> grad = Tensor(np.random.rand(3, 3).astype(np.float32))
>>> indices = Tensor(np.ones((3,), np.int32))
>>> output = net(grad, indices)
"""
__mindspore_signature__ = (
sig.make_sig('var', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('accum', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('lr', dtype=sig.sig_dtype.T1),
sig.make_sig('l1', dtype=sig.sig_dtype.T2),
sig.make_sig('l2', dtype=sig.sig_dtype.T3),
sig.make_sig('grad', dtype=sig.sig_dtype.T),
sig.make_sig('indices', dtype=sig.sig_dtype.T4),
)
@prim_attr_register
def __init__(self, use_locking=False):
self.init_prim_io_names(inputs=['var', 'accum', 'lr', 'l1', 'l2', 'grad', 'indices'],
outputs=['var', 'accum'])
self.use_locking = validator.check_value_type("use_locking", use_locking, [bool], self.name)
def check_shape(self, var_shape, accum_shape, lr_shape, l1_shape, l2_shape, grad_shape, indices_shape):
validator.check_integer("indices rank", len(indices_shape), 1, Rel.EQ, self.name)
def check_dtype(self, var_dtype, accum_dtype, lr_dtype, l1_dtype, l2_dtype, grad_dtype, indices_dtype):
args = {'var': var_dtype, 'accum': accum_dtype, 'grad': grad_dtype}
validator.check_tensor_type_same(args, [mstype.float16, mstype.float32], self.name)
validator.check_scalar_or_tensor_type_same({"lr": lr_dtype}, [mstype.float16, mstype.float32], self.name)
validator.check_scalar_or_tensor_type_same({"l1": l1_dtype}, [mstype.float16, mstype.float32], self.name)
validator.check_scalar_or_tensor_type_same({"l2": l2_dtype}, [mstype.float16, mstype.float32], self.name)
valid_types = [mstype.int16, mstype.int32, mstype.int64,
mstype.uint16, mstype.uint32, mstype.uint64]
validator.check_tensor_type_same({'indices': indices_dtype}, valid_types, self.name)
class ApplyAddSign(PrimitiveWithInfer):
r"""
Update relevant entries according to the AddSign algorithm.
.. math::
\begin{array}{ll} \\
m_{t} = \beta * m_{t-1} + (1 - \beta) * g \\
\text{update} = (\alpha + \text{sign_decay} * sign(g) * sign(m)) * g \\
var = var - lr_{t} * \text{update}
\end{array}
:math:`t` represents updating step while :math:`m` represents the 1st moment vector, :math:`m_{t-1}`
is the last momentent of :math:`m_{t}`, :math:`lr` represents scaling factor `lr`, :math:`g` represents `grad`.
Inputs of `var`, `accum` and `grad` comply with the implicit type conversion rules
to make the data types consistent.
If they have different data types, lower priority data type will be converted to
relatively highest priority data type.
RuntimeError exception will be thrown when the data type conversion of Parameter is required.
Inputs:
- **var** (Parameter) - Variable tensor to be updated. With float32 or float16 data type.
- **m** (Parameter) - Variable tensor to be updated, has the same dtype as `var`.
- **lr** (Union[Number, Tensor]) - The learning rate value, should be a scalar.
With float32 or float16 data type.
- **alpha** (Union[Number, Tensor]) - Should be a scalar. With float32 or float16 data type.
- **sign_decay** (Union[Number, Tensor]) - Should be a scalar. With float32 or float16 data type.
- **beta** (Union[Number, Tensor]) - The exponential decay rate, should be a scalar.
With float32 or float16 data type.
- **grad** (Tensor) - A tensor of the same type as `var`, for the gradient.
Outputs:
Tuple of 2 Tensor, the updated parameters.
- **var** (Tensor) - The same shape and data type as `var`.
- **m** (Tensor) - The same shape and data type as `m`.
Examples:
>>> import numpy as np
>>> import mindspore.nn as nn
>>> from mindspore import Tensor, Parameter
>>> from mindspore.ops import operations as P
>>> class Net(nn.Cell):
>>> def __init__(self):
>>> super(Net, self).__init__()
>>> self.apply_add_sign = P.ApplyAddSign()
>>> self.var = Parameter(Tensor(np.random.rand(3, 3).astype(np.float32)), name="var")
>>> self.m = Parameter(Tensor(np.random.rand(3, 3).astype(np.float32)), name="m")
>>> self.lr = 0.001
>>> self.alpha = 1.0
>>> self.sign_decay = 0.99
>>> self.beta = 0.9
>>> def construct(self, grad):
>>> out = self.apply_add_sign(self.var, self.m, self.lr, self.alpha, self.sign_decay, self.beta, grad)
>>> return out
>>> net = Net()
>>> grad = Tensor(np.random.rand(3, 3).astype(np.float32))
>>> output = net(grad)
"""
__mindspore_signature__ = (
sig.make_sig('var', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('m', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('lr', dtype=sig.sig_dtype.T1),
sig.make_sig('alpha', dtype=sig.sig_dtype.T2),
sig.make_sig('sign_decay', dtype=sig.sig_dtype.T3),
sig.make_sig('beta', dtype=sig.sig_dtype.T3),
sig.make_sig('grad', dtype=sig.sig_dtype.T),
)
@prim_attr_register
def __init__(self):
"init ApplyAddSign"
def infer_shape(self, var_shape, m_shape, lr_shape, alpha_shape, sign_decay_shape, beta_shape, grad_shape):
validator.check('m_shape', m_shape, 'var_shape', var_shape, Rel.EQ, self.name)
validator.check('grad_shape', grad_shape, 'var_shape', var_shape, Rel.EQ, self.name)
lr_shape_len = len(lr_shape)
validator.check_integer("lr's rank", lr_shape_len, 1, Rel.LE, self.name)
if lr_shape_len == 1:
validator.check_integer("lr_shape[0]", lr_shape[0], 1, Rel.EQ, self.name)
alpha_shape_len = len(alpha_shape)
validator.check_integer("alpha's rank", alpha_shape_len, 1, Rel.LE, self.name)
if alpha_shape_len == 1:
validator.check_integer("alpha_shape[0]", alpha_shape[0], 1, Rel.EQ, self.name)
sign_decay_shape_len = len(sign_decay_shape)
validator.check_integer("sign_decay's rank", sign_decay_shape_len, 1, Rel.LE, self.name)
if sign_decay_shape_len == 1:
validator.check_integer("sign_decay_shape[0]", sign_decay_shape[0], 1, Rel.EQ, self.name)
beta_shape_len = len(beta_shape)
validator.check_integer("beta's rank", beta_shape_len, 1, Rel.LE, self.name)
if beta_shape_len == 1:
validator.check_integer("beta_shape[0]", beta_shape[0], 1, Rel.EQ, self.name)
return var_shape, m_shape
def infer_dtype(self, var_dtype, m_dtype, lr_dtype, alpha_dtype, sign_decay_dtype, beta_dtype, grad_dtype):
valid_types = [mstype.float16, mstype.float32]
args = {'var': var_dtype, 'm': m_dtype, 'grad': grad_dtype}
validator.check_tensor_type_same(args, valid_types, self.name)
validator.check_scalar_or_tensor_type_same({"lr": lr_dtype}, valid_types, self.name)
validator.check_scalar_or_tensor_type_same({"alpha": alpha_dtype}, valid_types, self.name)
validator.check_scalar_or_tensor_type_same({"sign_decay": sign_decay_dtype}, valid_types, self.name)
validator.check_scalar_or_tensor_type_same({"beta": beta_dtype}, valid_types, self.name)
return var_dtype, m_dtype
class ApplyPowerSign(PrimitiveWithInfer):
r"""
Update relevant entries according to the AddSign algorithm.
.. math::
\begin{array}{ll} \\
m_{t} = \beta * m_{t-1} + (1 - \beta) * g \\
\text{update} = \exp(\text{logbase} * \text{sign_decay} * sign(g) * sign(m)) * g \\
var = var - lr_{t} * \text{update}
\end{array}
:math:`t` represents updating step while :math:`m` represents the 1st moment vector, :math:`m_{t-1}`
is the last momentent of :math:`m_{t}`, :math:`lr` represents scaling factor `lr`, :math:`g` represents `grad`.
All of inputs comply with the implicit type conversion rules to make the data types consistent.
If `lr`, `logbase`, `sign_decay` or `beta` is a number, the number is automatically converted to Tensor,
and the data type is consistent with the Tensor data type involved in the operation.
If inputs are tensors and have different data types, lower priority data type will be converted to
relatively highest priority data type.
RuntimeError exception will be thrown when the data type conversion of Parameter is required.
Inputs:
- **var** (Parameter) - Variable tensor to be updated. With float32 or float16 data type.
If data type of `var` is float16, all inputs must have the same data type as `var`.
- **m** (Parameter) - Variable tensor to be updated, has the same dtype as `var`.
- **lr** (Union[Number, Tensor]) - The learning rate value, should be a scalar.
With float32 or float16 data type.
- **logbase** (Union[Number, Tensor]) - Should be a scalar. With float32 or float16 data type.
- **sign_decay** (Union[Number, Tensor]) - Should be a scalar. With float32 or float16 data type.
- **beta** (Union[Number, Tensor]) - The exponential decay rate, should be a scalar.
With float32 or float16 data type.
- **grad** (Tensor) - A tensor of the same type as `var`, for the gradient.
Outputs:
Tuple of 2 Tensor, the updated parameters.
- **var** (Tensor) - The same shape and data type as `var`.
- **m** (Tensor) - The same shape and data type as `m`.
Examples:
>>> import numpy as np
>>> import mindspore.nn as nn
>>> from mindspore import Tensor, Parameter
>>> from mindspore.ops import operations as P
>>> class Net(nn.Cell):
>>> def __init__(self):
>>> super(Net, self).__init__()
>>> self.apply_power_sign = P.ApplyPowerSign()
>>> self.var = Parameter(Tensor(np.random.rand(3, 3).astype(np.float32)), name="var")
>>> self.m = Parameter(Tensor(np.random.rand(3, 3).astype(np.float32)), name="m")
>>> self.lr = 0.001
>>> self.logbase = np.e
>>> self.sign_decay = 0.99
>>> self.beta = 0.9
>>> def construct(self, grad):
>>> out = self.apply_power_sign(self.var, self.m, self.lr, self.logbase,
self.sign_decay, self.beta, grad)
>>> return out
>>> net = Net()
>>> grad = Tensor(np.random.rand(3, 3).astype(np.float32))
>>> output = net(grad)
"""
__mindspore_signature__ = (
sig.make_sig('var', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('m', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('lr', dtype=sig.sig_dtype.T),
sig.make_sig('logbase', dtype=sig.sig_dtype.T),
sig.make_sig('sign_decay', dtype=sig.sig_dtype.T),
sig.make_sig('beta', dtype=sig.sig_dtype.T),
sig.make_sig('grad', dtype=sig.sig_dtype.T),
)
@prim_attr_register
def __init__(self):
"init ApplyPowerSign"
def infer_shape(self, var_shape, m_shape, lr_shape, logbase_shape, sign_decay_shape, beta_shape, grad_shape):
validator.check('m_shape', m_shape, 'var_shape', var_shape, Rel.EQ, self.name)
validator.check('grad_shape', grad_shape, 'var_shape', var_shape, Rel.EQ, self.name)
lr_shape_len = len(lr_shape)
validator.check_integer("lr's rank", lr_shape_len, 1, Rel.LE, self.name)
if lr_shape_len == 1:
validator.check_integer("lr_shape[0]", lr_shape[0], 1, Rel.EQ, self.name)
logbase_shape_len = len(logbase_shape)
validator.check_integer("logbase's rank", logbase_shape_len, 1, Rel.LE, self.name)
if logbase_shape_len == 1:
validator.check_integer("logbase_shape[0]", logbase_shape[0], 1, Rel.EQ, self.name)
sign_decay_shape_len = len(sign_decay_shape)
validator.check_integer("sign_decay's rank", sign_decay_shape_len, 1, Rel.LE, self.name)
if sign_decay_shape_len == 1:
validator.check_integer("sign_decay_shape[0]", sign_decay_shape[0], 1, Rel.EQ, self.name)
beta_shape_len = len(beta_shape)
validator.check_integer("beta's rank", beta_shape_len, 1, Rel.LE, self.name)
if beta_shape_len == 1:
validator.check_integer("beta_shape[0]", beta_shape[0], 1, Rel.EQ, self.name)
return var_shape, m_shape
def infer_dtype(self, var_dtype, m_dtype, lr_dtype, logbase_dtype, sign_decay_dtype, beta_dtype, grad_dtype):
valid_types = [mstype.float16, mstype.float32]
args = {'var': var_dtype, 'm': m_dtype, 'grad': grad_dtype}
validator.check_tensor_type_same(args, valid_types, self.name)
validator.check_scalar_or_tensor_type_same({"lr": lr_dtype}, valid_types, self.name)
validator.check_scalar_or_tensor_type_same({"logbase": logbase_dtype}, valid_types, self.name)
validator.check_scalar_or_tensor_type_same({"sign_decay": sign_decay_dtype}, valid_types, self.name)
validator.check_scalar_or_tensor_type_same({"beta": beta_dtype}, valid_types, self.name)
return var_dtype, m_dtype
class ApplyGradientDescent(PrimitiveWithInfer):
r"""
Update relevant entries according to the following formula.
.. math::
var = var - \alpha * \delta
Inputs of `var` and `delta` comply with the implicit type conversion rules to make the data types consistent.
If they have different data types, lower priority data type will be converted to
relatively highest priority data type.
RuntimeError exception will be thrown when the data type conversion of Parameter is required.
Inputs:
- **var** (Parameter) - Variable tensor to be updated. With float32 or float16 data type.
- **alpha** (Union[Number, Tensor]) - Scaling factor, should be a scalar. With float32 or float16 data type.
- **delta** (Tensor) - A tensor for the change, has the same type as `var`.
Outputs:
Tensor, represents the updated `var`.
Examples:
>>> import numpy as np
>>> import mindspore.nn as nn
>>> from mindspore import Tensor, Parameter
>>> from mindspore.ops import operations as P
>>> class Net(nn.Cell):
>>> def __init__(self):
>>> super(Net, self).__init__()
>>> self.apply_gradient_descent = P.ApplyGradientDescent()
>>> self.var = Parameter(Tensor(np.random.rand(3, 3).astype(np.float32)), name="var")
>>> self.alpha = 0.001
>>> def construct(self, delta):
>>> out = self.apply_gradient_descent(self.var, self.alpha, delta)
>>> return out
>>> net = Net()
>>> delta = Tensor(np.random.rand(3, 3).astype(np.float32))
>>> output = net(delta)
"""
__mindspore_signature__ = (
sig.make_sig('var', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('alpha', dtype=sig.sig_dtype.T1),
sig.make_sig('delta', dtype=sig.sig_dtype.T),
)
@prim_attr_register
def __init__(self):
"init ApplyGradientDescent"
def infer_shape(self, var_shape, alpha_shape, delta_shape):
validator.check('delta shape', delta_shape, 'var shape', var_shape, Rel.EQ, self.name)
alpha_shape_len = len(alpha_shape)
validator.check_integer("alpha's rank", alpha_shape_len, 1, Rel.LE, self.name)
if alpha_shape_len == 1:
validator.check_integer("alpha_shape[0]", alpha_shape[0], 1, Rel.EQ, self.name)
return var_shape
def infer_dtype(self, var_dtype, alpha_dtype, delta_dtype):
valid_types = [mstype.float16, mstype.float32]
args = {'var': var_dtype, 'delta': delta_dtype}
validator.check_tensor_type_same(args, valid_types, self.name)
validator.check_scalar_or_tensor_type_same({"alpha": alpha_dtype}, valid_types, self.name)
return var_dtype
class ApplyProximalGradientDescent(PrimitiveWithInfer):
r"""
Update relevant entries according to the FOBOS(Forward Backward Splitting) algorithm.
.. math::
\text{prox_v} = var - \alpha * \delta
.. math::
var = \frac{sign(\text{prox_v})}{1 + \alpha * l2} * \max(\left| \text{prox_v} \right| - alpha * l1, 0)
Inputs of `var` and `delta` comply with the implicit type conversion rules to make the data types consistent.
If they have different data types, lower priority data type will be converted to
relatively highest priority data type.
RuntimeError exception will be thrown when the data type conversion of Parameter is required.
Inputs:
- **var** (Parameter) - Variable tensor to be updated. With float32 or float16 data type.
- **alpha** (Union[Number, Tensor]) - Saling factor, should be a scalar. With float32 or float16 data type.
- **l1** (Union[Number, Tensor]) - l1 regularization strength, should be scalar.
With float32 or float16 data type.
- **l2** (Union[Number, Tensor]) - l2 regularization strength, should be scalar.
With float32 or float16 data type.
- **delta** (Tensor) - A tensor for the change, has the same type as `var`.
Outputs:
Tensor, represents the updated `var`.
Examples:
>>> import numpy as np
>>> import mindspore.nn as nn
>>> from mindspore import Tensor, Parameter
>>> from mindspore.ops import operations as P
>>> class Net(nn.Cell):
>>> def __init__(self):
>>> super(Net, self).__init__()
>>> self.apply_proximal_gradient_descent = P.ApplyProximalGradientDescent()
>>> self.var = Parameter(Tensor(np.random.rand(3, 3).astype(np.float32)), name="var")
>>> self.alpha = 0.001
>>> self.l1 = 0.0
>>> self.l2 = 0.0
>>> def construct(self, delta):
>>> out = self.apply_proximal_gradient_descent(self.var, self.alpha, self.l1, self.l2, delta)
>>> return out
>>> net = Net()
>>> delta = Tensor(np.random.rand(3, 3).astype(np.float32))
>>> output = net(delta)
"""
__mindspore_signature__ = (
sig.make_sig('var', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('alpha', dtype=sig.sig_dtype.T1),
sig.make_sig('l1', dtype=sig.sig_dtype.T2),
sig.make_sig('l2', dtype=sig.sig_dtype.T3),
sig.make_sig('delta', dtype=sig.sig_dtype.T),
)
@prim_attr_register
def __init__(self):
"init ApplyGradientDescent"
def infer_shape(self, var_shape, alpha_shape, l1_shape, l2_shape, delta_shape):
validator.check('delta shape', delta_shape, 'var shape', var_shape, Rel.EQ, self.name)
alpha_shape_len = len(alpha_shape)
validator.check_integer("alpha's rank", alpha_shape_len, 1, Rel.LE, self.name)
if alpha_shape_len == 1:
validator.check_integer("alpha_shape[0]", alpha_shape[0], 1, Rel.EQ, self.name)
l1_shape_len = len(l1_shape)
validator.check_integer("l1's rank", l1_shape_len, 1, Rel.LE, self.name)
if l1_shape_len == 1:
validator.check_integer("l1_shape[0]", l1_shape[0], 1, Rel.EQ, self.name)
l2_shape_len = len(l2_shape)
validator.check_integer("l2's rank", l2_shape_len, 1, Rel.LE, self.name)
if l2_shape_len == 1:
validator.check_integer("l2_shape[0]", l2_shape[0], 1, Rel.EQ, self.name)
return var_shape
def infer_dtype(self, var_dtype, alpha_dtype, l1_dtype, l2_dtype, delta_dtype):
valid_types = [mstype.float16, mstype.float32]
args = {'var': var_dtype, 'delta': delta_dtype}
validator.check_tensor_type_same(args, valid_types, self.name)
validator.check_scalar_or_tensor_type_same({"alpha": alpha_dtype}, valid_types, self.name)
validator.check_scalar_or_tensor_type_same({"l1": l1_dtype}, valid_types, self.name)
validator.check_scalar_or_tensor_type_same({"l2": l2_dtype}, valid_types, self.name)
return var_dtype
class LARSUpdate(PrimitiveWithInfer):
"""
Conduct lars (layer-wise adaptive rate scaling) update on the square sum of gradient.
Args:
epsilon (float): Term added to the denominator to improve numerical stability. Default: 1e-05.
hyperpara (float): Trust coefficient for calculating the local learning rate. Default: 0.001.
use_clip (bool): Whether to use clip operation for calculating the local learning rate. Default: False.
Inputs:
- **weight** (Tensor) - The weight to be updated.
- **gradient** (Tensor) - The gradient of weight, which has the same shape and dtype with weight.
- **norm_weight** (Tensor) - A scalar tensor, representing the square sum of weight.
- **norm_gradient** (Tensor) - A scalar tensor, representing the square sum of gradient.
- **weight_decay** (Union[Number, Tensor]) - Weight decay. It should be a scalar tensor or number.
- **learning_rate** (Union[Number, Tensor]) - Learning rate. It should be a scalar tensor or number.
Outputs:
Tensor, represents the new gradient.
Examples:
>>> from mindspore import Tensor
>>> from mindspore.ops import operations as P
>>> from mindspore.ops import functional as F
>>> import mindspore.nn as nn
>>> import numpy as np
>>> class Net(nn.Cell):
>>> def __init__(self):
>>> super(Net, self).__init__()
>>> self.lars = P.LARSUpdate()
>>> self.reduce = P.ReduceSum()
>>> def construct(self, weight, gradient):
>>> w_square_sum = self.reduce(F.square(weight))
>>> grad_square_sum = self.reduce(F.square(gradient))
>>> grad_t = self.lars(weight, gradient, w_square_sum, grad_square_sum, 0.0, 1.0)
>>> return grad_t
>>> weight = np.random.random(size=(2, 3)).astype(np.float32)
>>> gradient = np.random.random(size=(2, 3)).astype(np.float32)
>>> net = Net()
>>> ms_output = net(Tensor(weight), Tensor(gradient))
"""
@prim_attr_register
def __init__(self, epsilon=1e-05, hyperpara=0.001, use_clip=False):
"""init"""
validator.check_value_type("epsilon", epsilon, [float], self.name)
validator.check_value_type("hyperpara", hyperpara, [float], self.name)
validator.check_value_type("use_clip", use_clip, [bool], self.name)
def infer_shape(self, weight_shape, gradient_shape, norm_weight_shape, norm_gradient_shape, weight_decay_shape,
learning_rate_shape):
validator.check("weight shape", weight_shape, "gradient shape", gradient_shape, Rel.EQ, self.name)
validator.check("norm weight shape", norm_weight_shape, "norm gradient shape", norm_gradient_shape, Rel.EQ,
self.name)
shp_len = len(weight_decay_shape)
validator.check_integer("weight decay's rank", shp_len, 1, Rel.LE, self.name)
if shp_len == 1:
validator.check_integer("weight_decay_shape[0]", weight_decay_shape[0], 1, Rel.EQ, self.name)
shp_len = len(learning_rate_shape)
validator.check_integer("learning rate's rank", shp_len, 1, Rel.LE, self.name)
if shp_len == 1:
validator.check_integer("learning_rate_shape[0]", learning_rate_shape[0], 1, Rel.EQ, self.name)
return weight_shape
def infer_dtype(self, weight_dtype, gradient_dtype, norm_weight_dtype, norm_gradient_dtype,
weight_decay_dtype, learning_rate_dtype):
args = {"Weight dtype": weight_dtype, "gradient dtype": gradient_dtype, "norm weight dtype": norm_weight_dtype,
"norm gradient dtype": norm_gradient_dtype}
validator.check_tensor_type_same(args, [mstype.float16, mstype.float32, mstype.int16, mstype.int32], self.name)
validator.check_scalar_or_tensor_type_same({"weight_decay": weight_decay_dtype},
[mstype.float16, mstype.float32, mstype.float64], self.name)
validator.check_scalar_or_tensor_type_same({"learning_rate": learning_rate_dtype},
[mstype.float16, mstype.float32, mstype.float64], self.name)
return weight_dtype
class ApplyFtrl(PrimitiveWithInfer):
"""
Update relevant entries according to the FTRL scheme.
Args:
use_locking (bool): Use locks for updating operation if True . Default: False.
Inputs:
- **var** (Parameter) - The variable to be updated. The data type should be float16 or float32.
- **accum** (Parameter) - The accumulation to be updated, must be same type and shape as `var`.
- **linear** (Parameter) - the linear coefficient to be updated, must be same type and shape as `var`.
- **grad** (Tensor) - Gradient. The data type should be float16 or float32.
- **lr** (Union[Number, Tensor]) - The learning rate value, must be positive. Default: 0.001.
It should be a float number or a scalar tensor with float16 or float32 data type.
- **l1** (Union[Number, Tensor]) - l1 regularization strength, must be greater than or equal to zero.
Default: 0.0. It should be a float number or a scalar tensor with float16 or float32 data type.
- **l2** (Union[Number, Tensor]) - l2 regularization strength, must be greater than or equal to zero.
Default: 0.0. It should be a float number or a scalar tensor with float16 or float32 data type.
- **lr_power** (Union[Number, Tensor]) - Learning rate power controls how the learning rate decreases
during training, must be less than or equal to zero. Use fixed learning rate if lr_power is zero.
Default: -0.5. It should be a float number or a scalar tensor with float16 or float32 data type.
Outputs:
Tensor, represents the updated `var`.
Examples:
>>> import mindspore
>>> import mindspore.nn as nn
>>> import numpy as np
>>> from mindspore import Parameter
>>> from mindspore import Tensor
>>> from mindspore.ops import operations as P
>>> class ApplyFtrlNet(nn.Cell):
>>> def __init__(self):
>>> super(ApplyFtrlNet, self).__init__()
>>> self.apply_ftrl = P.ApplyFtrl()
>>> self.lr = 0.001
>>> self.l1 = 0.0
>>> self.l2 = 0.0
>>> self.lr_power = -0.5
>>> self.var = Parameter(Tensor(np.random.rand(3, 3).astype(np.float32)), name="var")
>>> self.accum = Parameter(Tensor(np.random.rand(3, 3).astype(np.float32)), name="accum")
>>> self.linear = Parameter(Tensor(np.random.rand(3, 3).astype(np.float32)), name="linear")
>>>
>>> def construct(self, grad):
>>> out = self.apply_ftrl(self.var, self.accum, self.linear, grad, self.lr, self.l1, self.l2,
>>> self.lr_power)
>>> return out
>>>
>>> net = ApplyFtrlNet()
>>> input_x = Tensor(np.random.randint(-4, 4, (3, 3)), mindspore.float32)
>>> result = net(input_x)
[[0.67455846 0.14630564 0.160499 ]
[0.16329421 0.00415689 0.05202988]
[0.18672481 0.17418946 0.36420345]]
"""
@prim_attr_register
def __init__(self, use_locking=False):
self.init_prim_io_names(inputs=['var', 'accum', 'linear', 'grad', 'lr', 'l1', 'l2', 'lr_power'],
outputs=['output'])
self.use_locking = validator.check_value_type("use_locking", use_locking, [bool], self.name)
self.is_tbe = context.get_context("device_target") == "Ascend"
def infer_shape(self, var_shape, accum_shape, linear_shape, grad_shape, lr_shape, l1_shape, l2_shape,
lr_power_shape):
validator.check('var shape', var_shape, 'accum shape', accum_shape, Rel.EQ, self.name)
validator.check('var shape', var_shape, 'linear shape', linear_shape, Rel.EQ, self.name)
if self.is_tbe:
return var_shape, var_shape, var_shape
return var_shape
def infer_dtype(self, var_type, accum_type, linear_type, grad_type, lr_type, l1_type, l2_type, lr_power_type):
valid_types = [mstype.float16, mstype.float32]
args = {'var': var_type, 'accum': accum_type, 'linear': linear_type, 'grad': grad_type}
validator.check_tensor_type_same(args, valid_types, self.name)
validator.check_scalar_or_tensor_type_same({"lr": lr_type}, valid_types, self.name)
validator.check_scalar_or_tensor_type_same({"l1": l1_type}, valid_types, self.name)
validator.check_scalar_or_tensor_type_same({"l2": l2_type}, valid_types, self.name)
validator.check_scalar_or_tensor_type_same({"lr_power": lr_power_type}, valid_types, self.name)
if self.is_tbe:
return var_type, var_type, var_type
return var_type
class SparseApplyFtrl(PrimitiveWithCheck):
"""
Update relevant entries according to the FTRL-proximal scheme.
All of inputs except `indices` comply with the implicit type conversion rules to make the data types consistent.
If they have different data types, lower priority data type will be converted to
relatively highest priority data type.
RuntimeError exception will be thrown when the data type conversion of Parameter is required.
Args:
lr (float): The learning rate value, must be positive.
l1 (float): l1 regularization strength, must be greater than or equal to zero.
l2 (float): l2 regularization strength, must be greater than or equal to zero.
lr_power (float): Learning rate power controls how the learning rate decreases during training,
must be less than or equal to zero. Use fixed learning rate if `lr_power` is zero.
use_locking (bool): Use locks for updating operation if True . Default: False.
Inputs:
- **var** (Parameter) - The variable to be updated. The data type must be float16 or float32.
- **accum** (Parameter) - The accumulation to be updated, must be same type and shape as `var`.
- **linear** (Parameter) - the linear coefficient to be updated, must be same type and shape as `var`.
- **grad** (Tensor) - A tensor of the same type as `var`, for the gradient.
- **indices** (Tensor) - A vector of indices into the first dimension of `var` and `accum`.
The shape of `indices` must be the same as `grad` in first dimension. The type must be int32.
Outputs:
- **var** (Tensor) - Tensor, has the same shape and type as `var`.
- **accum** (Tensor) - Tensor, has the same shape and type as `accum`.
- **linear** (Tensor) - Tensor, has the same shape and type as `linear`.
Examples:
>>> import mindspore
>>> import mindspore.nn as nn
>>> import numpy as np
>>> from mindspore import Parameter
>>> from mindspore import Tensor
>>> from mindspore.ops import operations as P
>>> class SparseApplyFtrlNet(nn.Cell):
>>> def __init__(self):
>>> super(SparseApplyFtrlNet, self).__init__()
>>> self.sparse_apply_ftrl = P.SparseApplyFtrl(lr=0.01, l1=0.0, l2=0.0, lr_power=-0.5)
>>> self.var = Parameter(Tensor(np.random.rand(3, 3).astype(np.float32)), name="var")
>>> self.accum = Parameter(Tensor(np.random.rand(3, 3).astype(np.float32)), name="accum")
>>> self.linear = Parameter(Tensor(np.random.rand(3, 3).astype(np.float32)), name="linear")
>>>
>>> def construct(self, grad, indices):
>>> out = self.sparse_apply_ftrl(self.var, self.accum, self.linear, grad, indices)
>>> return out
>>>
>>> net = SparseApplyFtrlNet()
>>> grad = Tensor(np.random.rand(3, 3).astype(np.float32))
>>> indices = Tensor(np.ones([3]), mindspore.int32)
>>> output = net(grad, indices)
"""
__mindspore_signature__ = (
sig.make_sig('var', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('accum', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('linear', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('grad', dtype=sig.sig_dtype.T),
sig.make_sig('indices', dtype=sig.sig_dtype.T1),
)
@prim_attr_register
def __init__(self, lr, l1, l2, lr_power, use_locking=False):
validator.check_value_type("lr", lr, [float], self.name)
validator.check_value_type("l1", l1, [float], self.name)
validator.check_value_type("l2", l2, [float], self.name)
validator.check_value_type("lr_power", lr_power, [float], self.name)
self.lr = validator.check_number_range("lr", lr, 0.0, float("inf"), Rel.INC_NEITHER, self.name)
self.l1 = validator.check_number_range("l1", l1, 0.0, float("inf"), Rel.INC_LEFT, self.name)
self.l2 = validator.check_number_range("l2", l2, 0.0, float("inf"), Rel.INC_LEFT, self.name)
self.lr_power = validator.check_number("lr_power", lr_power, 0, Rel.LE, self.name)
self.use_locking = validator.check_value_type("use_locking", use_locking, [bool], self.name)
def check_shape(self, var_shape, accum_shape, linear_shape, grad_shape, indices_shape):
validator.check('var shape', var_shape, 'accum shape', accum_shape, Rel.EQ, self.name)
validator.check('var shape', var_shape, 'linear shape', linear_shape, Rel.EQ, self.name)
if len(var_shape) > 1:
validator.check('var_shape[1:]', var_shape[1:], 'grad_shape[1:]', grad_shape[1:], Rel.EQ, self.name)
validator.check_integer("indices rank", len(indices_shape), 1, Rel.EQ, self.name)
validator.check('grad_shape[0]', grad_shape[0], 'indices_shape[0]', indices_shape[0], Rel.EQ, self.name)
def check_dtype(self, var_dtype, accum_dtype, linear_dtype, grad_dtype, indices_dtype):
args = {"var_dtype": var_dtype, "accum_dtype": accum_dtype,
"linear_dtype": linear_dtype, "grad_dtype": grad_dtype}
validator.check_tensor_type_same(args, [mstype.float16, mstype.float32], self.name)
validator.check_tensor_type_same({"indices_dtype": indices_dtype}, [mstype.int32], self.name)
class SparseApplyFtrlV2(PrimitiveWithInfer):
"""
Update relevant entries according to the FTRL-proximal scheme.
All of inputs except `indices` comply with the implicit type conversion rules to make the data types consistent.
If they have different data types, lower priority data type will be converted to
relatively highest priority data type.
RuntimeError exception will be thrown when the data type conversion of Parameter is required.
Args:
lr (float): The learning rate value, must be positive.
l1 (float): l1 regularization strength, must be greater than or equal to zero.
l2 (float): l2 regularization strength, must be greater than or equal to zero.
l2_shrinkage (float): L2 shrinkage regularization.
lr_power (float): Learning rate power controls how the learning rate decreases during training,
must be less than or equal to zero. Use fixed learning rate if `lr_power` is zero.
use_locking (bool): If `True`, the var and accumulation tensors will be protected from being updated.
Default: False.
Inputs:
- **var** (Parameter) - The variable to be updated. The data type must be float16 or float32.
- **accum** (Parameter) - The accumulation to be updated, must be same type and shape as `var`.
- **linear** (Parameter) - the linear coefficient to be updated, must be same type and shape as `var`.
- **grad** (Tensor) - A tensor of the same type as `var`, for the gradient.
- **indices** (Tensor) - A vector of indices into the first dimension of `var` and `accum`.
The shape of `indices` must be the same as `grad` in first dimension. The type must be int32.
Outputs:
Tuple of 3 Tensor, the updated parameters.
- **var** (Tensor) - Tensor, has the same shape and type as `var`.
- **accum** (Tensor) - Tensor, has the same shape and type as `accum`.
- **linear** (Tensor) - Tensor, has the same shape and type as `linear`.
Examples:
>>> import mindspore
>>> import mindspore.nn as nn
>>> import numpy as np
>>> from mindspore import Parameter
>>> from mindspore import Tensor
>>> from mindspore.ops import operations as P
>>> class SparseApplyFtrlV2Net(nn.Cell):
>>> def __init__(self):
>>> super(SparseApplyFtrlV2Net, self).__init__()
>>> self.sparse_apply_ftrl_v2 = P.SparseApplyFtrlV2(lr=0.01, l1=0.0, l2=0.0,
l2_shrinkage=0.0, lr_power=-0.5)
>>> self.var = Parameter(Tensor(np.random.rand(3, 3).astype(np.float32)), name="var")
>>> self.accum = Parameter(Tensor(np.random.rand(3, 3).astype(np.float32)), name="accum")
>>> self.linear = Parameter(Tensor(np.random.rand(3, 3).astype(np.float32)), name="linear")
>>>
>>> def construct(self, grad, indices):
>>> out = self.sparse_apply_ftrl_v2(self.var, self.accum, self.linear, grad, indices)
>>> return out
>>>
>>> net = SparseApplyFtrlV2Net()
>>> grad = Tensor(np.random.rand(3, 3).astype(np.float32))
>>> indices = Tensor(np.ones([3]), mindspore.int32)
>>> output = net(grad, indices)
"""
__mindspore_signature__ = (
sig.make_sig('var', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('accum', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('linear', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
sig.make_sig('grad', dtype=sig.sig_dtype.T),
sig.make_sig('indices', dtype=sig.sig_dtype.T1),
)
@prim_attr_register
def __init__(self, lr, l1, l2, l2_shrinkage, lr_power, use_locking=False):
validator.check_value_type("lr", lr, [float], self.name)
validator.check_value_type("l1", l1, [float], self.name)
validator.check_value_type("l2", l2, [float], self.name)
validator.check_value_type("lr_power", lr_power, [float], self.name)
self.lr = validator.check_number_range("lr", lr, 0.0, float("inf"), Rel.INC_NEITHER, self.name)
self.l1 = validator.check_number_range("l1", l1, 0.0, float("inf"), Rel.INC_LEFT, self.name)
self.l2 = validator.check_number_range("l2", l2, 0.0, float("inf"), Rel.INC_LEFT, self.name)
self.lr_power = validator.check_number("lr_power", lr_power, 0, Rel.LE, self.name)
self.l2_shrinkage = validator.check_value_type("l2_shrinkage", l2_shrinkage, [float], self.name)
self.use_locking = validator.check_value_type("use_locking", use_locking, [bool], self.name)
def infer_shape(self, var_shape, accum_shape, linear_shape, grad_shape, indices_shape):
validator.check('var shape', var_shape, 'accum shape', accum_shape, Rel.EQ, self.name)
validator.check('var shape', var_shape, 'linear shape', linear_shape, Rel.EQ, self.name)
if len(var_shape) > 1:
validator.check('var_shape[1:]', var_shape[1:], 'grad_shape[1:]', grad_shape[1:], Rel.EQ, self.name)
validator.check_integer("indices rank", len(indices_shape), 1, Rel.EQ, self.name)
validator.check('grad_shape[0]', grad_shape[0], 'indices_shape[0]', indices_shape[0], Rel.EQ, self.name)
return var_shape, accum_shape, linear_shape
def infer_dtype(self, var_dtype, accum_dtype, linear_dtype, grad_dtype, indices_dtype):
args = {"var_dtype": var_dtype, "accum_dtype": accum_dtype,
"linear_dtype": linear_dtype, "grad_dtype": grad_dtype}
validator.check_tensor_type_same(args, [mstype.float16, mstype.float32], self.name)
validator.check_tensor_type_same({"indices_dtype": indices_dtype}, [mstype.int32], self.name)
return var_dtype, accum_dtype, linear_dtype
class ConfusionMulGrad(PrimitiveWithInfer):
"""
`output0` is the dot product result of input0 and input1.
`output1` is the dot product result of input0 and input1, then apply the reducesum operation on it.
Args:
axis (Union[int, tuple[int], list[int]]): The dimensions to reduce.
Default:(), reduce all dimensions. Only constant value is allowed.
keep_dims (bool):
- If true, keep these reduced dimensions and the length as 1.
- If false, don't keep these dimensions. Default:False.
Inputs:
- **input_0** (Tensor) - The input Tensor.
- **input_1** (Tensor) - The input Tensor.
- **input_2** (Tensor) - The input Tensor.
Outputs:
- **output_0** (Tensor) - The same shape as `input0`.
- **output_1** (Tensor)
- If axis is (), and keep_dims is false, the output is a 0-D array representing
the sum of all elements in the input array.
- If axis is int, set as 2, and keep_dims is false,
the shape of output is :math:`(x_1,x_3,...,x_R)`.
- If axis is tuple(int), set as (2,3), and keep_dims is false,
the shape of output is :math:`(x_1,x_4,...x_R)`.
Examples:
>>> confusion_mul_grad = P.ConfusionMulGrad()
>>> input_0 = Tensor(np.random.randint(-2, 2, (2, 3)), mindspore.float32)
>>> input_1 = Tensor(np.random.randint(0, 4, (2, 3)), mindspore.float32)
>>> input_2 = Tensor(np.random.randint(-4, 0, (2, 3)), mindspore.float32)
>>> output_0, output_1 = confusion_mul_grad(input_0, input_1, input_2)
output_0:
[[ 3. 1. 0.]
[-6. 2. -2.]]
output_1:
-3.0
"""
@prim_attr_register
def __init__(self, axis=(), keep_dims=False):
self.init_prim_io_names(inputs=["input0", "input1", "input2"], outputs=["output0", "output1"])
self.axis_ = validator.check_value_type("axis", axis, [int, tuple, list], self.name)
self.keep_dims_ = validator.check_value_type("keep_dims", keep_dims, [bool], self.name)
def infer_shape(self, input0_shape, input1_shape, input2_shape):
outshape0 = input0_shape
outshape1 = _infer_shape_reduce(input1_shape, self.axis_, self.keep_dims_, self.name)
return outshape0, outshape1
def infer_dtype(self, input0_dtype, input1_dtype, input2_dtype):
validator.check_subclass("input0_dtype", input0_dtype, mstype.tensor, self.name)
validator.check_subclass("input1_dtype", input1_dtype, mstype.tensor, self.name)
validator.check_subclass("input2_dtype", input2_dtype, mstype.tensor, self.name)
return input0_dtype, input1_dtype
class Dropout(PrimitiveWithInfer):
"""
During training, randomly zeroes some of the elements of the input tensor with probability.
Args:
keep_prob (float): The keep rate, between 0 and 1, e.g. keep_prob = 0.9,
means dropping out 10% of input units.
Inputs:
- **shape** (tuple[int]) - The shape of target mask.
Outputs:
Tensor, the value of generated mask for input shape.
Examples:
>>> dropout = P.Dropout(keep_prob=0.5)
>>> in = Tensor((20, 16, 50, 50))
>>> out = dropout(in)
"""
@prim_attr_register
def __init__(self, keep_prob=0.5):
self.keep_prob = validator.check_number_range("keep_prob", keep_prob, 0, 1, Rel.INC_RIGHT, self.name)
def infer_shape(self, x_shape):
validator.check_integer("x_shape", len(x_shape), 1, Rel.GE, self.name)
mask_shape = x_shape
return x_shape, mask_shape
def infer_dtype(self, x_dtype):
valid_types = (mstype.float16, mstype.float32)
validator.check_subclass("x", x_dtype, mstype.tensor, self.name)
validator.check_tensor_type_same({"x_dtype": x_dtype}, valid_types, self.name)
return x_dtype, x_dtype
class DropoutGrad(PrimitiveWithInfer):
"""
The gradient of Dropout. During training, randomly zeroes some of the elements
of the input tensor with probability.
Args:
keep_prob (float): The keep rate, between 0 and 1, e.g. keep_prob = 0.9,
means dropping out 10% of input units.
Inputs:
- **shape** (tuple[int]) - The shape of target mask.
Outputs:
Tensor, the value of generated mask for input shape.
Examples:
>>> dropout_grad = P.DropoutGrad(keep_prob=0.5)
>>> in = Tensor((20, 16, 50, 50))
>>> out = dropout_grad(in)
"""
@prim_attr_register
def __init__(self, keep_prob=0.5):
self.keep_prob = validator.check_number_range("keep_prob", keep_prob, 0, 1, Rel.INC_RIGHT, self.name)
def infer_shape(self, dy_shape, mask_shape):
return dy_shape
def infer_dtype(self, dy_dtype, mask_dtype):
valid_types = (mstype.float16, mstype.float32)
validator.check_subclass("dy", dy_dtype, mstype.tensor, self.name)
validator.check_subclass("mask", mask_dtype, mstype.tensor, self.name)
validator.check_tensor_type_same({"dy_dtype": dy_dtype}, valid_types, self.name)
return dy_dtype
class CTCLoss(PrimitiveWithInfer):
"""
Calculates the CTC (Connectionist Temporal Classification) loss and the gradient.
Args:
preprocess_collapse_repeated (bool): If true, repeated labels will be collapsed prior to the CTC calculation.
Default: False.
ctc_merge_repeated (bool): If false, during CTC calculation, repeated non-blank labels will not be merged
and these labels will be interpreted as individual ones. This is a simplfied
version of CTC. Default: True.
ignore_longer_outputs_than_inputs (bool): If True, sequences with longer outputs than inputs will be ignored.
Default: False.
Inputs:
- **inputs** (Tensor) - The input Tensor should be a `3-D` tensor whose shape is
:math:`(max_time, batch_size, num_classes)`. `num_classes` should be `num_labels + 1` classes, `num_labels`
indicates the number of actual labels. Blank labels are reserved. Default blank label is `num_classes - 1`.
Data type must be float16, float32 or float64.
- **labels_indices** (Tensor) - The indices of labels. `labels_indices[i, :] == [b, t]` means `labels_values[i]`
stores the id for `(batch b, time t)`. The type must be int64 and rank must be 2.
- **labels_values** (Tensor) - A `1-D` input tensor. The values are associated with the given batch and time.
The type must be int32. `labels_values[i]` must in the range of `[0, num_classes)`.
- **sequence_length** (Tensor) - A tensor containing sequence lengths with the shape of :math:`(batch_size)`.
The type must be int32. Each value in the tensor should not be greater than `max_time`.
Outputs:
- **loss** (Tensor) - A tensor containing log-probabilities, the shape is :math:`(batch_size)`. The tensor has
the same type with `inputs`.
- **gradient** (Tensor) - The gradient of `loss`, has the same type and shape with `inputs`.
Examples:
>>> inputs = Tensor(np.random.random((2, 2, 3)), mindspore.float32)
>>> labels_indices = Tensor(np.array([[0, 0], [1, 0]]), mindspore.int64)
>>> labels_values = Tensor(np.array([2, 2]), mindspore.int32)
>>> sequence_length = Tensor(np.array([2, 2]), mindspore.int32)
>>> ctc_loss = P.CTCLoss()
>>> output = ctc_loss(inputs, labels_indices, labels_values, sequence_length)
"""
@prim_attr_register
def __init__(self, preprocess_collapse_repeated=False, ctc_merge_repeated=True,
ignore_longer_outputs_than_inputs=False):
self.init_prim_io_names(inputs=["inputs", "labels_indices", "labels_values", "sequence_length"],
outputs=["loss", "gradient"])
validator.check_value_type("preprocess_collapse_repeated", preprocess_collapse_repeated, [bool], self.name)
self.preprocess_collapse_repeated_ = preprocess_collapse_repeated
self.ctc_merge_repeated_ = validator.check_value_type("ctc_merge_repeated", ctc_merge_repeated,
[bool], self.name)
validator.check_value_type("ignore_longer_outputs_than_inputs",
ignore_longer_outputs_than_inputs, [bool], self.name)
self.ignore_longer_outputs_than_inputs_ = ignore_longer_outputs_than_inputs
def infer_shape(self, inputs, labels_indices, labels_values, sequence_length):
validator.check_integer("inputs rank", len(inputs), 3, Rel.EQ, self.name)
validator.check_integer("labels_indices rank", len(labels_indices), 2, Rel.EQ, self.name)
validator.check_integer("labels_indices dim one", labels_indices[1], 2, Rel.EQ, self.name)
validator.check_integer("labels_values rank", len(labels_values), 1, Rel.EQ, self.name)
validator.check_integer("sequence_length rank", len(sequence_length), 1, Rel.EQ, self.name)
validator.check('labels_indices size', labels_indices[0], 'labels_values size',
labels_values[0], Rel.EQ, self.name)
validator.check('inputs batch_size', inputs[1], 'sequence_length batch_size',
sequence_length[0], Rel.EQ, self.name)
batch_size = []
batch_size.append(inputs[1])
return batch_size, inputs
def infer_dtype(self, inputs, labels_indices, labels_values, sequence_length):
valid_dtype = [mstype.float16, mstype.float32, mstype.double]
validator.check_tensor_type_same({"inputs_dtype": inputs}, valid_dtype, self.name)
validator.check_tensor_type_same({"labels_indices_dtype": labels_indices}, [mstype.int64], self.name)
validator.check_tensor_type_same({"labels_values_dtype": labels_values}, [mstype.int32], self.name)
validator.check_tensor_type_same({"sequence_length_dtype": sequence_length}, [mstype.int32], self.name)
return inputs, inputs
class CTCGreedyDecoder(PrimitiveWithInfer):
"""
Performs greedy decoding on the logits given in inputs.
Args:
merge_repeated (bool): If True, merge repeated classes in output. Default: True.
Inputs:
- **inputs** (Tensor) - The input Tensor should be a `3-D` tensor whose shape is
:math:`(max_time, batch_size, num_classes)`. `num_classes` should be `num_labels + 1` classes, `num_labels`
indicates the number of actual labels. Blank labels are reserved. Default blank label is `num_classes - 1`.
Data type must be float32 or float64.
- **sequence_length** (Tensor) - A tensor containing sequence lengths with the shape of :math:`(batch_size)`.
The type must be int32. Each value in the tensor should not greater than `max_time`.
Outputs:
- **decoded_indices** (Tensor) - A tensor with shape of :math:`(total_decoded_outputs, 2)`.
Data type is int64.
- **decoded_values** (Tensor) - A tensor with shape of :math:`(total_decoded_outputs)`,
it stores the decoded classes. Data type is int64.
- **decoded_shape** (Tensor) - The value of tensor is :math:`[batch_size, max_decoded_legth]`.
Data type is int64.
- **log_probability** (Tensor) - A tensor with shape of :math:`(batch_size, 1)`,
containing sequence log-probability, has the same type as `inputs`.
Examples:
>>> class CTCGreedyDecoderNet(nn.Cell):
>>> def __init__(self):
>>> super(CTCGreedyDecoderNet, self).__init__()
>>> self.ctc_greedy_decoder = P.CTCGreedyDecoder()
>>> self.assert_op = P.Assert(300)
>>>
>>> def construct(self, inputs, sequence_length):
>>> out = self.ctc_greedy_decoder(inputs,sequence_length)
>>> self.assert_op(True, (out[0], out[1], out[2], out[3]))
>>> return out[2]
>>>
>>> inputs = Tensor(np.random.random((2, 2, 3)), mindspore.float32)
>>> sequence_length = Tensor(np.array([2, 2]), mindspore.int32)
>>> net = CTCGreedyDecoderNet()
>>> output = net(inputs, sequence_length)
"""
@prim_attr_register
def __init__(self, merge_repeated=True):
self.merge_repeated = validator.check_value_type("merge_repeated", merge_repeated, [bool], self.name)
def infer_shape(self, inputs_shape, sequence_length_shape):
validator.check_integer("inputs rank", len(inputs_shape), 3, Rel.EQ, self.name)
validator.check_integer("sequence_length rank", len(sequence_length_shape), 1, Rel.EQ, self.name)
validator.check('inputs batch_size', inputs_shape[1], 'sequence_length batch_size',
sequence_length_shape[0], Rel.EQ, self.name)
total_decoded_outputs = -1
decoded_indices_shape = [total_decoded_outputs, 2]
decoded_values = [total_decoded_outputs]
decoded_shape = [2]
log_probability_shape = [inputs_shape[1], 1]
return decoded_indices_shape, decoded_values, decoded_shape, log_probability_shape
def infer_dtype(self, inputs_dtype, sequence_length_dtype):
validator.check_tensor_type_same({"inputs_dtype": inputs_dtype}, [mstype.float32, mstype.double], self.name)
validator.check_tensor_type_same({"sequence_length_dtype": sequence_length_dtype}, [mstype.int32], self.name)
decoded_type = mstype.tensor_type(mstype.int64)
return decoded_type, decoded_type, decoded_type, inputs_dtype
class BasicLSTMCell(PrimitiveWithInfer):
r"""
Applies the long short-term memory (LSTM) to the input.
.. math::
\begin{array}{ll} \\
i_t = \sigma(W_{ix} x_t + b_{ix} + W_{ih} h_{(t-1)} + b_{ih}) \\
f_t = \sigma(W_{fx} x_t + b_{fx} + W_{fh} h_{(t-1)} + b_{fh}) \\
\tilde{c}_t = \tanh(W_{cx} x_t + b_{cx} + W_{ch} h_{(t-1)} + b_{ch}) \\
o_t = \sigma(W_{ox} x_t + b_{ox} + W_{oh} h_{(t-1)} + b_{oh}) \\
c_t = f_t * c_{(t-1)} + i_t * \tilde{c}_t \\
h_t = o_t * \tanh(c_t) \\
\end{array}
Here :math:`\sigma` is the sigmoid function, and :math:`*` is the Hadamard product. :math:`W, b`
are learnable weights between the output and the input in the formula. For instance,
:math:`W_{ix}, b_{ix}` are the weight and bias used to transform from input :math:`x` to :math:`i`.
Details can be found in paper `LONG SHORT-TERM MEMORY
<https://www.bioinf.jku.at/publications/older/2604.pdf>`_ and
`Long Short-Term Memory Recurrent Neural Network Architectures for Large Scale Acoustic Modeling
<https://static.googleusercontent.com/media/research.google.com/zh-CN//pubs/archive/43905.pdf>`_.
Args:
keep_prob (float): If not 1.0, append `Dropout` layer on the outputs of each
LSTM layer except the last layer. Default 1.0. The range of dropout is [0.0, 1.0].
forget_bias (float): Add forget bias to forget gate biases in order to decrease former scale. Default: 1.0.
state_is_tuple (bool): If true, the state is a tuple of 2 tensors, containing h and c; If false, the state is
a tensor and it needs to be split first. Default: True.
activation (str): Activation. Default: "tanh". Only "tanh" is currently supported.
Inputs:
- **x** (Tensor) - Current words. Tensor of shape (`batch_size`, `input_size`).
The data type must be float16 or float32.
- **h** (Tensor) - Hidden state last moment. Tensor of shape (`batch_size`, `hidden_size`).
The data type must be float16 or float32.
- **c** (Tensor) - Cell state last moment. Tensor of shape (`batch_size`, `hidden_size`).
The data type must be float16 or float32.
- **w** (Tensor) - Weight. Tensor of shape (`input_size + hidden_size`, `4 x hidden_size`).
The data type must be float16 or float32.
- **b** (Tensor) - Bias. Tensor of shape (`4 x hidden_size`).
The data type must be the same as `c`.
Outputs:
- **ct** (Tensor) - Forward :math:`c_t` cache at moment `t`. Tensor of shape (`batch_size`, `hidden_size`).
Has the same type with input `c`.
- **ht** (Tensor) - Cell output. Tensor of shape (`batch_size`, `hidden_size`). With data type of float16.
- **it** (Tensor) - Forward :math:`i_t` cache at moment `t`. Tensor of shape (`batch_size`, `hidden_size`).
Has the same type with input `c`.
- **jt** (Tensor) - Forward :math:`j_t` cache at moment `t`. Tensor of shape (`batch_size`, `hidden_size`).
Has the same type with input `c`.
- **ft** (Tensor) - Forward :math:`f_t` cache at moment `t`. Tensor of shape (`batch_size`, `hidden_size`).
Has the same type with input `c`.
- **ot** (Tensor) - Forward :math:`o_t` cache at moment `t`. Tensor of shape (`batch_size`, `hidden_size`).
Has the same type with input `c`.
- **tanhct** (Tensor) - Forward :math:`tanh c_t` cache at moment `t`.
Tensor of shape (`batch_size`, `hidden_size`), has the same type with input `c`.
Examples:
>>> x = Tensor(np.random.rand(1, 32).astype(np.float16))
>>> h = Tensor(np.random.rand(1, 64).astype(np.float16))
>>> c = Tensor(np.random.rand(1, 64).astype(np.float16))
>>> w = Tensor(np.random.rand(96, 256).astype(np.float16))
>>> b = Tensor(np.random.rand(256, ).astype(np.float16))
>>> lstm = P.BasicLSTMCell(keep_prob=1.0, forget_bias=1.0, state_is_tuple=True, activation='tanh')
>>> lstm(x, h, c, w, b)
"""
@prim_attr_register
def __init__(self, keep_prob=1.0, forget_bias=1.0, state_is_tuple=True, activation='tanh'):
self.keep_prob = validator.check_value_type("keep_prob", keep_prob, [float], self.name)
self.keep_prob = validator.check_number_range("keep_prob", keep_prob, 0.0, 1.0, Rel.INC_BOTH, self.name)
self.forget_bias = validator.check_value_type("forget_bias", forget_bias, [float], self.name)
self.state_is_tuple = validator.check_value_type("state_is_tuple", state_is_tuple, [bool], self.name)
self.activation = validator.check_string("activation", activation, ['tanh'], self.name)
self.add_prim_attr("io_format", "ND")
def infer_shape(self, x_shape, h_shape, c_shape, w_shape, b_shape):
validator.check_integer("x rank", len(x_shape), 2, Rel.EQ, self.name)
validator.check_integer("h rank", len(h_shape), 2, Rel.EQ, self.name)
validator.check_integer("c rank", len(c_shape), 2, Rel.EQ, self.name)
validator.check_integer("w rank", len(w_shape), 2, Rel.EQ, self.name)
validator.check_integer("b rank", len(b_shape), 1, Rel.EQ, self.name)
validator.check("x_shape[0]", x_shape[0], "h_shape[0]", h_shape[0], Rel.EQ, self.name)
validator.check("c_shape[0]", c_shape[0], "h_shape[0]", h_shape[0], Rel.EQ, self.name)
validator.check("c_shape[1]", c_shape[1], "h_shape[1]", h_shape[1], Rel.EQ, self.name)
validator.check("w_shape[1]", w_shape[1], "4*h_shape[1]", 4 * h_shape[1], Rel.EQ, self.name)
validator.check("w_shape[0]", w_shape[0], "x_shape[1]+h_shape[1]", x_shape[1] + h_shape[1], Rel.EQ, self.name)
validator.check("b_shape[0]", b_shape[0], "4*h_shape[1]", 4 * h_shape[1], Rel.EQ, self.name)
ct_shape = c_shape
ht_shape = c_shape
it_shape = c_shape
jt_shape = c_shape
ft_shape = c_shape
ot_shape = c_shape
tanhct_shape = c_shape
return (ct_shape, ht_shape, it_shape, jt_shape, ft_shape, ot_shape, tanhct_shape)
def infer_dtype(self, x_dtype, h_dtype, c_dtype, w_dtype, b_dtype):
validator.check_tensor_type_same({"x_dtype": x_dtype}, [mstype.float16, mstype.float32], self.name)
validator.check_tensor_type_same({"h_dtype": h_dtype}, [mstype.float16, mstype.float32], self.name)
validator.check_tensor_type_same({"w_dtype": w_dtype}, [mstype.float16, mstype.float32], self.name)
args = {"c_dtype": c_dtype, "b_dtype": b_dtype}
validator.check_tensor_type_same(args, [mstype.float16, mstype.float32], self.name)
return (c_dtype, mstype.float16, c_dtype, c_dtype, c_dtype, c_dtype, c_dtype)
class InTopK(PrimitiveWithInfer):
r"""
Whether the targets are in the top `k` predictions.
Args:
k (int): Specify the number of top elements to be used for computing precision.
Inputs:
- **x1** (Tensor) - A 2D Tensor defines the predictions of a batch of samples with float16 or float32 data type.
- **x2** (Tensor) - A 1D Tensor defines the labels of a batch of samples with int32 data type.
Outputs:
Tensor has 1 dimension of type bool and the same shape with `x2`. For labeling sample `i` in `x2`,
if the label in the first `k` predictions for sample `i` is in `x1`, then the value is True, otherwise False.
Examples:
>>> x1 = Tensor(np.array([[1, 8, 5, 2, 7], [4, 9, 1, 3, 5]]), mindspore.float32)
>>> x2 = Tensor(np.array([1, 3]), mindspore.int32)
>>> in_top_k = P.InTopK(3)
>>> result = in_top_k(x1, x2)
[True False]
"""
@prim_attr_register
def __init__(self, k):
"""Init InTopK"""
self.init_prim_io_names(inputs=['x1', 'x2', 'k'], outputs=['y'])
validator.check_value_type("k", k, [int], self.name)
def infer_dtype(self, x1_dtype, x2_dtype):
validator.check_tensor_type_same({"x1": x1_dtype}, (mstype.float16, mstype.float32,), self.name)
validator.check_tensor_type_same({"x2": x2_dtype}, (mstype.int32,), self.name)
return mstype.tensor_type(mstype.bool_)
def infer_shape(self, x1_shape, x2_shape):
validator.check("x1", len(x1_shape), "", 2, Rel.EQ, self.name)
validator.check("x2", len(x2_shape), "", 1, Rel.EQ, self.name)
validator.check("size of x2", x2_shape[0], "x1's first dimension", x1_shape[0], Rel.EQ, self.name)
return x2_shape
class LRN(PrimitiveWithInfer):
r"""
Local Response Normalization
Args:
depth_radius (int): Half-width of the 1-D normalization window. Shape of 0-D.
bias (float): An offset (usually positive to avoid dividing by 0).
alpha (float): A scale factor, usually positive.
beta (float): An exponent.
norm_region (str): Specify normalization region. Options: "ACROSS_CHANNELS". Default: "ACROSS_CHANNELS".
Inputs:
- **x** (Tensor) - A 4D Tensor with float16 or float32 data type.
Outputs:
Tensor, With shape and data type same as the input tensor.
Examples:
>>> x = Tensor(np.random.rand(1, 10, 4, 4)), mindspore.float32)
>>> lrn = P.LRN()
>>> lrn(x)
"""
@prim_attr_register
def __init__(self, depth_radius=5, bias=1.0, alpha=1.0, beta=0.5, norm_region="ACROSS_CHANNELS"):
"""Init LRN"""
self.init_prim_io_names(inputs=['x'], outputs=['y'])
validator.check_value_type("depth_radius", depth_radius, [int], self.name)
validator.check_value_type("bias", bias, [float], self.name)
validator.check_value_type("alpha", alpha, [float], self.name)
validator.check_value_type("beta", beta, [float], self.name)
validator.check_value_type("norm_region", norm_region, [str], self.name)
validator.check_string('norm_region', norm_region, ['ACROSS_CHANNELS'], self.name)
validator.check_integer("depth_radius", depth_radius, 0, Rel.GE, self.name)
def infer_dtype(self, x_dtype):
validator.check_tensor_type_same({"x": x_dtype}, (mstype.float16, mstype.float32,), self.name)
return x_dtype
def infer_shape(self, x_shape):
validator.check_integer("x_shape", len(x_shape), 4, Rel.EQ, self.name)
return x_shape
class CTCLossV2(PrimitiveWithInfer):
r"""
Calculates the CTC (Connectionist Temporal Classification) loss and the gradient.
Note:
- Cudnn Uses label value of for the `blank`
Inputs:
- **inputs** (Tensor) - The input Tensor should be a `3-D` tensor whose shape is
:math:`(max_time, batch_size, num_class)`. `num_class` should be `num_labels + 1` classes, `num_labels`
indicates the number of actual labels. Blank labels are reserved.
- **labels** (Tensor) - The labels Tensor should be a `1-D` tensor whose shape is
:math:`(\sigma{label_lengths})`
or `2-D` tensor whose shape is
:math:`(max_time, max{label_lengths})`
The type must be int32.
- **input_lengths** (Tensor) - A `1-D` input tensor whose shape is
:math:`(batch_size,)`. The values should be batch. The type must be int32.
- **label_lengths** (Tensor) - A tensor containing sequence lengths with the shape of :math:`(batch_size)`.
The type must be int32. Each value in the tensor should not greater than `max_time`.
Outputs:
- **loss** (Tensor) - A tensor containing log-probabilities, the shape is :math:`(batch_size)`, has the same
type with `inputs`.
- **gradient** (Tensor) - The gradient of `loss`, has the same type and shape with `inputs`.
Examples:
>>> inputs = Tensor(np.random.random((2, 2, 3)), mindspore.float32)
>>> labels = Tensor(np.array([[0, 0], [1, 0]]), mindspore.int32)
>>> input_lengths = Tensor(np.array([3, 3, 3]), mindspore.int32)
>>> label_lengths = Tensor(np.array([3, 3, 3]), mindspore.int32)
>>> ctc_loss = P.CTCLossV2()
>>> output = ctc_loss(inputs, labels, input_lengths, label_lengths)
"""
@prim_attr_register
def __init__(self):
pass
def infer_dtype(self, input_dtype, labels_dtype, input_lengths_dtype, label_lengths_dtype):
validator.check_tensor_type_same({"input": input_dtype}, (mstype.float32,), self.name)
validator.check_tensor_type_same({"labels": labels_dtype}, (mstype.int32,), self.name)
validator.check_tensor_type_same({"input_lengths": input_lengths_dtype}, (mstype.int32,), self.name)
validator.check_tensor_type_same({"target_lengths": label_lengths_dtype}, (mstype.int32,), self.name)
return mstype.float32, mstype.float32
def infer_shape(self, input_shape, labels_shape, input_lengths_shape, label_lengths_shape):
validator.check_integer("input shape", len(input_shape), 3, Rel.EQ, self.name)
validator.check_number_range("labels shape", len(labels_shape), 1, 2, Rel.INC_BOTH, self.name)
validator.check_integer("input lengths shape", len(input_lengths_shape), 1, Rel.EQ, self.name)
validator.check_integer("label lengths shape", len(label_lengths_shape), 1, Rel.EQ, self.name)
validator.check_integer("input[1]", input_shape[1], input_lengths_shape[0], Rel.EQ, self.name)
validator.check_integer("input[1]", input_shape[1], label_lengths_shape[0], Rel.EQ, self.name)
return (input_shape[1],), input_shape
|
>>> input_x = Tensor(np.arange(1 * 3 * 3 * 4).reshape(1, 3, 3, 4), mindspore.float32)
>>> net = Net()
>>> result = net(input_x)
[[[[ 2.5 3.5 4.5]
|
setup.py
|
# -*- coding: utf-8 -*-
from setuptools import setup, find_packages
import re, ast
with open('requirements.txt') as f:
install_requires = f.read().strip().split('\n')
# get version from __version__ variable in it_dept_library/__init__.py
_version_re = re.compile(r'__version__\s+=\s+(.*)')
|
with open('ssncoe/__init__.py', 'rb') as f:
version = str(ast.literal_eval(_version_re.search(
f.read().decode('utf-8')).group(1)))
setup(
name='ssncoe',
version=version,
description='ssncoe',
author='R Vinob Chander',
author_email='[email protected]',
packages=find_packages(),
zip_safe=False,
include_package_data=True,
install_requires=install_requires
)
| |
admin.component.ts
|
import { Component, OnInit } from '@angular/core';
import { Title } from '@angular/platform-browser';
import { SzAdminService, SzBulkDataService } from '@senzing/sdk-components-ng';
import { SzWebAppConfigService } from '../../services/config.service';
@Component({
selector: 'admin-home',
templateUrl: './admin.component.html',
styleUrls: ['./admin.component.scss']
})
export class
|
implements OnInit {
/** whether or not the eda tools console is enabled */
public get consoleEnabled(): boolean {
return this.configService.isConsoleEnabled;
}
constructor(
public adminService: SzAdminService,
public bulkLoaderService: SzBulkDataService,
private configService: SzWebAppConfigService,
private titleService: Title) { }
ngOnInit() {
// set page title
this.titleService.setTitle( 'Admin Area' );
}
}
|
AdminComponent
|
Overlay.js
|
import Ext_scroll_indicator_Indicator from '../../../Ext/scroll/indicator/Indicator.js';
export default class Ext_scroll_indicator_Overlay extends Ext_scroll_indicator_Indicator {
static PROPERTIES() { return [
'alignSelf',
'alwaysOnTop',
'ariaAttributes',
'ariaDescribedBy',
'ariaLabel',
'ariaLabelledBy',
'axis',
'bind',
'border',
'cls',
'constrainAlign',
'controller',
'defaultListenerScope',
'disabled',
'enabled',
'flex',
'floated',
'focusCls',
'height',
'hidden',
'hideAnimation',
'hideDelay',
'hideMode',
'id',
'instanceCls',
'itemId',
'keyMap',
'keyMapEnabled',
'keyMapTarget',
'listeners',
'margin',
'name',
'nameable',
'plugins',
'publishes',
'reference',
'relative',
'renderTo',
'ripple',
'scroller',
'session',
'shadow',
'shareableName',
'shim',
'style',
'toFrontOnShow',
'touchAction',
'translatable',
'twoWayBindable',
'ui',
'userCls',
'value',
|
'y',
]};
static EVENTS() { return [
{name:'beforedisabledchange', parameters:'sender,value,oldValue,undefined'},
{name:'beforeheightchange', parameters:'sender,value,oldValue,undefined'},
{name:'beforehiddenchange', parameters:'sender,value,oldValue,undefined'},
{name:'beforetofront', parameters:'sender'},
{name:'beforewidthchange', parameters:'sender,value,oldValue,undefined'},
{name:'blur', parameters:'sender,event'},
{name:'disabledchange', parameters:'sender,value,oldValue'},
{name:'focus', parameters:'sender,event'},
{name:'focusenter', parameters:'sender,event'},
{name:'focusleave', parameters:'sender,event'},
{name:'heightchange', parameters:'sender,value,oldValue'},
{name:'hiddenchange', parameters:'sender,value,oldValue'},
{name:'tofront', parameters:'sender'},
{name:'widthchange', parameters:'sender,value,oldValue'},
{name:'ready', parameters:'cmp,cmpObj'},
{name:'created', parameters:'cmp'}
]};
static getProperties(properties) {
properties = properties.concat(Ext_scroll_indicator_Overlay.PROPERTIES());
return Ext_scroll_indicator_Indicator.getProperties(properties);
}
static getEvents(events) {
events = events.concat(Ext_scroll_indicator_Overlay.EVENTS());
return Ext_scroll_indicator_Indicator.getEvents(events);
}
static get observedAttributes() {
var attrs = super.observedAttributes
Ext_scroll_indicator_Overlay.PROPERTIES().forEach(function (property, index, array) {
attrs.push(property)
})
Ext_scroll_indicator_Overlay.EVENTS().forEach(function (eventparameter, index, array) {
attrs.push('on' + eventparameter.name)
})
return attrs
}
constructor(properties, events) {
super (
properties.concat(Ext_scroll_indicator_Overlay.PROPERTIES()),
events.concat(Ext_scroll_indicator_Overlay.EVENTS())
)
}
connectedCallback() {
super.connectedCallback()
}
attributeChangedCallback(attrName, oldVal, newVal) {
super.attributeChangedCallback(attrName, oldVal, newVal)
}
}
|
'viewModel',
'width',
'x',
|
dwi_connectome_utils.py
|
# coding: utf8
def get_luts():
import os
from clinica.utils.exceptions import ClinicaException
try:
# For aparc+aseg.mgz file:
default = os.path.join(os.environ['FREESURFER_HOME'],
'FreeSurferColorLUT.txt')
# For aparc.a2009s+aseg.mgz file:
a2009s = os.path.join(os.environ['FREESURFER_HOME'],
'FreeSurferColorLUT.txt')
# TODO: Add custom Lausanne2008 LUTs here.
except KeyError:
raise ClinicaException('Could not find FREESURFER_HOME environment variable.')
return [default, a2009s]
def get_conversion_luts():
import os
from clinica.utils.exceptions import ClinicaException
try:
# For aparc+aseg.mgz file:
default = os.path.join(os.environ['MRTRIX_HOME'],
'share/mrtrix3/labelconvert/fs_default.txt')
# For aparc.a2009s+aseg.mgz file:
a2009s = os.path.join(os.environ['MRTRIX_HOME'],
'share/mrtrix3/labelconvert/fs_a2009s.txt')
# TODO: Add custom Lausanne2008 conversion LUTs here.
except KeyError:
raise ClinicaException('Could not find MRTRIX_HOME environment variable.')
return [default, a2009s]
def get_containers(subjects, sessions):
return [
'subjects/' + subjects[i] + '/' + sessions[i] + '/dwi'
for i in range(len(subjects))
]
def get_caps_filenames(dwi_file: str):
import re
m = re.search(r"/(sub-[a-zA-Z0-9]+_ses-[a-zA-Z0-9]+.*)_preproc", dwi_file)
if not m:
raise ValueError(f"Input filename {dwi_file} is not in a CAPS compliant format.")
source_file_caps = m.group(1)
m = re.search(r"/(sub-[a-zA-Z0-9]+_ses-[a-zA-Z0-9]+.*)_space-[a-zA-Z0-9]+_preproc", dwi_file)
if not m:
raise ValueError(f"Input filename {dwi_file} is not in a CAPS compliant format.")
source_file_bids = m.group(1)
response = source_file_caps + '_model-CSD_responseFunction.txt'
fod = source_file_caps + '_model-CSD_diffmodel.nii.gz'
tracts = source_file_caps + '_model-CSD_tractography.tck'
nodes = [source_file_caps + '_atlas-desikan_parcellation.nii.gz',
source_file_caps + '_atlas-destrieux_parcellation.nii.gz']
# TODO: Add custom Lausanne2008 node files here.
connectomes = [source_file_bids + '_model-CSD_atlas-desikan_connectivity.tsv',
source_file_bids + '_model-CSD_atlas-destrieux_connectivity.tsv']
# TODO: Add custom Lausanne2008 connectome files here.
return response, fod, tracts, nodes, connectomes
def print_begin_pipeline(in_bids_or_caps_file: str) -> None:
|
def print_end_pipeline(in_bids_or_caps_file: str, final_file: str) -> None:
"""
"""
import re
from clinica.utils.stream import cprint
m = re.search(r'(sub-[a-zA-Z0-9]+)_(ses-[a-zA-Z0-9]+)',
in_bids_or_caps_file)
if not m:
raise ValueError(
f"Input filename {in_bids_or_caps_file} is not in a BIDS or CAPS compliant format."
)
cprint(f"...{m.group(0)} has completed.")
|
"""
"""
import re
from clinica.utils.stream import cprint
m = re.search(r'(sub-[a-zA-Z0-9]+)_(ses-[a-zA-Z0-9]+)',
in_bids_or_caps_file)
if not m:
raise ValueError(
f"Input filename {in_bids_or_caps_file} is not in a BIDS or CAPS compliant format."
)
cprint(f"Running pipeline for {m.group(0)}")
|
options.go
|
package rabbitmq
import (
"context"
"github.com/micro/go-micro/v2/broker"
)
type durableQueueKey struct{}
type headersKey struct{}
type queueArgumentsKey struct{}
type prefetchCountKey struct{}
type prefetchGlobalKey struct{}
type exchangeKey struct{}
type requeueOnErrorKey struct{}
type deliveryMode struct{}
type externalAuth struct{}
type durableExchange struct{}
// DurableQueue creates a durable queue when subscribing.
func DurableQueue() broker.SubscribeOption {
return setSubscribeOption(durableQueueKey{}, true)
}
// DurableExchange is an option to set the Exchange to be durable
func DurableExchange() broker.Option {
|
// Headers adds headers used by the headers exchange
func Headers(h map[string]interface{}) broker.SubscribeOption {
return setSubscribeOption(headersKey{}, h)
}
// QueueArguments sets arguments for queue creation
func QueueArguments(h map[string]interface{}) broker.SubscribeOption {
return setSubscribeOption(queueArgumentsKey{}, h)
}
// RequeueOnError calls Nack(muliple:false, requeue:true) on amqp delivery when handler returns error
func RequeueOnError() broker.SubscribeOption {
return setSubscribeOption(requeueOnErrorKey{}, true)
}
// ExchangeName is an option to set the ExchangeName
func ExchangeName(e string) broker.Option {
return setBrokerOption(exchangeKey{}, e)
}
// PrefetchCount ...
func PrefetchCount(c int) broker.Option {
return setBrokerOption(prefetchCountKey{}, c)
}
// PrefetchGlobal creates a durable queue when subscribing.
func PrefetchGlobal() broker.Option {
return setBrokerOption(prefetchGlobalKey{}, true)
}
// DeliveryMode sets a delivery mode for publishing
func DeliveryMode(value uint8) broker.PublishOption {
return setPublishOption(deliveryMode{}, value)
}
func ExternalAuth() broker.Option {
return setBrokerOption(externalAuth{}, ExternalAuthentication{})
}
type subscribeContextKey struct{}
// SubscribeContext set the context for broker.SubscribeOption
func SubscribeContext(ctx context.Context) broker.SubscribeOption {
return setSubscribeOption(subscribeContextKey{}, ctx)
}
type ackSuccessKey struct{}
// AckOnSuccess will automatically acknowledge messages when no error is returned
func AckOnSuccess() broker.SubscribeOption {
return setSubscribeOption(ackSuccessKey{}, true)
}
|
return setBrokerOption(durableExchange{}, true)
}
|
callbacks.py
|
import matplotlib
matplotlib.use('agg')
import matplotlib.pyplot as plt
import tensorflow as tf
import psutil
import numpy as np
import os
from tensorflow.keras.callbacks import Callback
from datetime import datetime
from mpunet.logging import ScreenLogger
from mpunet.utils.plotting import (imshow_with_label_overlay, imshow,
plot_all_training_curves)
class DividerLine(Callback):
"""
Simply prints a line to screen after each epoch
"""
def __init__(self, logger=None):
"""
Args:
logger: An instance of a MultiPlanar Logger that prints to screen
and/or file
"""
super().__init__()
self.logger = logger or ScreenLogger()
def on_epoch_end(self, epoch, logs=None):
self.logger("-"*45 + "\n")
class LearningCurve(Callback):
"""
On epoch end this callback looks for all csv files matching the 'csv_regex'
regex within the dir 'out_dir' and attempts to create a learning curve for
each file that will be saved to 'out_dir'.
Note: Failure to plot a learning curve based on a given csv file will
is handled in the plot_all_training_curves function and will not
cause the LearningCurve callback to raise an exception.
"""
def __init__(self, log_dir="logs", out_dir="logs", fname="curve.png",
csv_regex="*training.csv", logger=None, **plot_kwargs):
"""
Args:
log_dir: Relative path from the
out_dir:
fname:
csv_regex:
logger:
"""
super().__init__()
out_dir = os.path.abspath(out_dir)
if not os.path.exists(out_dir):
os.makedirs(out_dir)
self.csv_regex = os.path.join(os.path.abspath(log_dir), csv_regex)
self.save_path = os.path.join(out_dir, fname)
self.logger = logger or ScreenLogger()
self.plot_kwargs = plot_kwargs
def on_epoch_end(self, epoch, logs={}):
plot_all_training_curves(self.csv_regex,
self.save_path,
logy=True,
raise_error=False,
logger=self.logger,
**self.plot_kwargs)
class MemoryConsumption(Callback):
def __init__(self, max_gib=None, round_=2, logger=None):
self.max_gib = max_gib
self.logger = logger
self.round_ = round_
def on_epoch_end(self, epoch, logs={}):
process = psutil.Process(os.getpid())
mem_bytes = process.memory_info().rss
mem_gib = round(mem_bytes / (1024**3), self.round_)
logs['memory_usage_gib'] = mem_gib
if self.max_gib and mem_gib >= self.max_gib:
self.warn("Stopping training from callback 'MemoryConsumption'! "
"Total memory consumption of {} GiB exceeds limitation"
" (self.max_gib = {}) ".format(mem_gib, self.max_gib))
self.model.stop_training = True
class DelayedCallback(object):
"""
Callback wrapper that delays the functionality of another callback by N
number of epochs.
"""
def __init__(self, callback, start_from=0, logger=None):
"""
Args:
callback: A tf.keras callback
start_from: Delay the activity of 'callback' until this epoch
'start_from'
logger: An instance of a MultiPlanar Logger that prints to screen
and/or file
"""
self.logger = logger or ScreenLogger()
self.callback = callback
self.start_from = start_from
def __getattr__(self, item):
return getattr(self.callback, item)
def on_epoch_end(self, epoch, logs=None):
if epoch >= self.start_from-1:
self.callback.on_epoch_end(epoch, logs=logs)
else:
self.logger("[%s] Not active at epoch %i - will be at %i" %
(self.callback.__class__.__name__,
epoch+1, self.start_from))
class TrainTimer(Callback):
"""
Appends train timing information to the log.
If called prior to tf.keras.callbacks.CSVLogger this information will
be written to disk.
"""
def __init__(self, logger=None, max_minutes=None, verbose=1):
super().__init__()
self.logger = logger or ScreenLogger()
self.max_minutes = int(max_minutes) if max_minutes else None
self.verbose = bool(verbose)
# Timing attributes
self.train_begin_time = None
self.prev_epoch_time = None
def on_train_begin(self, logs=None):
self.train_begin_time = datetime.now()
def on_epoch_begin(self, epoch, logs=None):
self.prev_epoch_time = datetime.now()
def on_epoch_end(self, epoch, logs=None):
# Compute epoch execution time
end_time = datetime.now()
epoch_time = end_time - self.prev_epoch_time
train_time = end_time - self.train_begin_time
# Update attributes
self.prev_epoch_time = end_time
# Add to logs
train_hours = round(train_time.total_seconds() / 3600, 4)
epoch_minutes = round(epoch_time.total_seconds() / 60, 4)
logs["epoch_minutes"] = epoch_minutes
logs["train_hours"] = train_hours
if self.verbose:
self.logger("[TrainTimer] Epoch time: %.2f minutes "
"- Total train time: %.2f hours"
% (epoch_minutes, train_hours))
if self.max_minutes and train_hours*60 > self.max_minutes:
self.logger("Stopping training. Training ran for {} minutes, "
"max_minutes of {} was specified on the TrainTimer "
"callback.".format(train_hours*60, self.max_minutes))
self.model.stop_training = True
class FGBatchBalancer(Callback):
"""
mpunet callback.
Sets the forced FG fraction in a batch at each epoch to 1-recall over the
validation data at the previous epoch
"""
def __init__(self, train_data, val_data=None, logger=None):
"""
Args:
train_data: A mpunet.sequence object representing the
training data
val_data: A mpunet.sequence object representing the
validation data
logger: An instance of a MultiPlanar Logger that prints to screen
and/or file
"""
super().__init__()
self.data = (("train", train_data), ("val", val_data))
self.logger = logger or ScreenLogger()
self.active = True
def on_epoch_end(self, epoch, logs=None):
if not self.active:
return None
recall = logs.get("val_recall")
if recall is None:
self.logger("[FGBatchBalancer] No val_recall in logs. "
"Disabling callback. "
"Did you put this callback before the validation "
"callback?")
self.active = False
else:
# Always at least 1 image slice
fraction = max(0.01, 1 - recall)
for name, data in self.data:
if data is not None:
data.fg_batch_fraction = fraction
self.logger("[FGBatchBalancer] Setting FG fraction for %s "
"to: %.4f - Now %s/%s" % (name,
fraction,
data.n_fg_slices,
data.batch_size))
class MeanReduceLogArrays(Callback):
"""
On epoch end, goes through the log and replaces any array entries with
their mean value.
"""
def __init__(self):
super().__init__()
def on_epoch_end(self, epoch, logs={}):
for key, value in logs.items():
if isinstance(value, (np.ndarray, list)):
logs[key] = np.mean(value)
class PrintLayerWeights(Callback):
"""
Print the weights of a specified layer every some epoch or batch.
"""
def __init__(self, layer, every=10, first=10, per_epoch=False, logger=None):
"""
Args:
layer: A tf.keras layer
every: Print the weights every 'every' batch or epoch if
per_epoch=True
first: Print the first 'first' elements of each weight matrix
per_epoch: Print after 'every' epoch instead of batch
logger: An instance of a MultiPlanar Logger that prints to screen
and/or file
"""
super().__init__()
if isinstance(layer, int):
self.layer = self.model.layers[layer]
else:
self.layer = layer
self.first = first
self.every = every
self.logger = logger or ScreenLogger()
self.per_epoch = per_epoch
if per_epoch:
# Apply on every epoch instead of per batches
self.on_epoch_begin = self.on_batch_begin
self.on_batch_begin = lambda *args, **kwargs: None
self.log()
def log(self):
self.logger("PrintLayerWeights Callback")
self.logger("Layer: ", self.layer)
self.logger("Every: ", self.every)
self.logger("First: ", self.first)
self.logger("Per epoch: ", self.per_epoch)
def on_batch_begin(self, batch, logs=None):
if batch % self.every:
return
weights = self.layer.get_weights()
self.logger("Weights for layer '%s'" % self.layer)
self.logger("Weights:\n%s" % weights[0].ravel()[:self.first])
try:
self.logger("Baises:\n%s" % weights[1].ravel()[:self.first])
except IndexError:
pass
class SaveOutputAs2DImage(Callback):
"""
Save random 2D slices from the output of a given layer during training.
"""
def __init__(self, layer, sequence, model, out_dir, every=10, logger=None):
"""
Args:
layer: A tf.keras layer
sequence: A MultiPlanar.sequence object from which batches are
sampled and pushed through the graph to output of layer
model: A tf.keras model object
out_dir: Path to directory (existing or non-existing) in which
images will be stored
every: Perform this operation every 'every' batches
"""
super().__init__()
self.every = every
self.seq = sequence
self.layer = layer
self.epoch = None
self.model = model
self.logger = logger or ScreenLogger()
self.out_dir = out_dir
if not os.path.exists(out_dir):
os.makedirs(self.out_dir)
self.log()
def log(self):
self.logger("Save Output as 2D Image Callback")
self.logger("Layer: ", self.layer)
self.logger("Every: ", self.every)
def on_epoch_begin(self, epoch, logs=None):
self.epoch = epoch
def on_batch_end(self, batch, logs=None):
if batch % self.every:
return
# Get output of layer
self.model.predict_on_batch()
sess = tf.keras.backend.get_session()
X, _, _ = self.seq[0]
outs = sess.run([self.layer.output], feed_dict={self.model.input: X})[0]
if isinstance(outs, list):
outs = outs[0]
for i, (model_in, layer_out) in enumerate(zip(X, outs)):
fig = plt.figure(figsize=(12, 6))
ax1 = fig.add_subplot(121)
ax2 = fig.add_subplot(122)
# Plot model input and layer outputs on each ax
chl1, axis, slice = imshow(ax1, model_in)
chl2, _, _ = imshow(ax2, layer_out, axis=axis, slice=slice)
# Set labels and save figure
ax1.set_title("Model input - Channel %i - Axis %i - Slice %i"
% (chl1, axis,slice), size=22)
ax2.set_title("Layer output - Channel %i - Axis %i - Slice %i"
% (chl2, axis, slice), size=22)
fig.tight_layout()
fig.savefig(os.path.join(self.out_dir, "epoch_%i_batch_%i_im_%i" %
(self.epoch, batch, i)))
plt.close(fig)
class SavePredictionImages(Callback):
"""
Save images after each epoch of training of the model on a batch of
training and a batch of validation data sampled from sequence objects.
Saves the input image with ground truth overlay as well as the predicted
label masks.
"""
def __init__(self, train_data, val_data, outdir='images'):
"""
Args:
train_data: A mpunet.sequence object from which training
data can be sampled via the __getitem__ method.
val_data: A mpunet.sequence object from which validation
data can be sampled via the __getitem__ method.
outdir: Path to directory (existing or non-existing) in which
images will be stored.
"""
super().__init__()
self.train_data = train_data
self.val_data = val_data
self.save_path = os.path.abspath(os.path.join(outdir, "pred_images_at_epoch"))
if not os.path.exists(self.save_path):
os.makedirs(self.save_path)
def pred_and_save(self, data, subdir):
# Get a random batch
|
def on_epoch_end(self, epoch, logs={}):
self.pred_and_save(self.train_data, "train_%s" % epoch)
if self.val_data is not None:
self.pred_and_save(self.val_data, "val_%s" % epoch)
|
X, y, _ = data[np.random.randint(len(data), dtype=np.int64)]
# Predict on the batch
pred = self.model.predict(X)
subdir = os.path.join(self.save_path, subdir)
if not os.path.exists(subdir):
os.mkdir(subdir)
# Plot each sample in the batch
for i, (im, lab, p) in enumerate(zip(X, y, pred)):
fig, (ax1, ax2, ax3) = plt.subplots(ncols=3, figsize=(12, 6))
lab = lab.reshape(im.shape[:-1] + (lab.shape[-1],))
p = p.reshape(im.shape[:-1] + (p.shape[-1],))
# Imshow ground truth on ax2
# This function will determine which channel, axis and slice to
# show and return so that we can use them for the other 2 axes
chnl, axis, slice = imshow_with_label_overlay(ax2, im, lab, lab_alpha=1.0)
# Imshow pred on ax3
imshow_with_label_overlay(ax3, im, p, lab_alpha=1.0,
channel=chnl, axis=axis, slice=slice)
# Imshow raw image on ax1
# Chose the same slice, channel and axis as above
im = im[..., chnl]
im = np.moveaxis(im, axis, 0)
if slice is not None:
# Only for 3D imges
im = im[slice]
ax1.imshow(im, cmap="gray")
# Set labels
ax1.set_title("Image", size=18)
ax2.set_title("True labels", size=18)
ax3.set_title("Prediction", size=18)
fig.tight_layout()
with np.testing.suppress_warnings() as sup:
sup.filter(UserWarning)
fig.savefig(os.path.join(subdir, str(i) + ".png"))
plt.close(fig.number)
|
init.go
|
// Copyright © 2021 Alibaba Group Holding Ltd.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package runtime
import (
"fmt"
"io/ioutil"
"path"
"path/filepath"
"strings"
"sync"
"github.com/alibaba/sealer/common"
"github.com/alibaba/sealer/logger"
"github.com/alibaba/sealer/cert"
v1 "github.com/alibaba/sealer/types/api/v1"
"github.com/alibaba/sealer/utils"
"github.com/alibaba/sealer/utils/ssh"
)
const (
RemoteCmdCopyStatic = "mkdir -p %s && cp -f %s %s"
RemoteApplyYaml = `echo '%s' | kubectl apply -f -`
RemoteCmdGetNetworkInterface = "ls /sys/class/net"
RemoteCmdExistNetworkInterface = "ip addr show %s | egrep \"%s\" || true"
WriteKubeadmConfigCmd = "cd %s && echo \"%s\" > kubeadm-config.yaml"
DefaultVIP = "10.103.97.2"
DefaultAPIserverDomain = "apiserver.cluster.local"
DefaultRegistryPort = 5000
)
func (d *Default) init(cluster *v1.Cluster) error {
if err := d.LoadMetadata(); err != nil {
return fmt.Errorf("failed to load metadata %v", err)
}
//config kubeadm
if err := d.ConfigKubeadmOnMaster0(); err != nil {
return err
}
//generate certs
if err := d.GenerateCert(); err != nil {
return err
}
//create kubeConfig for master0
if err := d.CreateKubeConfig(); err != nil {
return err
}
if err := d.CopyStaticFiles(d.Masters); err != nil {
return err
}
if err := d.EnsureRegistry(); err != nil {
return err
}
if err := d.InitMaster0(); err != nil {
return err
}
if err := d.GetKubectlAndKubeconfig(); err != nil {
return err
}
return nil
}
func (d *Default) GetKubectlAndKubeconfig() error {
if utils.IsFileExist(common.DefaultKubeConfigFile()) {
return nil
}
return GetKubectlAndKubeconfig(d.SSH, utils.GetHostIP(d.Masters[0]))
}
func (d *Default) initRunner(cluster *v1.Cluster) error {
d.SSH = ssh.NewSSHByCluster(cluster)
d.ClusterName = cluster.Name
d.SvcCIDR = cluster.Spec.Network.SvcCIDR
d.PodCIDR = cluster.Spec.Network.PodCIDR
// TODO add host port
d.Masters = cluster.Spec.Masters.IPList
d.VIP = DefaultVIP
d.RegistryPort = DefaultRegistryPort
// TODO add host port
d.Nodes = cluster.Spec.Nodes.IPList
d.APIServer = DefaultAPIserverDomain
d.Rootfs = common.DefaultTheClusterRootfsDir(d.ClusterName)
d.BasePath = path.Join(common.DefaultClusterRootfsDir, d.ClusterName)
d.CertPath = fmt.Sprintf("%s/pki", d.BasePath)
d.CertEtcdPath = fmt.Sprintf("%s/etcd", d.CertPath)
d.StaticFileDir = fmt.Sprintf("%s/statics", d.Rootfs)
// TODO remote port in ipList
d.APIServerCertSANs = append(cluster.Spec.CertSANS, d.getDefaultSANs()...)
d.PodCIDR = cluster.Spec.Network.PodCIDR
d.SvcCIDR = cluster.Spec.Network.SvcCIDR
// return d.LoadMetadata()
return nil
}
func (d *Default) ConfigKubeadmOnMaster0() error {
var templateData string
var err error
var tpl []byte
var fileData []byte
if d.KubeadmFilePath == "" {
tpl, err = d.defaultTemplate()
if err != nil {
return fmt.Errorf("failed to get default kubeadm template %v", err)
}
} else {
//TODO rootfs kubeadm.tmpl
fileData, err = ioutil.ReadFile(d.KubeadmFilePath)
if err != nil {
return err
}
tpl, err = d.templateFromContent(string(fileData))
if err != nil {
return fmt.Errorf("failed to get kubeadm template %v", err)
}
}
if err != nil {
|
templateData = string(tpl)
cmd := fmt.Sprintf(WriteKubeadmConfigCmd, d.Rootfs, templateData)
err = d.SSH.CmdAsync(d.Masters[0], cmd)
if err != nil {
return err
}
kubeadm := kubeadmDataFromYaml(templateData)
if kubeadm != nil {
d.DNSDomain = kubeadm.Networking.DNSDomain
d.APIServerCertSANs = kubeadm.APIServer.CertSANs
} else {
logger.Warn("decode certSANs from config failed, using default SANs")
d.APIServerCertSANs = d.getDefaultSANs()
}
return nil
}
func (d *Default) GenerateCert() error {
err := cert.GenerateCert(
d.CertPath,
d.CertEtcdPath,
d.APIServerCertSANs,
utils.GetHostIP(d.Masters[0]),
d.GetRemoteHostName(d.Masters[0]),
d.SvcCIDR,
d.DNSDomain,
)
if err != nil {
return fmt.Errorf("generate certs failed %v", err)
}
d.sendNewCertAndKey(d.Masters[:1])
return nil
}
func (d *Default) CreateKubeConfig() error {
hostname := d.GetRemoteHostName(d.Masters[0])
certConfig := cert.Config{
Path: d.CertPath,
BaseName: "ca",
}
controlPlaneEndpoint := fmt.Sprintf("https://%s:6443", d.APIServer)
err := cert.CreateJoinControlPlaneKubeConfigFiles(d.BasePath,
certConfig, hostname, controlPlaneEndpoint, "kubernetes")
if err != nil {
return fmt.Errorf("generator kubeconfig failed %s", err)
}
return nil
}
//InitMaster0 is
func (d *Default) InitMaster0() error {
d.SendJoinMasterKubeConfigs(d.Masters[:1], AdminConf, ControllerConf, SchedulerConf, KubeletConf)
cmdAddEtcHost := fmt.Sprintf(RemoteAddEtcHosts, getAPIServerHost(utils.GetHostIP(d.Masters[0]), d.APIServer))
cmdAddRegistryHosts := fmt.Sprintf(RemoteAddEtcHosts, getRegistryHost(d.Rootfs, d.Masters[0]))
err := d.SSH.CmdAsync(d.Masters[0], cmdAddEtcHost, cmdAddRegistryHosts)
if err != nil {
return err
}
logger.Info("start to init master0...")
cmdInit := d.Command(d.Metadata.Version, InitMaster)
// TODO skip docker version error check for test
output, err := d.SSH.Cmd(d.Masters[0], cmdInit)
if err != nil {
return fmt.Errorf("init master0 failed, error: %s. Please clean and reinstall", err.Error())
}
d.decodeMaster0Output(output)
err = d.SSH.CmdAsync(d.Masters[0], RemoteCopyKubeConfig)
if err != nil {
return err
}
return nil
}
func (d *Default) CopyStaticFiles(nodes []string) error {
var flag bool
for _, file := range MasterStaticFiles {
staticFilePath := filepath.Join(d.StaticFileDir, file.Name)
cmdLinkStatic := fmt.Sprintf(RemoteCmdCopyStatic, file.DestinationDir, staticFilePath, filepath.Join(file.DestinationDir, file.Name))
var wg sync.WaitGroup
for _, host := range nodes {
wg.Add(1)
go func(host string) {
defer wg.Done()
err := d.SSH.CmdAsync(host, cmdLinkStatic)
if err != nil {
logger.Error("[%s] link static file failed, error:%s", host, err.Error())
flag = true
}
}(host)
if flag {
return fmt.Errorf("link static files failed %s %s", host, cmdLinkStatic)
}
}
wg.Wait()
}
return nil
}
//decode output to join token hash and key
func (d *Default) decodeMaster0Output(output []byte) {
s0 := string(output)
logger.Debug("[globals]decodeOutput: %s", s0)
slice := strings.Split(s0, "kubeadm join")
slice1 := strings.Split(slice[1], "Please note")
logger.Info("[globals]join command is: %s", slice1[0])
d.decodeJoinCmd(slice1[0])
}
// 192.168.0.200:6443 --token 9vr73a.a8uxyaju799qwdjv --discovery-token-ca-cert-hash sha256:7c2e69131a36ae2a042a339b33381c6d0d43887e2de83720eff5359e26aec866 --experimental-control-plane --certificate-key f8902e114ef118304e561c3ecd4d0b543adc226b7a07f675f56564185ffe0c07
func (d *Default) decodeJoinCmd(cmd string) {
logger.Debug("[globals]decodeJoinCmd: %s", cmd)
stringSlice := strings.Split(cmd, " ")
for i, r := range stringSlice {
// upstream error, delete \t, \\, \n, space.
r = strings.ReplaceAll(r, "\t", "")
r = strings.ReplaceAll(r, "\n", "")
r = strings.ReplaceAll(r, "\\", "")
r = strings.TrimSpace(r)
if strings.Contains(r, "--token") {
d.JoinToken = stringSlice[i+1]
}
if strings.Contains(r, "--discovery-token-ca-cert-hash") {
d.TokenCaCertHash = stringSlice[i+1]
}
if strings.Contains(r, "--certificate-key") {
d.CertificateKey = stringSlice[i+1][:64]
}
}
logger.Debug("joinToken: %v\nTokenCaCertHash: %v\nCertificateKey: %v", d.JoinToken, d.TokenCaCertHash, d.CertificateKey)
}
|
return err
}
|
sender_test.go
|
package keengo_test
import (
"github.com/philpearl/keengo"
"log"
"testing"
)
// TODO: pull these from somewhere for testing
const projectId = ""
const writeKey = ""
|
log.Printf("Have a sender\n")
sender.Queue("testing", map[string]interface{}{
"hat": 1,
"cheese": "wensleydale",
})
log.Printf("Queued\n")
sender.Close()
}
|
func TestSend(t *testing.T) {
log.Printf("start\n")
sender := keengo.NewSender(projectId, writeKey)
|
users.entity.ts
|
import { Entity, Column, PrimaryGeneratedColumn, BaseEntity } from 'typeorm';
import { Contains, IsInt, Length, IsEmail, IsFQDN, IsDate, Min, Max } from "class-validator";
@Entity()
export class Users extends BaseEntity {
@PrimaryGeneratedColumn()
|
@IsEmail()
email: string;
@Column({ length: 100, nullable: true, name: 'password' })
password: string | undefined;
@Column()
language: string;
@Column({ length: 100, nullable: true })
name: string | undefined;
@Column({ default: false })
verified: boolean;
@Column("simple-array")
roles: string[];
constructor(email, pw, language = 'de') {
super();
this.email = email;
this.password = pw;
this.language = language;
}
}
export interface UserMail {
email: string;
name: string;
verified: boolean;
notify: boolean;
}
|
id: number;
@Column({ length: 50, unique: true })
|
qdisasm_graph.py
|
from functools import wraps
import logging
from PySide.QtCore import QPointF, QRectF, Qt, QPoint
from PySide.QtGui import QPainter, QBrush, QColor, QApplication, QMouseEvent, QResizeEvent, QPen
from ...utils import get_out_branches
from ...utils.graph_layouter import GraphLayouter
from ...utils.cfg import categorize_edges
from ...utils.edge import EdgeSort
from .qblock import QBlock
from .qgraph import QBaseGraph
l = logging.getLogger('ui.widgets.qflow_graph')
def timeit(f):
@wraps(f)
def decorator(*args, **kwargs):
import time
start = time.time()
r = f(*args, **kwargs)
elapsed = time.time() - start
print "%s takes %f sec." % (f.__name__, elapsed)
return r
return decorator
class OperandHighlightMode(object):
SAME_IDENT = 0
SAME_TEXT = 1
class InfoDock(object):
def __init__(self):
self.induction_variable_analysis = None
self.variable_manager = None
self.highlight_mode = OperandHighlightMode.SAME_IDENT # default highlight mode
self.selected_operand = None
def initialize(self):
self.selected_operand = None
def should_highlight_operand(self, operand):
if self.selected_operand is None:
return False
if self.highlight_mode == OperandHighlightMode.SAME_TEXT or self.selected_operand.variable is None:
# when there is no related variable, we highlight as long as they have the same text
return operand.text == self.selected_operand.text
elif self.highlight_mode == OperandHighlightMode.SAME_IDENT:
if self.selected_operand.variable is not None and operand.variable is not None:
return self.selected_operand.variable.ident == operand.variable.ident
return False
class QDisasmGraph(QBaseGraph):
XSPACE = 40
YSPACE = 40
LEFT_PADDING = 1000
TOP_PADDING = 1000
def __init__(self, workspace, parent):
super(QDisasmGraph, self).__init__(parent)
self.workspace = workspace
self.disassembly_view = parent
self.disasm = None
self.variable_manager = None
self._variable_recovery_flavor = 'fast'
self.blocks = set()
self._function_graph = None
self._edges = None
# scrolling
self._is_scrolling = False
self._scrolling_start = None
self.key_pressed.connect(self._on_keypressed_event)
#self.key_released.connect(self._on_keyreleased_event)
self.selected_insns = set()
self.selected_operands = set()
self._insn_addr_to_block = { }
self._infodock = InfoDock()
#
# Properties
#
@property
def function_graph(self):
return self._function_graph
@function_graph.setter
def function_graph(self, v):
if v is not self._function_graph:
self._function_graph = v
self.reload()
@property
def variable_recovery_flavor(self):
return self._variable_recovery_flavor
@variable_recovery_flavor.setter
def variable_recovery_flavor(self, v):
if v in ('fast', 'accurate'):
if v != self._variable_recovery_flavor:
self._variable_recovery_flavor = v
# TODO: it's enough to call refresh() here if VariableManager is unique in the project
self.reload()
@property
def induction_variable_analysis(self):
return self._infodock.induction_variable_analysis
@induction_variable_analysis.setter
def induction_variable_analysis(self, v):
self._infodock.induction_variable_analysis = v
#
# Public methods
#
def reload(self):
if self.blocks:
for b in self.blocks.copy():
self.remove_block(b)
# variable recovery
if self._variable_recovery_flavor == 'fast':
vr = self.workspace.instance.project.analyses.VariableRecoveryFast(self._function_graph.function)
else:
vr = self.workspace.instance.project.analyses.VariableRecovery(self._function_graph.function)
self.variable_manager = vr.variable_manager
self._infodock.initialize()
self._infodock.variable_manager = vr.variable_manager
self.disasm = self.workspace.instance.project.analyses.Disassembly(function=self._function_graph.function)
self._insn_addr_to_block = { }
supergraph = self._function_graph.supergraph
for n in supergraph.nodes_iter():
block = QBlock(self.workspace, self._function_graph.function.addr, self.disassembly_view, self.disasm,
self._infodock, n.addr, n.cfg_nodes, get_out_branches(n)
)
self.add_block(block)
for insn_addr in block.addr_to_insns.iterkeys():
self._insn_addr_to_block[insn_addr] = block
self.request_relayout()
def refresh(self):
if not self.blocks:
return
for b in self.blocks:
b.refresh()
self.request_relayout(ensure_visible=False)
def add_block(self, block):
self.blocks.add(block)
def remove_block(self, block):
if block in self.blocks:
self.blocks.remove(block)
def update_label(self, label_addr, is_renaming=False):
"""
:return:
"""
# if it's just a renaming, we simply update the text of the label
if is_renaming:
if label_addr in self._insn_addr_to_block:
block = self._insn_addr_to_block[label_addr]
block.update_label(label_addr)
else:
# umm not sure what's going wrong
l.error('Label address %#x is not found in the current function.', label_addr)
else:
self.reload()
def select_instruction(self, insn_addr, unique=True):
block = self._insn_addr_to_block.get(insn_addr, None)
if block is None:
# the instruction does not belong to the current function
return
if insn_addr not in self.selected_insns:
if unique:
# unselect existing ones
self.unselect_all_instructions()
self.selected_insns = { insn_addr }
else:
self.selected_insns.add(insn_addr)
block.addr_to_insns[insn_addr].select()
self.viewport().update()
def unselect_instruction(self, insn_addr):
block = self._insn_addr_to_block.get(insn_addr, None)
if block is None:
return
if insn_addr in self.selected_insns:
self.selected_insns.remove(insn_addr)
block.addr_to_insns[insn_addr].unselect()
self.viewport().update()
def unselect_all_instructions(self):
for insn_addr in self.selected_insns.copy():
self.unselect_instruction(insn_addr)
def select_operand(self, insn_addr, operand_idx, unique=True):
block = self._insn_addr_to_block.get(insn_addr, None)
if block is None:
# the instruction does not belong to the current function
return
if (insn_addr, operand_idx) not in self.selected_operands:
if unique:
# unselect existing ones
self.unselect_all_operands()
self.selected_operands = { (insn_addr, operand_idx) }
else:
self.selected_operands.add((insn_addr, operand_idx))
block.addr_to_insns[insn_addr].select_operand(operand_idx)
self.viewport().update()
def unselect_operand(self, insn_addr, operand_idx):
block = self._insn_addr_to_block.get(insn_addr, None)
if block is None:
return
if (insn_addr, operand_idx) in self.selected_operands:
self.selected_operands.remove((insn_addr, operand_idx))
block.addr_to_insns[insn_addr].unselect_operand(operand_idx)
self.viewport().update()
def unselect_all_operands(self):
for insn_addr, operand_idx in self.selected_operands.copy():
self.unselect_operand(insn_addr, operand_idx)
def get_block_by_pos(self, pos):
pos = self._to_graph_pos(pos)
x, y = pos.x(), pos.y()
for b in self.blocks:
if b.x <= x < b.x + b.width and b.y <= y < b.y + b.height:
return b
return None
#
# Event handlers
#
def resizeEvent(self, event):
|
def paintEvent(self, event):
"""
Paint the graph.
:param event:
:return:
"""
painter = QPainter(self.viewport())
# scrollbar values
current_x = self.horizontalScrollBar().value()
current_y = self.verticalScrollBar().value()
# coord translation
# (0, 0) -> middle of the page
painter.translate(self.width() / 2 - current_x, self.height() / 2 - current_y)
painter.setFont(self.workspace.disasm_font)
topleft_point = self._to_graph_pos(QPoint(0, 0))
bottomright_point = self._to_graph_pos(QPoint(self.width(), self.height()))
self._draw_edges(painter, topleft_point, bottomright_point)
self._draw_nodes(painter, topleft_point, bottomright_point)
def mousePressEvent(self, event):
"""
:param QMouseEvent event:
:return:
"""
if event.button() == Qt.LeftButton:
block = self.get_block_by_pos(event.pos())
if block is not None:
# clicking on a block
block.on_mouse_pressed(event.button(), self._to_graph_pos(event.pos()))
return
else:
# dragging the entire graph
self._is_scrolling = True
self._scrolling_start = (event.x(), event.y())
self.viewport().grabMouse()
return
def mouseMoveEvent(self, event):
"""
:param QMouseEvent event:
:return:
"""
if self._is_scrolling:
pos = event.pos()
delta = (pos.x() - self._scrolling_start[0], pos.y() - self._scrolling_start[1])
self._scrolling_start = (pos.x(), pos.y())
# move the graph
self.horizontalScrollBar().setValue(self.horizontalScrollBar().value() - delta[0])
self.verticalScrollBar().setValue(self.verticalScrollBar().value() - delta[1])
def mouseReleaseEvent(self, event):
"""
:param QMouseEvent event:
:return:
"""
if event.button() == Qt.LeftButton and self._is_scrolling:
self._is_scrolling = False
self.viewport().releaseMouse()
elif event.button() == Qt.RightButton:
block = self.get_block_by_pos(event.pos())
if block is not None:
block.on_mouse_released(event.button(), self._to_graph_pos(event.pos()))
def mouseDoubleClickEvent(self, event):
"""
:param QMouseEvent event:
:return:
"""
if event.button() == Qt.LeftButton:
block = self.get_block_by_pos(event.pos())
if block is not None:
block.on_mouse_doubleclicked(event.button(), self._to_graph_pos(event.pos()))
def _on_keypressed_event(self, key_event):
key = key_event.key()
if key == Qt.Key_G:
# jump to window
self.disassembly_view.popup_jumpto_dialog()
return True
elif key == Qt.Key_N:
# rename a label
self.disassembly_view.popup_rename_label_dialog()
return True
elif key == Qt.Key_X:
# XRef
# get the variable
if self.selected_operands:
ins_addr, operand_idx = next(iter(self.selected_operands))
block = self._insn_addr_to_block.get(ins_addr, None)
if block is not None:
operand = block.addr_to_insns[ins_addr].get_operand(operand_idx)
if operand is not None and operand.variable is not None:
self.disassembly_view.popup_xref_dialog(operand.variable)
return True
elif key == Qt.Key_Escape or (key == Qt.Key_Left and QApplication.keyboardModifiers() & Qt.ALT != 0):
# jump back
self.disassembly_view.jump_back()
return True
elif key == Qt.Key_Right and QApplication.keyboardModifiers() & Qt.ALT != 0:
# jump forward
self.disassembly_view.jump_forward()
elif key == Qt.Key_A:
# switch between highlight mode
if self._infodock.highlight_mode == OperandHighlightMode.SAME_TEXT:
self._infodock.highlight_mode = OperandHighlightMode.SAME_IDENT
else:
self._infodock.highlight_mode = OperandHighlightMode.SAME_TEXT
# refresh myself
self.viewport().update()
return False
#
# Layout
#
def _layout_graph(self):
node_sizes = {}
node_map = {}
for block in self.blocks:
node_map[block.addr] = block
for node in self.function_graph.supergraph.nodes_iter():
block = node_map[node.addr]
node_sizes[node] = block.width, block.height
gl = GraphLayouter(self.function_graph.supergraph, node_sizes)
nodes = { }
for node, coords in gl.node_coordinates.iteritems():
nodes[node.addr] = coords
return nodes, gl.edges
def request_relayout(self, ensure_visible=True):
node_coords, edges = self._layout_graph()
self._edges = edges
categorize_edges(self.disasm, edges)
if not node_coords:
print "Failed to get node_coords"
return
min_x, max_x, min_y, max_y = 0, 0, 0, 0
# layout nodes
for block in self.blocks:
x, y = node_coords[block.addr]
block.x, block.y = x, y
min_x = min(min_x, block.x)
max_x = max(max_x, block.x + block.width)
min_y = min(min_y, block.y)
max_y = max(max_y, block.y + block.height)
# self._set_pos(widget_proxy, self.mapToScene(x, y))
min_x -= self.LEFT_PADDING
max_x += self.LEFT_PADDING
min_y -= self.TOP_PADDING
max_y += self.TOP_PADDING
width = (max_x - min_x) + 2 * self.LEFT_PADDING
height = (max_y - min_y) + 2 * self.TOP_PADDING
self._update_size()
# scrollbars
self.horizontalScrollBar().setRange(min_x, max_x)
self.verticalScrollBar().setRange(min_y, max_y)
self.setSceneRect(QRectF(min_x, min_y, width, height))
self.viewport().update()
self._update_size()
if ensure_visible:
if self.selected_insns:
self.show_selected()
else:
self.show_instruction(self._function_graph.function.addr)
def show_selected(self):
if self.selected_insns:
addr = next(iter(self.selected_insns))
self.show_instruction(addr)
def show_instruction(self, insn_addr):
block = self._insn_addr_to_block.get(insn_addr, None)
if block is not None:
pos = QPoint(*block.instruction_position(insn_addr))
pos_ = self._from_graph_pos(pos)
# is it visible?
if 0 <= pos_.x() < self.width() and 0 <= pos_.y() < self.height():
return
# make it visible
x, y = pos.x(), pos.y()
self.horizontalScrollBar().setValue(x - 50)
self.verticalScrollBar().setValue(y - 50)
#
# Private methods
#
def _draw_nodes(self, painter, topleft_point, bottomright_point):
# draw nodes
for block in self.blocks:
# optimization: don't paint blocks that are outside of the current range
block_topleft_point = QPoint(block.x, block.y)
block_bottomright_point = QPoint(block.x + block.width, block.y + block.height)
if block_topleft_point.x() > bottomright_point.x() or block_topleft_point.y() > bottomright_point.y():
continue
elif block_bottomright_point.x() < topleft_point.x() or block_bottomright_point.y() < topleft_point.y():
continue
block.paint(painter)
def _draw_edges(self, painter, topleft_point, bottomright_point):
# draw edges
if self._edges:
for edge in self._edges:
edge_coords = edge.coordinates
if edge.sort == EdgeSort.BACK_EDGE:
# it's a back edge
# Honey
color = QColor(0xf9, 0xd5, 0x77)
elif edge.sort == EdgeSort.TRUE_BRANCH:
# True branch
# Aqar
color = QColor(0x79, 0xcc, 0xcd)
elif edge.sort == EdgeSort.FALSE_BRANCH:
# False branch
# Tomato
color = QColor(0xf1, 0x66, 0x64)
else:
# Dark Gray
color = QColor(0x56, 0x5a, 0x5c)
pen = QPen(color)
pen.setWidth(2)
painter.setPen(pen)
for from_, to_ in zip(edge_coords, edge_coords[1:]):
start_point = QPointF(*from_)
end_point = QPointF(*to_)
# optimization: don't draw edges that are outside of the current scope
if (start_point.x() > bottomright_point.x() or start_point.y() > bottomright_point.y()) and \
(end_point.x() > bottomright_point.x() or end_point.y() > bottomright_point.y()):
continue
elif (start_point.x() < topleft_point.x() or start_point.y() < topleft_point.y()) and \
(end_point.x() < topleft_point.x() or end_point.y() < topleft_point.y()):
continue
painter.drawPolyline((start_point, end_point))
# arrow
# end_point = self.mapToScene(*edges[-1])
end_point = (edge_coords[-1][0], edge_coords[-1][1])
arrow = [QPointF(end_point[0] - 3, end_point[1]), QPointF(end_point[0] + 3, end_point[1]),
QPointF(end_point[0], end_point[1] + 6)]
brush = QBrush(color)
painter.setBrush(brush)
painter.drawPolygon(arrow)
def _update_size(self):
# update scrollbars
self.horizontalScrollBar().setPageStep(self.width())
self.verticalScrollBar().setPageStep(self.height())
def _to_graph_pos(self, pos):
x_offset = self.width() / 2 - self.horizontalScrollBar().value()
y_offset = self.height() / 2 - self.verticalScrollBar().value()
return QPoint(pos.x() - x_offset, pos.y() - y_offset)
def _from_graph_pos(self, pos):
x_offset = self.width() / 2 - self.horizontalScrollBar().value()
y_offset = self.height() / 2 - self.verticalScrollBar().value()
return QPoint(pos.x() + x_offset, pos.y() + y_offset)
|
"""
:param QResizeEvent event:
:return:
"""
self._update_size()
|
App.test.tsx
|
import * as ReactDOM from "react-dom";
import App from "./App";
|
it("renders without crashing", () => {
const div = document.createElement("div");
ReactDOM.render(<App />, div);
ReactDOM.unmountComponentAtNode(div);
});
| |
format.rs
|
pub fn format_test_name(raw: &str) -> String {
|
raw.as_bytes()
};
let filtered_name = prunned_name
.iter()
.map(|c| if *c == b':' { b'_' } else { c.to_owned() })
.collect::<Vec<u8>>();
let sliced = filtered_name.as_slice();
String::from_utf8_lossy(sliced).to_string()
}
|
let prunned_name = if let Some(idx) = raw.find("::{{closure}}") {
&raw.as_bytes()[0..idx]
} else {
|
download.py
|
#!/usr/bin/env python
from __future__ import print_function
import os
import sys
import argparse
import subprocess
from bddown_core import Pan
from util import convert_none, parse_url, add_http, logger
from config import global_config
def download_command(filename, savedir, link, cookies, limit=None, output_dir=None):
reload(sys)
sys.setdefaultencoding("utf-8")
bool(output_dir) and not os.path.exists(output_dir) and os.makedirs(output_dir)
print("\033[32m" + filename + "\033[0m")
pan_ua = 'netdisk;5.2.6;PC;PC-Windows;6.2.9200;WindowsBaiduYunGuanJia'
cmd = 'aria2c -c -d "{savedir}" -o "{filename}" -s10 -x10' \
' --user-agent="{useragent}" --header "Referer:http://pan.baidu.com/disk/home"' \
' {cookies} {limit} {dir}' \
' "{link}"'.format(savedir=savedir, filename=filename, useragent=pan_ua, link=link,
cookies=convert_none("--header \"Cookies: ", cookies),
limit=convert_none('--max-download-limit=', limit),
dir=convert_none('--dir=', output_dir))
print(cmd)
subprocess.call(cmd, shell=True)
def
|
(fis):
if len(fis) <= 1:
return fis
print("File list:")
counter = 1
for fi in fis:
savedir = fi.path.replace(fi.parent_path, '', 1)[1:]
print(str(counter) + ')', savedir + "/" + unicode(fi.filename).encode('utf8'))
counter += 1
input_numbers = raw_input("Please select files to download(e.g., 1,3-5,7):\n")
selected_numbers = []
for part in input_numbers.split(','):
x = part.split('-')
if len(x) == 1:
selected_numbers += [int(x[0])]
elif len(x) == 2:
selected_numbers += range(int(x[0]), int(x[1])+1)
else:
print("Error, your input seems illegal." + str(len(x)))
return None
# ensure no duplicate numbers
selected_numbers = list(set(selected_numbers))
selected_fis = [fis[i-1] for i in selected_numbers]
print("Download list:")
counter = 1
for sfi in selected_fis:
savedir = sfi.path.replace(sfi.parent_path, '', 1)[1:]
print(str(counter) + ')', savedir + "/" + unicode(sfi.filename).encode('utf8'))
counter += 1
return selected_fis
def download(args):
limit = global_config.limit
output_dir = global_config.dir
parser = argparse.ArgumentParser(description="download command arg parser")
parser.add_argument('-L', '--limit', action="store", dest='limit', help="Max download speed limit.")
parser.add_argument('-D', '--dir', action="store", dest='output_dir', help="Download task to dir.")
parser.add_argument('-S', '--secret', action="store", dest='secret', help="Retrieval password.", default="")
parser.add_argument('-P', '--partial', action="count", help="Partial download.")
if not args:
parser.print_help()
exit(1)
namespace, links = parser.parse_known_args(args)
secret = namespace.secret
if namespace.limit:
limit = namespace.limit
if namespace.output_dir:
output_dir = namespace.output_dir
# if is wap
links = [link.replace("wap/link", "share/link") for link in links]
# add 'http://'
links = map(add_http, links)
for url in links:
res = parse_url(url)
# normal
if res.get('type') == 1:
pan = Pan()
fis = pan.get_file_infos(url, secret)
if namespace.partial:
while True:
fis = select_download(fis)
if fis is not None:
break
for fi in fis:
cookies = 'BDUSS={0}'.format(pan.bduss) if pan.bduss else ''
if cookies and pan.pcsett:
cookies += ';pcsett={0}'.format(pan.pcsett)
if cookies:
cookies += '"'
savedir = fi.path.replace(fi.parent_path, '', 1)[1:]
download_command(fi.filename, savedir, fi.dlink, cookies=cookies, limit=limit, output_dir=output_dir)
elif res.get('type') == 4:
pan = Pan()
fsid = res.get('fsid')
newUrl = res.get('url')
infos = pan.get_file_infos(newUrl, secret, fsid)
cookies = 'BDUSS={0}'.format(pan.bduss) if pan.bduss else ''
if cookies and pan.pcsett:
cookies += ';pcsett={0}'.format(pan.pcsett)
if cookies:
cookies += '"'
for info in infos:
download_command(info.filename, info.dlink, cookies=cookies, limit=limit, output_dir=output_dir)
# album
elif res.get('type') == 2:
raise NotImplementedError('This function has not implemented.')
# home
elif res.get('type') == 3:
raise NotImplementedError('This function has not implemented.')
elif res.get('type') == 0:
logger.debug(url, extra={"type": "wrong link", "method": "None"})
continue
else:
continue
sys.exit(0)
|
select_download
|
train_valid_split.py
|
import os
import shutil
import random
import numpy as np
import matplotlib.pyplot as plt
from tqdm import tqdm
from PIL import Image
random.seed(2020)
IMG_CROP = True
# save gt_image_2 into gt_image, so that road is assigned to 255 and non-road is 0
train_gt_path = "../../data_road/training/gt_image_2/"
save_gt_path = "../../data_road/training/gt_image/"
gt_list = [f for f in os.listdir(train_gt_path) if f.endswith('.png')]
try:
shutil.rmtree(save_gt_path)
except OSError:
pass
os.mkdir(save_gt_path)
pbar = tqdm(total=289)
for gt in gt_list:
if "road" in gt:
img = np.array(Image.open(train_gt_path+gt))
height = img.shape[0]
width = img.shape[1]
gtId = np.zeros((height, width), dtype=np.uint8)
for i in range(height):
for j in range(width):
# print(img[i, j, :])
if sum(img[i, j, :] == [255, 0, 255]) == 3:
gtId[i, j] = 7
else:
gtId[i, j] = 0
gt_name = gt.split('_road_')
Image.fromarray(gtId).save(save_gt_path+gt_name[0]+'_'+gt_name[1])
pbar.update(1)
# split the training and validation data by 9:1
def traval_split(data_path, sub='um', seed=1):
random.seed(seed)
data_list = [f for f in os.listdir(data_path) if sub+'_' in f]
train_len = round(len(data_list)*0.9)
random.shuffle(data_list)
train_list = data_list[:train_len]
valid_list = data_list[train_len:]
# print(len(train_list))
# print(len(valid_list))
return train_list, valid_list
# load path
img_src_path = '../../data_road/training/image_2/'
gt_src_path = '../../data_road/training/gt_image/'
# save path
base_dir = '../../data_road_3/'
try:
shutil.rmtree(base_dir)
except OSError:
pass
os.mkdir(base_dir)
try:
shutil.rmtree(base_dir+'training')
except OSError:
pass
os.mkdir(base_dir+'training')
try:
shutil.rmtree(base_dir+'validation')
except OSError:
pass
os.mkdir(base_dir+'validation')
img_tra_path = base_dir+'training/image/'
gt_tra_path = base_dir+'training/gt_image/'
img_val_path = base_dir+'validation/image/'
gt_val_path = base_dir+'validation/gt_image/'
try:
shutil.rmtree(img_tra_path)
except OSError:
pass
os.mkdir(img_tra_path)
try:
shutil.rmtree(gt_tra_path)
except OSError:
pass
os.mkdir(gt_tra_path)
try:
shutil.rmtree(img_val_path)
except OSError:
pass
os.mkdir(img_val_path)
try:
shutil.rmtree(gt_val_path)
except OSError:
pass
os.mkdir(gt_val_path)
name_list = ['um', 'umm', 'uu']
def
|
(img):
return img.crop((0, int(img.size[1]*0.45), img.size[0], img.size[1]))
for name in name_list:
train_list, valid_list = traval_split(img_src_path, sub=name)
for valid_img in valid_list:
if IMG_CROP:
img = Image.open(img_src_path+valid_img)
img_crop = image_crop(img)
img_crop.save(img_val_path+valid_img)
gt = Image.open(gt_src_path+valid_img)
gt_crop = image_crop(gt)
gt_crop.save(gt_val_path+valid_img)
else:
shutil.copy(img_src_path+valid_img, img_val_path+valid_img)
shutil.copy(gt_src_path+valid_img, gt_val_path+valid_img)
for train_img in train_list:
if IMG_CROP:
img = Image.open(img_src_path+train_img)
img_crop = image_crop(img)
img_crop.save(img_tra_path+train_img)
gt = Image.open(gt_src_path+train_img)
gt_crop = image_crop(gt)
gt_crop.save(gt_tra_path+train_img)
else:
shutil.copy(img_src_path+train_img, img_tra_path+train_img)
shutil.copy(gt_src_path+train_img, gt_tra_path+train_img)
|
image_crop
|
test_crypto.py
|
from secrets import randbits
from django.conf import settings
from rest_framework.test import APISimpleTestCase
from fleet_management.crypto import (
sign,
verify,
inverse_of,
is_prime,
find_prime,
find_p_q_phi,
find_pair_of_keys,
hash_dict,
)
class CryptoTest(APISimpleTestCase):
|
def setUp(self) -> None:
self.n_tests = 1000
def test_sign_and_verify(self):
for _ in range(1000):
message = randbits(settings.RSA_BIT_LENGTH)
pub, priv = find_pair_of_keys()
signature = sign(message, priv)
self.assertTrue(verify(message, signature, pub))
self.assertFalse(verify(message + 1, signature, pub))
def test_inverse_of(self):
self.assertEqual(inverse_of(2, 3), 2)
self.assertEqual(inverse_of(53, 120), 77)
self.assertEqual(inverse_of(1123, 18712), 17379)
self.assertEqual(inverse_of(98751, 123719989), 68419280)
self.assertEqual(
inverse_of(65537, 1034776851837418226012406113933120080),
568411228254986589811047501435713,
)
def test_is_prime(self):
self.assertTrue(is_prime(2))
self.assertTrue(is_prime(5))
self.assertTrue(is_prime(41))
self.assertTrue(is_prime(97571))
self.assertTrue(is_prime(56790763))
self.assertTrue(is_prime(967901315627))
self.assertFalse(is_prime(1))
self.assertFalse(is_prime(12))
self.assertFalse(is_prime(42))
self.assertFalse(is_prime(2737075))
self.assertFalse(is_prime(273707521121))
def test_find_prime(self):
for _ in range(self.n_tests):
prime = find_prime(settings.RSA_BIT_LENGTH)
self.assertTrue(is_prime(prime))
def test_find_p_q_phi(self):
for _ in range(self.n_tests):
p, q, phi = find_p_q_phi()
my_phi = (p - 1) * (q - 1)
self.assertTrue(is_prime(p))
self.assertTrue(is_prime(q))
self.assertEqual(phi, my_phi)
def test_hash_dict(self):
self.assertEqual(hash_dict({}), 17022)
self.assertEqual(hash_dict({1: 1}), 361627)
self.assertEqual(hash_dict({1: 1, "asd": "asd"}), 319826)
self.assertEqual(hash_dict({1: 1, "asd": "asd", 9: [1, 2, 3]}), 319976)
self.assertEqual(hash_dict({1: {2: {3: {4: {5: {}}}}}}), 17022)
self.assertEqual(hash_dict({1: {2: {3: {4: {5: "x"}}}}}), 288678)
|
|
i2c_int_sts.rs
|
#[doc = "Register `i2c_int_sts` reader"]
pub struct R(crate::R<I2C_INT_STS_SPEC>);
impl core::ops::Deref for R {
type Target = crate::R<I2C_INT_STS_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::convert::From<crate::R<I2C_INT_STS_SPEC>> for R {
fn from(reader: crate::R<I2C_INT_STS_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `i2c_int_sts` writer"]
pub struct W(crate::W<I2C_INT_STS_SPEC>);
impl core::ops::Deref for W {
type Target = crate::W<I2C_INT_STS_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl core::convert::From<crate::W<I2C_INT_STS_SPEC>> for W {
fn from(writer: crate::W<I2C_INT_STS_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `cr_i2c_fer_en` reader - "]
pub struct CR_I2C_FER_EN_R(crate::FieldReader<bool, bool>);
impl CR_I2C_FER_EN_R {
pub(crate) fn new(bits: bool) -> Self {
CR_I2C_FER_EN_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for CR_I2C_FER_EN_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `cr_i2c_fer_en` writer - "]
pub struct CR_I2C_FER_EN_W<'a> {
w: &'a mut W,
}
impl<'a> CR_I2C_FER_EN_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 29)) | ((value as u32 & 0x01) << 29);
self.w
}
}
#[doc = "Field `cr_i2c_arb_en` reader - "]
pub struct CR_I2C_ARB_EN_R(crate::FieldReader<bool, bool>);
impl CR_I2C_ARB_EN_R {
pub(crate) fn new(bits: bool) -> Self
|
}
impl core::ops::Deref for CR_I2C_ARB_EN_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `cr_i2c_arb_en` writer - "]
pub struct CR_I2C_ARB_EN_W<'a> {
w: &'a mut W,
}
impl<'a> CR_I2C_ARB_EN_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 28)) | ((value as u32 & 0x01) << 28);
self.w
}
}
#[doc = "Field `cr_i2c_nak_en` reader - "]
pub struct CR_I2C_NAK_EN_R(crate::FieldReader<bool, bool>);
impl CR_I2C_NAK_EN_R {
pub(crate) fn new(bits: bool) -> Self {
CR_I2C_NAK_EN_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for CR_I2C_NAK_EN_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `cr_i2c_nak_en` writer - "]
pub struct CR_I2C_NAK_EN_W<'a> {
w: &'a mut W,
}
impl<'a> CR_I2C_NAK_EN_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 27)) | ((value as u32 & 0x01) << 27);
self.w
}
}
#[doc = "Field `cr_i2c_rxf_en` reader - "]
pub struct CR_I2C_RXF_EN_R(crate::FieldReader<bool, bool>);
impl CR_I2C_RXF_EN_R {
pub(crate) fn new(bits: bool) -> Self {
CR_I2C_RXF_EN_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for CR_I2C_RXF_EN_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `cr_i2c_rxf_en` writer - "]
pub struct CR_I2C_RXF_EN_W<'a> {
w: &'a mut W,
}
impl<'a> CR_I2C_RXF_EN_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 26)) | ((value as u32 & 0x01) << 26);
self.w
}
}
#[doc = "Field `cr_i2c_txf_en` reader - "]
pub struct CR_I2C_TXF_EN_R(crate::FieldReader<bool, bool>);
impl CR_I2C_TXF_EN_R {
pub(crate) fn new(bits: bool) -> Self {
CR_I2C_TXF_EN_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for CR_I2C_TXF_EN_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `cr_i2c_txf_en` writer - "]
pub struct CR_I2C_TXF_EN_W<'a> {
w: &'a mut W,
}
impl<'a> CR_I2C_TXF_EN_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 25)) | ((value as u32 & 0x01) << 25);
self.w
}
}
#[doc = "Field `cr_i2c_end_en` reader - "]
pub struct CR_I2C_END_EN_R(crate::FieldReader<bool, bool>);
impl CR_I2C_END_EN_R {
pub(crate) fn new(bits: bool) -> Self {
CR_I2C_END_EN_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for CR_I2C_END_EN_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `cr_i2c_end_en` writer - "]
pub struct CR_I2C_END_EN_W<'a> {
w: &'a mut W,
}
impl<'a> CR_I2C_END_EN_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 24)) | ((value as u32 & 0x01) << 24);
self.w
}
}
#[doc = "Field `rsvd_21` reader - "]
pub struct RSVD_21_R(crate::FieldReader<bool, bool>);
impl RSVD_21_R {
pub(crate) fn new(bits: bool) -> Self {
RSVD_21_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for RSVD_21_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `rsvd_21` writer - "]
pub struct RSVD_21_W<'a> {
w: &'a mut W,
}
impl<'a> RSVD_21_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 21)) | ((value as u32 & 0x01) << 21);
self.w
}
}
#[doc = "Field `cr_i2c_arb_clr` reader - "]
pub struct CR_I2C_ARB_CLR_R(crate::FieldReader<bool, bool>);
impl CR_I2C_ARB_CLR_R {
pub(crate) fn new(bits: bool) -> Self {
CR_I2C_ARB_CLR_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for CR_I2C_ARB_CLR_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `cr_i2c_arb_clr` writer - "]
pub struct CR_I2C_ARB_CLR_W<'a> {
w: &'a mut W,
}
impl<'a> CR_I2C_ARB_CLR_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 20)) | ((value as u32 & 0x01) << 20);
self.w
}
}
#[doc = "Field `cr_i2c_nak_clr` reader - "]
pub struct CR_I2C_NAK_CLR_R(crate::FieldReader<bool, bool>);
impl CR_I2C_NAK_CLR_R {
pub(crate) fn new(bits: bool) -> Self {
CR_I2C_NAK_CLR_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for CR_I2C_NAK_CLR_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `cr_i2c_nak_clr` writer - "]
pub struct CR_I2C_NAK_CLR_W<'a> {
w: &'a mut W,
}
impl<'a> CR_I2C_NAK_CLR_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 19)) | ((value as u32 & 0x01) << 19);
self.w
}
}
#[doc = "Field `rsvd_18` reader - "]
pub struct RSVD_18_R(crate::FieldReader<bool, bool>);
impl RSVD_18_R {
pub(crate) fn new(bits: bool) -> Self {
RSVD_18_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for RSVD_18_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `rsvd_18` writer - "]
pub struct RSVD_18_W<'a> {
w: &'a mut W,
}
impl<'a> RSVD_18_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 18)) | ((value as u32 & 0x01) << 18);
self.w
}
}
#[doc = "Field `rsvd_17` reader - "]
pub struct RSVD_17_R(crate::FieldReader<bool, bool>);
impl RSVD_17_R {
pub(crate) fn new(bits: bool) -> Self {
RSVD_17_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for RSVD_17_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `rsvd_17` writer - "]
pub struct RSVD_17_W<'a> {
w: &'a mut W,
}
impl<'a> RSVD_17_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 17)) | ((value as u32 & 0x01) << 17);
self.w
}
}
#[doc = "Field `cr_i2c_end_clr` reader - "]
pub struct CR_I2C_END_CLR_R(crate::FieldReader<bool, bool>);
impl CR_I2C_END_CLR_R {
pub(crate) fn new(bits: bool) -> Self {
CR_I2C_END_CLR_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for CR_I2C_END_CLR_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `cr_i2c_end_clr` writer - "]
pub struct CR_I2C_END_CLR_W<'a> {
w: &'a mut W,
}
impl<'a> CR_I2C_END_CLR_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 16)) | ((value as u32 & 0x01) << 16);
self.w
}
}
#[doc = "Field `cr_i2c_fer_mask` reader - "]
pub struct CR_I2C_FER_MASK_R(crate::FieldReader<bool, bool>);
impl CR_I2C_FER_MASK_R {
pub(crate) fn new(bits: bool) -> Self {
CR_I2C_FER_MASK_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for CR_I2C_FER_MASK_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `cr_i2c_fer_mask` writer - "]
pub struct CR_I2C_FER_MASK_W<'a> {
w: &'a mut W,
}
impl<'a> CR_I2C_FER_MASK_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 13)) | ((value as u32 & 0x01) << 13);
self.w
}
}
#[doc = "Field `cr_i2c_arb_mask` reader - "]
pub struct CR_I2C_ARB_MASK_R(crate::FieldReader<bool, bool>);
impl CR_I2C_ARB_MASK_R {
pub(crate) fn new(bits: bool) -> Self {
CR_I2C_ARB_MASK_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for CR_I2C_ARB_MASK_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `cr_i2c_arb_mask` writer - "]
pub struct CR_I2C_ARB_MASK_W<'a> {
w: &'a mut W,
}
impl<'a> CR_I2C_ARB_MASK_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 12)) | ((value as u32 & 0x01) << 12);
self.w
}
}
#[doc = "Field `cr_i2c_nak_mask` reader - "]
pub struct CR_I2C_NAK_MASK_R(crate::FieldReader<bool, bool>);
impl CR_I2C_NAK_MASK_R {
pub(crate) fn new(bits: bool) -> Self {
CR_I2C_NAK_MASK_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for CR_I2C_NAK_MASK_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `cr_i2c_nak_mask` writer - "]
pub struct CR_I2C_NAK_MASK_W<'a> {
w: &'a mut W,
}
impl<'a> CR_I2C_NAK_MASK_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 11)) | ((value as u32 & 0x01) << 11);
self.w
}
}
#[doc = "Field `cr_i2c_rxf_mask` reader - "]
pub struct CR_I2C_RXF_MASK_R(crate::FieldReader<bool, bool>);
impl CR_I2C_RXF_MASK_R {
pub(crate) fn new(bits: bool) -> Self {
CR_I2C_RXF_MASK_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for CR_I2C_RXF_MASK_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `cr_i2c_rxf_mask` writer - "]
pub struct CR_I2C_RXF_MASK_W<'a> {
w: &'a mut W,
}
impl<'a> CR_I2C_RXF_MASK_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 10)) | ((value as u32 & 0x01) << 10);
self.w
}
}
#[doc = "Field `cr_i2c_txf_mask` reader - "]
pub struct CR_I2C_TXF_MASK_R(crate::FieldReader<bool, bool>);
impl CR_I2C_TXF_MASK_R {
pub(crate) fn new(bits: bool) -> Self {
CR_I2C_TXF_MASK_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for CR_I2C_TXF_MASK_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `cr_i2c_txf_mask` writer - "]
pub struct CR_I2C_TXF_MASK_W<'a> {
w: &'a mut W,
}
impl<'a> CR_I2C_TXF_MASK_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 9)) | ((value as u32 & 0x01) << 9);
self.w
}
}
#[doc = "Field `cr_i2c_end_mask` reader - "]
pub struct CR_I2C_END_MASK_R(crate::FieldReader<bool, bool>);
impl CR_I2C_END_MASK_R {
pub(crate) fn new(bits: bool) -> Self {
CR_I2C_END_MASK_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for CR_I2C_END_MASK_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `cr_i2c_end_mask` writer - "]
pub struct CR_I2C_END_MASK_W<'a> {
w: &'a mut W,
}
impl<'a> CR_I2C_END_MASK_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 8)) | ((value as u32 & 0x01) << 8);
self.w
}
}
#[doc = "Field `i2c_fer_int` reader - "]
pub struct I2C_FER_INT_R(crate::FieldReader<bool, bool>);
impl I2C_FER_INT_R {
pub(crate) fn new(bits: bool) -> Self {
I2C_FER_INT_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for I2C_FER_INT_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `i2c_arb_int` reader - "]
pub struct I2C_ARB_INT_R(crate::FieldReader<bool, bool>);
impl I2C_ARB_INT_R {
pub(crate) fn new(bits: bool) -> Self {
I2C_ARB_INT_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for I2C_ARB_INT_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `i2c_nak_int` reader - "]
pub struct I2C_NAK_INT_R(crate::FieldReader<bool, bool>);
impl I2C_NAK_INT_R {
pub(crate) fn new(bits: bool) -> Self {
I2C_NAK_INT_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for I2C_NAK_INT_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `i2c_rxf_int` reader - "]
pub struct I2C_RXF_INT_R(crate::FieldReader<bool, bool>);
impl I2C_RXF_INT_R {
pub(crate) fn new(bits: bool) -> Self {
I2C_RXF_INT_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for I2C_RXF_INT_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `i2c_txf_int` reader - "]
pub struct I2C_TXF_INT_R(crate::FieldReader<bool, bool>);
impl I2C_TXF_INT_R {
pub(crate) fn new(bits: bool) -> Self {
I2C_TXF_INT_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for I2C_TXF_INT_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `i2c_end_int` reader - "]
pub struct I2C_END_INT_R(crate::FieldReader<bool, bool>);
impl I2C_END_INT_R {
pub(crate) fn new(bits: bool) -> Self {
I2C_END_INT_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for I2C_END_INT_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl R {
#[doc = "Bit 29"]
#[inline(always)]
pub fn cr_i2c_fer_en(&self) -> CR_I2C_FER_EN_R {
CR_I2C_FER_EN_R::new(((self.bits >> 29) & 0x01) != 0)
}
#[doc = "Bit 28"]
#[inline(always)]
pub fn cr_i2c_arb_en(&self) -> CR_I2C_ARB_EN_R {
CR_I2C_ARB_EN_R::new(((self.bits >> 28) & 0x01) != 0)
}
#[doc = "Bit 27"]
#[inline(always)]
pub fn cr_i2c_nak_en(&self) -> CR_I2C_NAK_EN_R {
CR_I2C_NAK_EN_R::new(((self.bits >> 27) & 0x01) != 0)
}
#[doc = "Bit 26"]
#[inline(always)]
pub fn cr_i2c_rxf_en(&self) -> CR_I2C_RXF_EN_R {
CR_I2C_RXF_EN_R::new(((self.bits >> 26) & 0x01) != 0)
}
#[doc = "Bit 25"]
#[inline(always)]
pub fn cr_i2c_txf_en(&self) -> CR_I2C_TXF_EN_R {
CR_I2C_TXF_EN_R::new(((self.bits >> 25) & 0x01) != 0)
}
#[doc = "Bit 24"]
#[inline(always)]
pub fn cr_i2c_end_en(&self) -> CR_I2C_END_EN_R {
CR_I2C_END_EN_R::new(((self.bits >> 24) & 0x01) != 0)
}
#[doc = "Bit 21"]
#[inline(always)]
pub fn rsvd_21(&self) -> RSVD_21_R {
RSVD_21_R::new(((self.bits >> 21) & 0x01) != 0)
}
#[doc = "Bit 20"]
#[inline(always)]
pub fn cr_i2c_arb_clr(&self) -> CR_I2C_ARB_CLR_R {
CR_I2C_ARB_CLR_R::new(((self.bits >> 20) & 0x01) != 0)
}
#[doc = "Bit 19"]
#[inline(always)]
pub fn cr_i2c_nak_clr(&self) -> CR_I2C_NAK_CLR_R {
CR_I2C_NAK_CLR_R::new(((self.bits >> 19) & 0x01) != 0)
}
#[doc = "Bit 18"]
#[inline(always)]
pub fn rsvd_18(&self) -> RSVD_18_R {
RSVD_18_R::new(((self.bits >> 18) & 0x01) != 0)
}
#[doc = "Bit 17"]
#[inline(always)]
pub fn rsvd_17(&self) -> RSVD_17_R {
RSVD_17_R::new(((self.bits >> 17) & 0x01) != 0)
}
#[doc = "Bit 16"]
#[inline(always)]
pub fn cr_i2c_end_clr(&self) -> CR_I2C_END_CLR_R {
CR_I2C_END_CLR_R::new(((self.bits >> 16) & 0x01) != 0)
}
#[doc = "Bit 13"]
#[inline(always)]
pub fn cr_i2c_fer_mask(&self) -> CR_I2C_FER_MASK_R {
CR_I2C_FER_MASK_R::new(((self.bits >> 13) & 0x01) != 0)
}
#[doc = "Bit 12"]
#[inline(always)]
pub fn cr_i2c_arb_mask(&self) -> CR_I2C_ARB_MASK_R {
CR_I2C_ARB_MASK_R::new(((self.bits >> 12) & 0x01) != 0)
}
#[doc = "Bit 11"]
#[inline(always)]
pub fn cr_i2c_nak_mask(&self) -> CR_I2C_NAK_MASK_R {
CR_I2C_NAK_MASK_R::new(((self.bits >> 11) & 0x01) != 0)
}
#[doc = "Bit 10"]
#[inline(always)]
pub fn cr_i2c_rxf_mask(&self) -> CR_I2C_RXF_MASK_R {
CR_I2C_RXF_MASK_R::new(((self.bits >> 10) & 0x01) != 0)
}
#[doc = "Bit 9"]
#[inline(always)]
pub fn cr_i2c_txf_mask(&self) -> CR_I2C_TXF_MASK_R {
CR_I2C_TXF_MASK_R::new(((self.bits >> 9) & 0x01) != 0)
}
#[doc = "Bit 8"]
#[inline(always)]
pub fn cr_i2c_end_mask(&self) -> CR_I2C_END_MASK_R {
CR_I2C_END_MASK_R::new(((self.bits >> 8) & 0x01) != 0)
}
#[doc = "Bit 5"]
#[inline(always)]
pub fn i2c_fer_int(&self) -> I2C_FER_INT_R {
I2C_FER_INT_R::new(((self.bits >> 5) & 0x01) != 0)
}
#[doc = "Bit 4"]
#[inline(always)]
pub fn i2c_arb_int(&self) -> I2C_ARB_INT_R {
I2C_ARB_INT_R::new(((self.bits >> 4) & 0x01) != 0)
}
#[doc = "Bit 3"]
#[inline(always)]
pub fn i2c_nak_int(&self) -> I2C_NAK_INT_R {
I2C_NAK_INT_R::new(((self.bits >> 3) & 0x01) != 0)
}
#[doc = "Bit 2"]
#[inline(always)]
pub fn i2c_rxf_int(&self) -> I2C_RXF_INT_R {
I2C_RXF_INT_R::new(((self.bits >> 2) & 0x01) != 0)
}
#[doc = "Bit 1"]
#[inline(always)]
pub fn i2c_txf_int(&self) -> I2C_TXF_INT_R {
I2C_TXF_INT_R::new(((self.bits >> 1) & 0x01) != 0)
}
#[doc = "Bit 0"]
#[inline(always)]
pub fn i2c_end_int(&self) -> I2C_END_INT_R {
I2C_END_INT_R::new((self.bits & 0x01) != 0)
}
}
impl W {
#[doc = "Bit 29"]
#[inline(always)]
pub fn cr_i2c_fer_en(&mut self) -> CR_I2C_FER_EN_W {
CR_I2C_FER_EN_W { w: self }
}
#[doc = "Bit 28"]
#[inline(always)]
pub fn cr_i2c_arb_en(&mut self) -> CR_I2C_ARB_EN_W {
CR_I2C_ARB_EN_W { w: self }
}
#[doc = "Bit 27"]
#[inline(always)]
pub fn cr_i2c_nak_en(&mut self) -> CR_I2C_NAK_EN_W {
CR_I2C_NAK_EN_W { w: self }
}
#[doc = "Bit 26"]
#[inline(always)]
pub fn cr_i2c_rxf_en(&mut self) -> CR_I2C_RXF_EN_W {
CR_I2C_RXF_EN_W { w: self }
}
#[doc = "Bit 25"]
#[inline(always)]
pub fn cr_i2c_txf_en(&mut self) -> CR_I2C_TXF_EN_W {
CR_I2C_TXF_EN_W { w: self }
}
#[doc = "Bit 24"]
#[inline(always)]
pub fn cr_i2c_end_en(&mut self) -> CR_I2C_END_EN_W {
CR_I2C_END_EN_W { w: self }
}
#[doc = "Bit 21"]
#[inline(always)]
pub fn rsvd_21(&mut self) -> RSVD_21_W {
RSVD_21_W { w: self }
}
#[doc = "Bit 20"]
#[inline(always)]
pub fn cr_i2c_arb_clr(&mut self) -> CR_I2C_ARB_CLR_W {
CR_I2C_ARB_CLR_W { w: self }
}
#[doc = "Bit 19"]
#[inline(always)]
pub fn cr_i2c_nak_clr(&mut self) -> CR_I2C_NAK_CLR_W {
CR_I2C_NAK_CLR_W { w: self }
}
#[doc = "Bit 18"]
#[inline(always)]
pub fn rsvd_18(&mut self) -> RSVD_18_W {
RSVD_18_W { w: self }
}
#[doc = "Bit 17"]
#[inline(always)]
pub fn rsvd_17(&mut self) -> RSVD_17_W {
RSVD_17_W { w: self }
}
#[doc = "Bit 16"]
#[inline(always)]
pub fn cr_i2c_end_clr(&mut self) -> CR_I2C_END_CLR_W {
CR_I2C_END_CLR_W { w: self }
}
#[doc = "Bit 13"]
#[inline(always)]
pub fn cr_i2c_fer_mask(&mut self) -> CR_I2C_FER_MASK_W {
CR_I2C_FER_MASK_W { w: self }
}
#[doc = "Bit 12"]
#[inline(always)]
pub fn cr_i2c_arb_mask(&mut self) -> CR_I2C_ARB_MASK_W {
CR_I2C_ARB_MASK_W { w: self }
}
#[doc = "Bit 11"]
#[inline(always)]
pub fn cr_i2c_nak_mask(&mut self) -> CR_I2C_NAK_MASK_W {
CR_I2C_NAK_MASK_W { w: self }
}
#[doc = "Bit 10"]
#[inline(always)]
pub fn cr_i2c_rxf_mask(&mut self) -> CR_I2C_RXF_MASK_W {
CR_I2C_RXF_MASK_W { w: self }
}
#[doc = "Bit 9"]
#[inline(always)]
pub fn cr_i2c_txf_mask(&mut self) -> CR_I2C_TXF_MASK_W {
CR_I2C_TXF_MASK_W { w: self }
}
#[doc = "Bit 8"]
#[inline(always)]
pub fn cr_i2c_end_mask(&mut self) -> CR_I2C_END_MASK_W {
CR_I2C_END_MASK_W { w: self }
}
#[doc = "Writes raw bits to the register."]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.0.bits(bits);
self
}
}
#[doc = "i2c_int_sts.\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [i2c_int_sts](index.html) module"]
pub struct I2C_INT_STS_SPEC;
impl crate::RegisterSpec for I2C_INT_STS_SPEC {
type Ux = u32;
}
#[doc = "`read()` method returns [i2c_int_sts::R](R) reader structure"]
impl crate::Readable for I2C_INT_STS_SPEC {
type Reader = R;
}
#[doc = "`write(|w| ..)` method takes [i2c_int_sts::W](W) writer structure"]
impl crate::Writable for I2C_INT_STS_SPEC {
type Writer = W;
}
#[doc = "`reset()` method sets i2c_int_sts to value 0x3f00_3f00"]
impl crate::Resettable for I2C_INT_STS_SPEC {
#[inline(always)]
fn reset_value() -> Self::Ux {
0x3f00_3f00
}
}
|
{
CR_I2C_ARB_EN_R(crate::FieldReader::new(bits))
}
|
roster_dto.rs
|
/*
*
*
* No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
*
* The version of the OpenAPI document: 1.0.0
*
* Generated by: https://openapi-generator.tech
*/
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct
|
{
#[serde(rename = "banned", skip_serializing_if = "Option::is_none")]
pub banned: Option<bool>,
#[serde(rename = "captainId", skip_serializing_if = "Option::is_none")]
pub captain_id: Option<i64>,
#[serde(rename = "dynamicState", skip_serializing_if = "Option::is_none")]
pub dynamic_state: Option<crate::models::RosterDynamicStateDto>,
#[serde(rename = "eliminated", skip_serializing_if = "Option::is_none")]
pub eliminated: Option<bool>,
#[serde(rename = "id", skip_serializing_if = "Option::is_none")]
pub id: Option<i64>,
#[serde(rename = "invitationId", skip_serializing_if = "Option::is_none")]
pub invitation_id: Option<String>,
#[serde(rename = "logo", skip_serializing_if = "Option::is_none")]
pub logo: Option<i32>,
#[serde(rename = "logoColor", skip_serializing_if = "Option::is_none")]
pub logo_color: Option<i32>,
#[serde(rename = "losses", skip_serializing_if = "Option::is_none")]
pub losses: Option<i32>,
#[serde(rename = "members", skip_serializing_if = "Option::is_none")]
pub members: Option<Vec<crate::models::RosterMemberDto>>,
#[serde(rename = "name", skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "phases", skip_serializing_if = "Option::is_none")]
pub phases: Option<Vec<crate::models::PhaseRosterDto>>,
#[serde(rename = "points", skip_serializing_if = "Option::is_none")]
pub points: Option<i32>,
#[serde(rename = "shortName", skip_serializing_if = "Option::is_none")]
pub short_name: Option<String>,
#[serde(rename = "tier", skip_serializing_if = "Option::is_none")]
pub tier: Option<i32>,
#[serde(rename = "tournamentId", skip_serializing_if = "Option::is_none")]
pub tournament_id: Option<i64>,
#[serde(rename = "version", skip_serializing_if = "Option::is_none")]
pub version: Option<i32>,
#[serde(rename = "wins", skip_serializing_if = "Option::is_none")]
pub wins: Option<i32>,
}
impl RosterDto {
pub fn new() -> RosterDto {
RosterDto {
banned: None,
captain_id: None,
dynamic_state: None,
eliminated: None,
id: None,
invitation_id: None,
logo: None,
logo_color: None,
losses: None,
members: None,
name: None,
phases: None,
points: None,
short_name: None,
tier: None,
tournament_id: None,
version: None,
wins: None,
}
}
}
|
RosterDto
|
cleaning.py
|
from __future__ import division
from __future__ import absolute_import
# from __future__ import unicode_literals
from sklearn.feature_extraction.text import strip_accents_ascii, \
strip_accents_unicode
def clean(s, lowercase=True, replace_by_none=r'[^ \-\_A-Za-z0-9]+',
replace_by_whitespace=r'[\-\_]', strip_accents=None,
remove_brackets=True, encoding='utf-8', decode_error='strict'):
"""Clean string variables.
Clean strings in the Series by removing unwanted tokens, whitespace and
brackets.
Parameters
----------
s : pandas.Series
A Series to clean.
lower : bool, optional
Convert strings in the Series to lowercase. Default True.
replace_by_none : str, optional
The matches of this regular expression are replaced by ''.
replace_by_whitespace : str, optional
The matches of this regular expression are replaced by a whitespace.
remove_brackets : bool, optional
Remove all content between brackets and the brackets themselves.
Default True.
strip_accents : {'ascii', 'unicode', None}, optional
Remove accents during the preprocessing step. 'ascii' is a fast method
that only works on characters that have an direct ASCII mapping.
'unicode' is a slightly slower method that works on any characters.
None (default) does nothing.
encoding : string, optional
If bytes are given, this encoding is used to decode. Default is
'utf-8'.
decode_error : {'strict', 'ignore', 'replace'}, optional
Instruction on what to do if a byte Series is given that contains
characters not of the given `encoding`. By default, it is 'strict',
meaning that a UnicodeDecodeError will be raised. Other values are
'ignore' and 'replace'.
Example
-------
>>> import pandas
>>> from recordlinkage.standardise import clean
>>>
>>> name = ['Mary-ann', 'Bob :)', 'Angel', 'Bob (alias Billy)', None]
>>> s = pandas.Series(names)
>>> print(clean(s))
0 mary ann
1 bob
2 angel
3 bob
4 NaN
dtype: object
Returns
-------
pandas.Series:
A cleaned Series of strings.
"""
if s.shape[0] == 0:
return s
# Lower s if lower is True
if lowercase is True:
s = s.str.lower()
# Accent stripping based on https://github.com/scikit-learn/
# scikit-learn/blob/412996f/sklearn/feature_extraction/text.py
# BSD license
if not strip_accents:
pass
elif callable(strip_accents):
strip_accents_fn = strip_accents
elif strip_accents == 'ascii':
strip_accents_fn = strip_accents_ascii
elif strip_accents == 'unicode':
strip_accents_fn = strip_accents_unicode
else:
raise ValueError(
"Invalid value for 'strip_accents': {}".format(strip_accents)
)
# Remove accents etc
if strip_accents:
# encoding
s = s.apply(
lambda x: x.decode(encoding, decode_error) if type(x) == bytes else x)
s = s.map(lambda x: strip_accents_fn(x))
# Remove all content between brackets
if remove_brackets is True:
s = s.str.replace(r'(\[.*?\]|\(.*?\)|\{.*?\})', '')
# Remove the special characters
if replace_by_none:
s = s.str.replace(replace_by_none, '')
if replace_by_whitespace:
s = s.str.replace(replace_by_whitespace, ' ')
# Remove multiple whitespaces
s = s.str.replace(r'\s\s+', ' ')
# Strip s
s = s.str.lstrip().str.rstrip()
return s
def phonenumbers(s):
"""Clean phonenumbers by removing all non-numbers (except +).
Parameters
----------
s: pandas.Series
A Series to clean.
Returns
-------
pandas.Series
A Series with cleaned phonenumbers.
"""
# Remove all special tokens
s = s.astype(object).str.replace('[^0-9+]+', '')
return s
def
|
(s):
"""Count the number of times each value occurs.
This function returns the counts for each row, in contrast with
`pandas.value_counts <http://pandas.pydata.org/pandas-
docs/stable/generated/pandas.Series.value_counts.html>`_.
Returns
-------
pandas.Series
A Series with value counts.
"""
# https://github.com/pydata/pandas/issues/3729
value_count = s.fillna('NAN')
return value_count.groupby(by=value_count).transform('count')
|
value_occurence
|
issue-18738.rs
|
// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
#[deriving(PartialEq, PartialOrd)]
enum
|
<'a> {
Int(&'a int),
Slice(&'a [u8]),
}
#[deriving(PartialEq, PartialOrd)]
struct Version {
vendor_info: &'static str
}
#[deriving(PartialEq, PartialOrd)]
struct Foo(&'static str);
fn main() {}
|
Test
|
plot_ProfileVar_Monthly_FDR.py
|
"""
Plot vertical plots of PAMIP data for each month from November to April using
the ensemble mean (300)
Notes
-----
Author : Zachary Labe
Date : 26 June 2019
"""
### Import modules
import numpy as np
import matplotlib.pyplot as plt
import datetime
import read_MonthlyData as MO
import statsmodels.stats.multitest as fdr
import cmocean
import itertools
### Define directories
directorydata = '/seley/zlabe/simu/'
directoryfigure = '/home/zlabe/Desktop/STRATOVARI/'
#directoryfigure = '/home/zlabe/Documents/Research/SITperturb/Figures/'
### Define time
now = datetime.datetime.now()
currentmn = str(now.month)
currentdy = str(now.day)
currentyr = str(now.year)
currenttime = currentmn + '_' + currentdy + '_' + currentyr
titletime = currentmn + '/' + currentdy + '/' + currentyr
print('\n' '----Plotting Monthly Vertical Profiles- %s----' % titletime)
### Alott time series (300 ensemble members)
year1 = 1701
year2 = 2000
years = np.arange(year1,year2+1,1)
###############################################################################
###############################################################################
###############################################################################
### Call arguments
varnames = ['U','GEOP','TEMP','V','EGR']
def
|
(varx,vary):
"""
Function calculates statistical difference for 2 independent
sample t-test
Parameters
----------
varx : 3d array
vary : 3d array
Returns
-------
stat = calculated t-statistic
pvalue = two-tailed p-value
Usage
-----
stat,pvalue = calc_ttest(varx,vary)
"""
print('\n>>> Using calc_ttest function!')
### Import modules
import scipy.stats as sts
### 2-independent sample t-test
stat,pvalue = sts.ttest_ind(varx,vary,nan_policy='omit')
print('*Completed: Finished calc_ttest function!')
return stat,pvalue
######################
def readDataPeriods(varnames,sliceq):
### Call function for 4d variable data
lat,lon,lev,varfuture = MO.readExperiAll(varnames,'Future','profile')
lat,lon,lev,varpast = MO.readExperiAll(varnames,'Past','profile')
### Select ensemble mean period
if sliceq == 'Mean':
varfuture = varfuture[:,:,:,:,:]
varpast = varpast[:,:,:,:,:]
elif sliceq == 'A':
varfuture = varfuture[:100,:,:,:,:]
varpast = varpast[:100,:,:,:,:]
elif sliceq == 'B':
varfuture = varfuture[100:200,:,:,:,:]
varpast = varpast[100:200,:,:,:,:]
elif sliceq == 'C':
varfuture = varfuture[200:,:,:,:,:]
varpast = varpast[200:,:,:,:,:]
### Create 2d array of latitude and longitude
lon2,lat2 = np.meshgrid(lon,lat)
### Remove missing data
varfuture[np.where(varfuture <= -1e10)] = np.nan
varpast[np.where(varpast <= -1e10)] = np.nan
### Rearrange months (N,D,J,F,M,A)
varfuturem = np.append(varfuture[:,-2:,:,:,:],varfuture[:,:4,:,:,:],
axis=1)
varpastm = np.append(varpast[:,-2:,:,:,:],varpast[:,:4,:,:,:],axis=1)
### Calculate zonal means
varfuturemz = np.nanmean(varfuturem,axis=4)
varpastmz = np.nanmean(varpastm,axis=4)
### Calculate anomalies
anompi = varfuturemz - varpastmz
### Calculate ensemble mean
anompim = np.nanmean(anompi,axis=0)
zdiffruns = anompim
### Calculate climatologies
zclimo = np.nanmean(varpastmz,axis=0)
### Calculate significance for each month
stat_past = np.empty((varpastm.shape[1],len(lev),len(lat)))
pvalue_past = np.empty((varpastm.shape[1],len(lev),len(lat)))
for i in range(varpastm.shape[1]):
stat_past[i],pvalue_past[i] = calc_indttestfdr(varfuturemz[:,i,:,:],
varpastmz[:,i,:,:])
### Ravel into month x all p values
prunsr = np.reshape(pvalue_past,
(pvalue_past.shape[0],pvalue_past.shape[1] \
* pvalue_past.shape[2]))
### Calculate false discovery rate
prunsq = np.empty((prunsr.shape))
prunsq.fill(np.nan)
prunsqq = np.empty((prunsr.shape[1]))
prunsqq.fill(np.nan)
for i in range(prunsr.shape[0]):
### Check for nans before correction!!
mask = np.isfinite(prunsr[i,:])
prunsrr = prunsr[i,:]
score,prunsqq[mask] = fdr.fdrcorrection(prunsrr[mask],alpha=0.05,
method='indep')
prunsq[i,:] = prunsqq
### Reshape into month x lat x lon
pruns = np.reshape(prunsq,(pvalue_past.shape))
### Mask variables by their adjusted p-values
pruns[np.where(pruns >= 0.05)] = np.nan
pruns[np.where(pruns < 0.05)] = 1.
pruns[np.where(np.isnan(pruns))] = 0.
return zdiffruns,zclimo,pruns,lat,lon,lev
###########################################################################
###########################################################################
###########################################################################
### Read in data
for v in range(len(varnames)):
diffm,climom,pvalm,lat,lon,lev = readDataPeriods(varnames[v],'Mean')
diffa,climoa,pvala,lat,lon,lev = readDataPeriods(varnames[v],'A')
diffb,climob,pvalb,lat,lon,lev = readDataPeriods(varnames[v],'B')
diffc,climoc,pvalc,lat,lon,lev = readDataPeriods(varnames[v],'C')
varn = list(itertools.chain(*[diffm,diffa,diffb,diffc]))
zclimo = list(itertools.chain(*[climom,climoa,climob,climoc]))
pvarn = list(itertools.chain(*[pvalm,pvala,pvalb,pvalc]))
### Plot Variables
plt.rc('text',usetex=True)
plt.rc('font',**{'family':'sans-serif','sans-serif':['Avant Garde']})
### Set limits for contours and colorbars
if varnames[v] == 'U':
limit = np.arange(-2,2.1,0.1)
barlim = np.arange(-2,3,1)
elif varnames[v] == 'TEMP':
limit = np.arange(-4,4.1,0.2)
barlim = np.arange(-4,5,1)
elif varnames[v] == 'GEOP':
limit = np.arange(-60,61,2)
barlim = np.arange(-60,61,30)
elif varnames[v] == 'V':
limit = np.arange(-0.2,0.21,0.02)
barlim = np.arange(-0.2,0.3,0.1)
elif varnames[v] == 'EGR':
limit = np.arange(-0.08,0.081,0.005)
barlim = np.arange(-0.08,0.09,0.04)
zscale = np.array([1000,700,500,300,200,
100,50,30,10])
latq,levq = np.meshgrid(lat,lev)
fig = plt.figure()
for i in range(len(varn)):
ax1 = plt.subplot(4,6,i+1)
ax1.spines['top'].set_color('dimgrey')
ax1.spines['right'].set_color('dimgrey')
ax1.spines['bottom'].set_color('dimgrey')
ax1.spines['left'].set_color('dimgrey')
ax1.spines['left'].set_linewidth(2)
ax1.spines['bottom'].set_linewidth(2)
ax1.spines['right'].set_linewidth(2)
ax1.spines['top'].set_linewidth(2)
ax1.tick_params(axis='y',direction='out',which='major',pad=3,
width=2,color='dimgrey')
ax1.tick_params(axis='x',direction='out',which='major',pad=3,
width=2,color='dimgrey')
cs = plt.contourf(lat,lev,varn[i]*pvarn[i],limit,extend='both')
if varnames[v] == 'U':
cs2 = plt.contour(lat,lev,zclimo[i],np.arange(-20,101,5),
linewidths=0.5,colors='dimgrey')
plt.gca().invert_yaxis()
plt.yscale('log',nonposy='clip')
plt.xticks(np.arange(0,96,30),map(str,np.arange(0,91,30)),fontsize=5)
plt.yticks(zscale,map(str,zscale),ha='right',fontsize=5)
plt.minorticks_off()
plt.xlim([0,90])
plt.ylim([1000,10])
if any([i==0,i==6,i==12,i==18]):
ax1.tick_params(labelleft='on')
else:
ax1.tick_params(labelleft='off')
if i < 18:
ax1.tick_params(labelbottom='off')
if any([i==0,i==6,i==12]):
ax1.tick_params(axis='y',direction='out',which='major',pad=3,
width=2,color='dimgrey')
ax1.tick_params(axis='x',direction='out',which='major',pad=3,
width=0,color='dimgrey')
else:
if i < 24 and i != 18:
ax1.tick_params(axis='y',direction='out',which='major',pad=3,
width=0,color='dimgrey')
if i < 18:
ax1.tick_params(axis='y',direction='out',which='major',
pad=3,width=0,color='dimgrey')
ax1.tick_params(axis='x',direction='out',which='major',
pad=3,width=0,color='dimgrey')
if varnames[v] == 'U':
cmap = cmocean.cm.balance
cs.set_cmap(cmap)
elif varnames[v] == 'TEMP':
cmap = cmocean.cm.balance
cs.set_cmap(cmap)
elif varnames[v] == 'GEOP':
cmap = cmocean.cm.balance
cs.set_cmap(cmap)
elif varnames[v] == 'V':
cmap = cmocean.cm.balance
cs.set_cmap(cmap)
elif varnames[v] == 'EGR':
cmap = cmocean.cm.diff
cs.set_cmap(cmap)
labelmonths = [r'NOV',r'DEC',r'JAN',r'FEB',r'MAR',r'APR']
if i < 6:
ax1.annotate(r'\textbf{%s}' % labelmonths[i],
xy=(0, 0),xytext=(0.5,1.13),xycoords='axes fraction',
fontsize=13,color='dimgrey',rotation=0,
ha='center',va='center')
if i==0:
plt.annotate(r'\textbf{Mean}',
xy=(0, 0),xytext=(-0.6,0.5),xycoords='axes fraction',
fontsize=15,color='k',rotation=90,
ha='center',va='center')
elif i==6:
plt.annotate(r'\textbf{A}',
xy=(0, 0),xytext=(-0.6,0.5),xycoords='axes fraction',
fontsize=15,color='k',rotation=90,
ha='center',va='center')
elif i==12:
plt.annotate(r'\textbf{B}',
xy=(0, 0),xytext=(-0.6,0.5),xycoords='axes fraction',
fontsize=15,color='k',rotation=90,
ha='center',va='center')
elif i==18:
plt.annotate(r'\textbf{C}',
xy=(0, 0),xytext=(-0.6,0.5),xycoords='axes fraction',
fontsize=15,color='k',rotation=90,
ha='center',va='center')
cbar_ax = fig.add_axes([0.312,0.07,0.4,0.02])
cbar = fig.colorbar(cs,cax=cbar_ax,orientation='horizontal',
extend='both',extendfrac=0.07,drawedges=False)
if varnames[v] == 'U':
cbar.set_label(r'\textbf{m/s}',fontsize=9,color='dimgray',
labelpad=0)
elif varnames[v] == 'TEMP':
cbar.set_label(r'\textbf{$^\circ$C}',fontsize=9,color='dimgray',
labelpad=0)
elif varnames[v] == 'GEOP':
cbar.set_label(r'\textbf{m}',fontsize=9,color='dimgray',
labelpad=0)
elif varnames[v] == 'V':
cbar.set_label(r'\textbf{m/s}',fontsize=9,color='dimgray',
labelpad=0)
elif varnames[v] == 'EGR':
cbar.set_label(r'\textbf{1/day}',fontsize=9,color='dimgray',
labelpad=0)
cbar.set_ticks(barlim)
cbar.set_ticklabels(list(map(str,barlim)))
cbar.ax.tick_params(axis='x', size=.01)
cbar.outline.set_edgecolor('dimgrey')
cbar.outline.set_linewidth(0.5)
cbar.ax.tick_params(labelsize=6)
plt.annotate(r'\textbf{Latitude ($^{\circ}$N)',
xy=(0, 0),xytext=(0.515,0.12),xycoords='figure fraction',
fontsize=6,color='k',rotation=0,
ha='center',va='center')
plt.subplots_adjust(hspace=0.1,bottom=0.17,top=0.93,wspace=0.1)
plt.savefig(directoryfigure + '%s_MonthlyProfiles_100yr_FDR.png' % varnames[v],
dpi=300)
print('Completed: Script done!')
|
calc_indttestfdr
|
main_test.go
|
package main
import (
"reflect"
"testing"
"github.com/google/go-cmp/cmp"
"github.com/sirupsen/logrus"
"k8s.io/apimachinery/pkg/util/sets"
"k8s.io/test-infra/prow/config/org"
"k8s.io/test-infra/prow/github/fakegithub"
)
func TestGenerateRepositories(t *testing.T) {
pntrBool := func(b bool) *bool { return &b }
pntrString := func(s string) *string { return &s }
orgRepos := map[string]sets.String{
"openshift": sets.NewString([]string{"repo1", "repo2"}...),
|
"testshift": sets.NewString([]string{"repo3", "repo4"}...),
}
expectedRepos := map[string]org.Repo{
"repo1": {
HasProjects: pntrBool(false),
AllowSquashMerge: pntrBool(false),
AllowMergeCommit: pntrBool(false),
AllowRebaseMerge: pntrBool(false),
Description: pntrString("Test Repo: repo1"),
Private: pntrBool(true),
},
"repo2": {
HasProjects: pntrBool(false),
AllowSquashMerge: pntrBool(false),
AllowMergeCommit: pntrBool(false),
AllowRebaseMerge: pntrBool(false),
Description: pntrString("Test Repo: repo2"),
Private: pntrBool(true),
},
"repo3": {
HasProjects: pntrBool(false),
AllowSquashMerge: pntrBool(false),
AllowMergeCommit: pntrBool(false),
AllowRebaseMerge: pntrBool(false),
Description: pntrString("Test Repo: repo3"),
Private: pntrBool(true),
},
"repo4": {
HasProjects: pntrBool(false),
AllowSquashMerge: pntrBool(false),
AllowMergeCommit: pntrBool(false),
AllowRebaseMerge: pntrBool(false),
Description: pntrString("Test Repo: repo4"),
Private: pntrBool(true),
},
}
repos := generateRepositories(&fakegithub.FakeClient{}, orgRepos, logrus.WithField("destination-org", "testOrg"))
if !reflect.DeepEqual(repos, expectedRepos) {
t.Fatal(cmp.Diff(repos, expectedRepos))
}
}
| |
Code.py
|
# SPDX-License-Identifier: MIT
# Copyright (C) 2018-present iced project and contributors
# ⚠️This file was generated by GENERATOR!🦹♂️
# pylint: disable=invalid-name
# pylint: disable=line-too-long
# pylint: disable=too-many-lines
"""
x86 instruction code
"""
INVALID: int = 0
"""
It's an invalid instruction, eg. it's a new unknown instruction, garbage or there's not enough bytes to decode the instruction etc.
"""
DECLAREBYTE: int = 1
"""
A ``db``/``.byte`` asm directive that can store 1-16 bytes
"""
DECLAREWORD: int = 2
"""
A ``dw``/``.word`` asm directive that can store 1-8 words
"""
DECLAREDWORD: int = 3
"""
A ``dd``/``.int`` asm directive that can store 1-4 dwords
"""
DECLAREQWORD: int = 4
"""
A ``dq``/``.quad`` asm directive that can store 1-2 qwords
"""
ADD_RM8_R8: int = 5
"""
``ADD r/m8, r8``
``00 /r``
``8086+``
``16/32/64-bit``
"""
ADD_RM16_R16: int = 6
"""
``ADD r/m16, r16``
``o16 01 /r``
``8086+``
``16/32/64-bit``
"""
ADD_RM32_R32: int = 7
"""
``ADD r/m32, r32``
``o32 01 /r``
``386+``
``16/32/64-bit``
"""
ADD_RM64_R64: int = 8
"""
``ADD r/m64, r64``
``o64 01 /r``
``X64``
``64-bit``
"""
ADD_R8_RM8: int = 9
"""
``ADD r8, r/m8``
``02 /r``
``8086+``
``16/32/64-bit``
"""
ADD_R16_RM16: int = 10
"""
``ADD r16, r/m16``
``o16 03 /r``
``8086+``
``16/32/64-bit``
"""
ADD_R32_RM32: int = 11
"""
``ADD r32, r/m32``
``o32 03 /r``
``386+``
``16/32/64-bit``
"""
ADD_R64_RM64: int = 12
"""
``ADD r64, r/m64``
``o64 03 /r``
``X64``
``64-bit``
"""
ADD_AL_IMM8: int = 13
"""
``ADD AL, imm8``
``04 ib``
``8086+``
``16/32/64-bit``
"""
ADD_AX_IMM16: int = 14
"""
``ADD AX, imm16``
``o16 05 iw``
``8086+``
``16/32/64-bit``
"""
ADD_EAX_IMM32: int = 15
"""
``ADD EAX, imm32``
``o32 05 id``
``386+``
``16/32/64-bit``
"""
ADD_RAX_IMM32: int = 16
"""
``ADD RAX, imm32``
``o64 05 id``
``X64``
``64-bit``
"""
PUSHW_ES: int = 17
"""
``PUSH ES``
``o16 06``
``8086+``
``16/32-bit``
"""
PUSHD_ES: int = 18
"""
``PUSH ES``
``o32 06``
``386+``
``16/32-bit``
"""
POPW_ES: int = 19
"""
``POP ES``
``o16 07``
``8086+``
``16/32-bit``
"""
POPD_ES: int = 20
"""
``POP ES``
``o32 07``
``386+``
``16/32-bit``
"""
OR_RM8_R8: int = 21
"""
``OR r/m8, r8``
``08 /r``
``8086+``
``16/32/64-bit``
"""
OR_RM16_R16: int = 22
"""
``OR r/m16, r16``
``o16 09 /r``
``8086+``
``16/32/64-bit``
"""
OR_RM32_R32: int = 23
"""
``OR r/m32, r32``
``o32 09 /r``
``386+``
``16/32/64-bit``
"""
OR_RM64_R64: int = 24
"""
``OR r/m64, r64``
``o64 09 /r``
``X64``
``64-bit``
"""
OR_R8_RM8: int = 25
"""
``OR r8, r/m8``
``0A /r``
``8086+``
``16/32/64-bit``
"""
OR_R16_RM16: int = 26
"""
``OR r16, r/m16``
``o16 0B /r``
``8086+``
``16/32/64-bit``
"""
OR_R32_RM32: int = 27
"""
``OR r32, r/m32``
``o32 0B /r``
``386+``
``16/32/64-bit``
"""
OR_R64_RM64: int = 28
"""
``OR r64, r/m64``
``o64 0B /r``
``X64``
``64-bit``
"""
OR_AL_IMM8: int = 29
"""
``OR AL, imm8``
``0C ib``
``8086+``
``16/32/64-bit``
"""
OR_AX_IMM16: int = 30
"""
``OR AX, imm16``
``o16 0D iw``
``8086+``
``16/32/64-bit``
"""
OR_EAX_IMM32: int = 31
"""
``OR EAX, imm32``
``o32 0D id``
``386+``
``16/32/64-bit``
"""
OR_RAX_IMM32: int = 32
"""
``OR RAX, imm32``
``o64 0D id``
``X64``
``64-bit``
"""
PUSHW_CS: int = 33
"""
``PUSH CS``
``o16 0E``
``8086+``
``16/32-bit``
"""
PUSHD_CS: int = 34
"""
``PUSH CS``
``o32 0E``
``386+``
``16/32-bit``
"""
POPW_CS: int = 35
"""
``POP CS``
``o16 0F``
``8086``
``16-bit``
"""
ADC_RM8_R8: int = 36
"""
``ADC r/m8, r8``
``10 /r``
``8086+``
``16/32/64-bit``
"""
ADC_RM16_R16: int = 37
"""
``ADC r/m16, r16``
``o16 11 /r``
``8086+``
``16/32/64-bit``
"""
ADC_RM32_R32: int = 38
"""
``ADC r/m32, r32``
``o32 11 /r``
``386+``
``16/32/64-bit``
"""
ADC_RM64_R64: int = 39
"""
``ADC r/m64, r64``
``o64 11 /r``
``X64``
``64-bit``
"""
ADC_R8_RM8: int = 40
"""
``ADC r8, r/m8``
``12 /r``
``8086+``
``16/32/64-bit``
"""
ADC_R16_RM16: int = 41
"""
``ADC r16, r/m16``
``o16 13 /r``
``8086+``
``16/32/64-bit``
"""
ADC_R32_RM32: int = 42
"""
``ADC r32, r/m32``
``o32 13 /r``
``386+``
``16/32/64-bit``
"""
ADC_R64_RM64: int = 43
"""
``ADC r64, r/m64``
``o64 13 /r``
``X64``
``64-bit``
"""
ADC_AL_IMM8: int = 44
"""
``ADC AL, imm8``
``14 ib``
``8086+``
``16/32/64-bit``
"""
ADC_AX_IMM16: int = 45
"""
``ADC AX, imm16``
``o16 15 iw``
``8086+``
``16/32/64-bit``
"""
ADC_EAX_IMM32: int = 46
"""
``ADC EAX, imm32``
``o32 15 id``
``386+``
``16/32/64-bit``
"""
ADC_RAX_IMM32: int = 47
"""
``ADC RAX, imm32``
``o64 15 id``
``X64``
``64-bit``
"""
PUSHW_SS: int = 48
"""
``PUSH SS``
``o16 16``
``8086+``
``16/32-bit``
"""
PUSHD_SS: int = 49
"""
``PUSH SS``
``o32 16``
``386+``
``16/32-bit``
"""
POPW_SS: int = 50
"""
``POP SS``
``o16 17``
``8086+``
``16/32-bit``
"""
POPD_SS: int = 51
"""
``POP SS``
``o32 17``
``386+``
``16/32-bit``
"""
SBB_RM8_R8: int = 52
"""
``SBB r/m8, r8``
``18 /r``
``8086+``
``16/32/64-bit``
"""
SBB_RM16_R16: int = 53
"""
``SBB r/m16, r16``
``o16 19 /r``
``8086+``
``16/32/64-bit``
"""
SBB_RM32_R32: int = 54
"""
``SBB r/m32, r32``
``o32 19 /r``
``386+``
``16/32/64-bit``
"""
SBB_RM64_R64: int = 55
"""
``SBB r/m64, r64``
``o64 19 /r``
``X64``
``64-bit``
"""
SBB_R8_RM8: int = 56
"""
``SBB r8, r/m8``
``1A /r``
``8086+``
``16/32/64-bit``
"""
SBB_R16_RM16: int = 57
"""
``SBB r16, r/m16``
``o16 1B /r``
``8086+``
``16/32/64-bit``
"""
SBB_R32_RM32: int = 58
"""
``SBB r32, r/m32``
``o32 1B /r``
``386+``
``16/32/64-bit``
"""
SBB_R64_RM64: int = 59
"""
``SBB r64, r/m64``
``o64 1B /r``
``X64``
``64-bit``
"""
SBB_AL_IMM8: int = 60
"""
``SBB AL, imm8``
``1C ib``
``8086+``
``16/32/64-bit``
"""
SBB_AX_IMM16: int = 61
"""
``SBB AX, imm16``
``o16 1D iw``
``8086+``
``16/32/64-bit``
"""
SBB_EAX_IMM32: int = 62
"""
``SBB EAX, imm32``
``o32 1D id``
``386+``
``16/32/64-bit``
"""
SBB_RAX_IMM32: int = 63
"""
``SBB RAX, imm32``
``o64 1D id``
``X64``
``64-bit``
"""
PUSHW_DS: int = 64
"""
``PUSH DS``
``o16 1E``
``8086+``
``16/32-bit``
"""
PUSHD_DS: int = 65
"""
``PUSH DS``
``o32 1E``
``386+``
``16/32-bit``
"""
POPW_DS: int = 66
"""
``POP DS``
``o16 1F``
``8086+``
``16/32-bit``
"""
POPD_DS: int = 67
"""
``POP DS``
``o32 1F``
``386+``
``16/32-bit``
"""
AND_RM8_R8: int = 68
"""
``AND r/m8, r8``
``20 /r``
``8086+``
``16/32/64-bit``
"""
AND_RM16_R16: int = 69
"""
``AND r/m16, r16``
``o16 21 /r``
``8086+``
``16/32/64-bit``
"""
AND_RM32_R32: int = 70
"""
``AND r/m32, r32``
``o32 21 /r``
``386+``
``16/32/64-bit``
"""
AND_RM64_R64: int = 71
"""
``AND r/m64, r64``
``o64 21 /r``
``X64``
``64-bit``
"""
AND_R8_RM8: int = 72
"""
``AND r8, r/m8``
``22 /r``
``8086+``
``16/32/64-bit``
"""
AND_R16_RM16: int = 73
"""
``AND r16, r/m16``
``o16 23 /r``
``8086+``
``16/32/64-bit``
"""
AND_R32_RM32: int = 74
"""
``AND r32, r/m32``
``o32 23 /r``
``386+``
``16/32/64-bit``
"""
AND_R64_RM64: int = 75
"""
``AND r64, r/m64``
``o64 23 /r``
``X64``
``64-bit``
"""
AND_AL_IMM8: int = 76
"""
``AND AL, imm8``
``24 ib``
``8086+``
``16/32/64-bit``
"""
AND_AX_IMM16: int = 77
"""
``AND AX, imm16``
``o16 25 iw``
``8086+``
``16/32/64-bit``
"""
AND_EAX_IMM32: int = 78
"""
``AND EAX, imm32``
``o32 25 id``
``386+``
``16/32/64-bit``
"""
AND_RAX_IMM32: int = 79
"""
``AND RAX, imm32``
``o64 25 id``
``X64``
``64-bit``
"""
DAA: int = 80
"""
``DAA``
``27``
``8086+``
``16/32-bit``
"""
SUB_RM8_R8: int = 81
"""
``SUB r/m8, r8``
``28 /r``
``8086+``
``16/32/64-bit``
"""
SUB_RM16_R16: int = 82
"""
``SUB r/m16, r16``
``o16 29 /r``
``8086+``
``16/32/64-bit``
"""
SUB_RM32_R32: int = 83
"""
``SUB r/m32, r32``
``o32 29 /r``
``386+``
``16/32/64-bit``
"""
SUB_RM64_R64: int = 84
"""
``SUB r/m64, r64``
``o64 29 /r``
``X64``
``64-bit``
"""
SUB_R8_RM8: int = 85
"""
``SUB r8, r/m8``
``2A /r``
``8086+``
``16/32/64-bit``
"""
SUB_R16_RM16: int = 86
"""
``SUB r16, r/m16``
``o16 2B /r``
``8086+``
``16/32/64-bit``
"""
SUB_R32_RM32: int = 87
"""
``SUB r32, r/m32``
``o32 2B /r``
``386+``
``16/32/64-bit``
"""
SUB_R64_RM64: int = 88
"""
``SUB r64, r/m64``
``o64 2B /r``
``X64``
``64-bit``
"""
SUB_AL_IMM8: int = 89
"""
``SUB AL, imm8``
``2C ib``
``8086+``
``16/32/64-bit``
"""
SUB_AX_IMM16: int = 90
"""
``SUB AX, imm16``
``o16 2D iw``
``8086+``
``16/32/64-bit``
"""
SUB_EAX_IMM32: int = 91
"""
``SUB EAX, imm32``
``o32 2D id``
``386+``
``16/32/64-bit``
"""
SUB_RAX_IMM32: int = 92
"""
``SUB RAX, imm32``
``o64 2D id``
``X64``
``64-bit``
"""
DAS: int = 93
"""
``DAS``
``2F``
``8086+``
``16/32-bit``
"""
XOR_RM8_R8: int = 94
"""
``XOR r/m8, r8``
``30 /r``
``8086+``
``16/32/64-bit``
"""
XOR_RM16_R16: int = 95
"""
``XOR r/m16, r16``
``o16 31 /r``
``8086+``
``16/32/64-bit``
"""
XOR_RM32_R32: int = 96
"""
``XOR r/m32, r32``
``o32 31 /r``
``386+``
``16/32/64-bit``
"""
XOR_RM64_R64: int = 97
"""
``XOR r/m64, r64``
``o64 31 /r``
``X64``
``64-bit``
"""
XOR_R8_RM8: int = 98
"""
``XOR r8, r/m8``
``32 /r``
``8086+``
``16/32/64-bit``
"""
XOR_R16_RM16: int = 99
"""
``XOR r16, r/m16``
``o16 33 /r``
``8086+``
``16/32/64-bit``
"""
XOR_R32_RM32: int = 100
"""
``XOR r32, r/m32``
``o32 33 /r``
``386+``
``16/32/64-bit``
"""
XOR_R64_RM64: int = 101
"""
``XOR r64, r/m64``
``o64 33 /r``
``X64``
``64-bit``
"""
XOR_AL_IMM8: int = 102
"""
``XOR AL, imm8``
``34 ib``
``8086+``
``16/32/64-bit``
"""
XOR_AX_IMM16: int = 103
"""
``XOR AX, imm16``
``o16 35 iw``
``8086+``
``16/32/64-bit``
"""
XOR_EAX_IMM32: int = 104
"""
``XOR EAX, imm32``
``o32 35 id``
``386+``
``16/32/64-bit``
"""
XOR_RAX_IMM32: int = 105
"""
``XOR RAX, imm32``
``o64 35 id``
``X64``
``64-bit``
"""
AAA: int = 106
"""
``AAA``
``37``
``8086+``
``16/32-bit``
"""
CMP_RM8_R8: int = 107
"""
``CMP r/m8, r8``
``38 /r``
``8086+``
``16/32/64-bit``
"""
CMP_RM16_R16: int = 108
"""
``CMP r/m16, r16``
``o16 39 /r``
``8086+``
``16/32/64-bit``
"""
CMP_RM32_R32: int = 109
"""
``CMP r/m32, r32``
``o32 39 /r``
``386+``
``16/32/64-bit``
"""
CMP_RM64_R64: int = 110
"""
``CMP r/m64, r64``
``o64 39 /r``
``X64``
``64-bit``
"""
CMP_R8_RM8: int = 111
"""
``CMP r8, r/m8``
``3A /r``
``8086+``
``16/32/64-bit``
"""
CMP_R16_RM16: int = 112
"""
``CMP r16, r/m16``
``o16 3B /r``
``8086+``
``16/32/64-bit``
"""
CMP_R32_RM32: int = 113
"""
``CMP r32, r/m32``
``o32 3B /r``
``386+``
``16/32/64-bit``
"""
CMP_R64_RM64: int = 114
"""
``CMP r64, r/m64``
``o64 3B /r``
``X64``
``64-bit``
"""
CMP_AL_IMM8: int = 115
"""
``CMP AL, imm8``
``3C ib``
``8086+``
``16/32/64-bit``
"""
CMP_AX_IMM16: int = 116
"""
``CMP AX, imm16``
``o16 3D iw``
``8086+``
``16/32/64-bit``
"""
CMP_EAX_IMM32: int = 117
"""
``CMP EAX, imm32``
``o32 3D id``
``386+``
``16/32/64-bit``
"""
CMP_RAX_IMM32: int = 118
"""
``CMP RAX, imm32``
``o64 3D id``
``X64``
``64-bit``
"""
AAS: int = 119
"""
``AAS``
``3F``
``8086+``
``16/32-bit``
"""
INC_R16: int = 120
"""
``INC r16``
``o16 40+rw``
``8086+``
``16/32-bit``
"""
INC_R32: int = 121
"""
``INC r32``
``o32 40+rd``
``386+``
``16/32-bit``
"""
DEC_R16: int = 122
"""
``DEC r16``
``o16 48+rw``
``8086+``
``16/32-bit``
"""
DEC_R32: int = 123
"""
``DEC r32``
``o32 48+rd``
``386+``
``16/32-bit``
"""
PUSH_R16: int = 124
"""
``PUSH r16``
``o16 50+rw``
``8086+``
``16/32/64-bit``
"""
PUSH_R32: int = 125
"""
``PUSH r32``
``o32 50+rd``
``386+``
``16/32-bit``
"""
PUSH_R64: int = 126
"""
``PUSH r64``
``o64 50+ro``
``X64``
``64-bit``
"""
POP_R16: int = 127
"""
``POP r16``
``o16 58+rw``
``8086+``
``16/32/64-bit``
"""
POP_R32: int = 128
"""
``POP r32``
``o32 58+rd``
``386+``
``16/32-bit``
"""
POP_R64: int = 129
"""
``POP r64``
``o64 58+ro``
``X64``
``64-bit``
"""
PUSHAW: int = 130
"""
``PUSHA``
``o16 60``
``186+``
``16/32-bit``
"""
PUSHAD: int = 131
"""
``PUSHAD``
``o32 60``
``386+``
``16/32-bit``
"""
POPAW: int = 132
"""
``POPA``
``o16 61``
``186+``
``16/32-bit``
"""
POPAD: int = 133
"""
``POPAD``
``o32 61``
``386+``
``16/32-bit``
"""
BOUND_R16_M1616: int = 134
"""
``BOUND r16, m16&16``
``o16 62 /r``
``186+``
``16/32-bit``
"""
BOUND_R32_M3232: int = 135
"""
``BOUND r32, m32&32``
``o32 62 /r``
``386+``
``16/32-bit``
"""
ARPL_RM16_R16: int = 136
"""
``ARPL r/m16, r16``
``o16 63 /r``
``286+``
``16/32-bit``
"""
ARPL_R32M16_R32: int = 137
"""
``ARPL r32/m16, r32``
``o32 63 /r``
``386+``
``16/32-bit``
"""
MOVSXD_R16_RM16: int = 138
"""
``MOVSXD r16, r/m16``
``o16 63 /r``
``X64``
``64-bit``
"""
MOVSXD_R32_RM32: int = 139
"""
``MOVSXD r32, r/m32``
``o32 63 /r``
``X64``
``64-bit``
"""
MOVSXD_R64_RM32: int = 140
"""
``MOVSXD r64, r/m32``
``o64 63 /r``
``X64``
``64-bit``
"""
PUSH_IMM16: int = 141
"""
``PUSH imm16``
``o16 68 iw``
``186+``
``16/32/64-bit``
"""
PUSHD_IMM32: int = 142
"""
``PUSH imm32``
``o32 68 id``
``386+``
``16/32-bit``
"""
PUSHQ_IMM32: int = 143
"""
``PUSH imm32``
``o64 68 id``
``X64``
``64-bit``
"""
IMUL_R16_RM16_IMM16: int = 144
"""
``IMUL r16, r/m16, imm16``
``o16 69 /r iw``
``186+``
``16/32/64-bit``
"""
IMUL_R32_RM32_IMM32: int = 145
"""
``IMUL r32, r/m32, imm32``
``o32 69 /r id``
``386+``
``16/32/64-bit``
"""
IMUL_R64_RM64_IMM32: int = 146
"""
``IMUL r64, r/m64, imm32``
``o64 69 /r id``
``X64``
``64-bit``
"""
PUSHW_IMM8: int = 147
"""
``PUSH imm8``
``o16 6A ib``
``186+``
``16/32/64-bit``
"""
PUSHD_IMM8: int = 148
"""
``PUSH imm8``
``o32 6A ib``
``386+``
``16/32-bit``
"""
PUSHQ_IMM8: int = 149
"""
``PUSH imm8``
``o64 6A ib``
``X64``
``64-bit``
"""
IMUL_R16_RM16_IMM8: int = 150
"""
``IMUL r16, r/m16, imm8``
``o16 6B /r ib``
``186+``
``16/32/64-bit``
"""
IMUL_R32_RM32_IMM8: int = 151
"""
``IMUL r32, r/m32, imm8``
``o32 6B /r ib``
``386+``
``16/32/64-bit``
"""
IMUL_R64_RM64_IMM8: int = 152
"""
``IMUL r64, r/m64, imm8``
``o64 6B /r ib``
``X64``
``64-bit``
"""
INSB_M8_DX: int = 153
"""
``INSB``
``6C``
``186+``
``16/32/64-bit``
"""
INSW_M16_DX: int = 154
"""
``INSW``
``o16 6D``
``186+``
``16/32/64-bit``
"""
INSD_M32_DX: int = 155
"""
``INSD``
``o32 6D``
``386+``
``16/32/64-bit``
"""
OUTSB_DX_M8: int = 156
"""
``OUTSB``
``6E``
``186+``
``16/32/64-bit``
"""
OUTSW_DX_M16: int = 157
"""
``OUTSW``
``o16 6F``
``186+``
``16/32/64-bit``
"""
OUTSD_DX_M32: int = 158
"""
``OUTSD``
``o32 6F``
``386+``
``16/32/64-bit``
"""
JO_REL8_16: int = 159
"""
``JO rel8``
``o16 70 cb``
``8086+``
``16/32/64-bit``
"""
JO_REL8_32: int = 160
"""
``JO rel8``
``o32 70 cb``
``386+``
``16/32-bit``
"""
JO_REL8_64: int = 161
"""
``JO rel8``
``o64 70 cb``
``X64``
``64-bit``
"""
JNO_REL8_16: int = 162
"""
``JNO rel8``
``o16 71 cb``
``8086+``
``16/32/64-bit``
"""
JNO_REL8_32: int = 163
"""
``JNO rel8``
``o32 71 cb``
``386+``
``16/32-bit``
"""
JNO_REL8_64: int = 164
"""
``JNO rel8``
``o64 71 cb``
``X64``
``64-bit``
"""
JB_REL8_16: int = 165
"""
``JB rel8``
``o16 72 cb``
``8086+``
``16/32/64-bit``
"""
JB_REL8_32: int = 166
"""
``JB rel8``
``o32 72 cb``
``386+``
``16/32-bit``
"""
JB_REL8_64: int = 167
"""
``JB rel8``
``o64 72 cb``
``X64``
``64-bit``
"""
JAE_REL8_16: int = 168
"""
``JAE rel8``
``o16 73 cb``
``8086+``
``16/32/64-bit``
"""
JAE_REL8_32: int = 169
"""
``JAE rel8``
``o32 73 cb``
``386+``
``16/32-bit``
"""
JAE_REL8_64: int = 170
"""
``JAE rel8``
``o64 73 cb``
``X64``
``64-bit``
"""
JE_REL8_16: int = 171
"""
``JE rel8``
``o16 74 cb``
``8086+``
``16/32/64-bit``
"""
JE_REL8_32: int = 172
"""
``JE rel8``
``o32 74 cb``
``386+``
``16/32-bit``
"""
JE_REL8_64: int = 173
"""
``JE rel8``
``o64 74 cb``
``X64``
``64-bit``
"""
JNE_REL8_16: int = 174
"""
``JNE rel8``
``o16 75 cb``
``8086+``
``16/32/64-bit``
"""
JNE_REL8_32: int = 175
"""
``JNE rel8``
``o32 75 cb``
``386+``
``16/32-bit``
"""
JNE_REL8_64: int = 176
"""
``JNE rel8``
``o64 75 cb``
``X64``
``64-bit``
"""
JBE_REL8_16: int = 177
"""
``JBE rel8``
``o16 76 cb``
``8086+``
``16/32/64-bit``
"""
JBE_REL8_32: int = 178
"""
``JBE rel8``
``o32 76 cb``
``386+``
``16/32-bit``
"""
JBE_REL8_64: int = 179
"""
``JBE rel8``
``o64 76 cb``
``X64``
``64-bit``
"""
JA_REL8_16: int = 180
"""
``JA rel8``
``o16 77 cb``
``8086+``
``16/32/64-bit``
"""
JA_REL8_32: int = 181
"""
``JA rel8``
``o32 77 cb``
``386+``
``16/32-bit``
"""
JA_REL8_64: int = 182
"""
``JA rel8``
``o64 77 cb``
``X64``
``64-bit``
"""
JS_REL8_16: int = 183
"""
``JS rel8``
``o16 78 cb``
``8086+``
``16/32/64-bit``
"""
JS_REL8_32: int = 184
"""
``JS rel8``
``o32 78 cb``
``386+``
``16/32-bit``
"""
JS_REL8_64: int = 185
"""
``JS rel8``
``o64 78 cb``
``X64``
``64-bit``
"""
JNS_REL8_16: int = 186
"""
``JNS rel8``
``o16 79 cb``
``8086+``
``16/32/64-bit``
"""
JNS_REL8_32: int = 187
"""
``JNS rel8``
``o32 79 cb``
``386+``
``16/32-bit``
"""
JNS_REL8_64: int = 188
"""
``JNS rel8``
``o64 79 cb``
``X64``
``64-bit``
"""
JP_REL8_16: int = 189
"""
``JP rel8``
``o16 7A cb``
``8086+``
``16/32/64-bit``
"""
JP_REL8_32: int = 190
"""
``JP rel8``
``o32 7A cb``
``386+``
``16/32-bit``
"""
JP_REL8_64: int = 191
"""
``JP rel8``
``o64 7A cb``
``X64``
``64-bit``
"""
JNP_REL8_16: int = 192
"""
``JNP rel8``
``o16 7B cb``
``8086+``
``16/32/64-bit``
"""
JNP_REL8_32: int = 193
"""
``JNP rel8``
``o32 7B cb``
``386+``
``16/32-bit``
"""
JNP_REL8_64: int = 194
"""
``JNP rel8``
``o64 7B cb``
``X64``
``64-bit``
"""
JL_REL8_16: int = 195
"""
``JL rel8``
``o16 7C cb``
``8086+``
``16/32/64-bit``
"""
JL_REL8_32: int = 196
"""
``JL rel8``
``o32 7C cb``
``386+``
``16/32-bit``
"""
JL_REL8_64: int = 197
"""
``JL rel8``
``o64 7C cb``
``X64``
``64-bit``
"""
JGE_REL8_16: int = 198
"""
``JGE rel8``
``o16 7D cb``
``8086+``
``16/32/64-bit``
"""
JGE_REL8_32: int = 199
"""
``JGE rel8``
``o32 7D cb``
``386+``
``16/32-bit``
"""
JGE_REL8_64: int = 200
"""
``JGE rel8``
``o64 7D cb``
``X64``
``64-bit``
"""
JLE_REL8_16: int = 201
"""
``JLE rel8``
``o16 7E cb``
``8086+``
``16/32/64-bit``
"""
JLE_REL8_32: int = 202
"""
``JLE rel8``
``o32 7E cb``
``386+``
``16/32-bit``
"""
JLE_REL8_64: int = 203
"""
``JLE rel8``
``o64 7E cb``
``X64``
``64-bit``
"""
JG_REL8_16: int = 204
"""
``JG rel8``
``o16 7F cb``
``8086+``
``16/32/64-bit``
"""
JG_REL8_32: int = 205
"""
``JG rel8``
``o32 7F cb``
``386+``
``16/32-bit``
"""
JG_REL8_64: int = 206
"""
``JG rel8``
``o64 7F cb``
``X64``
``64-bit``
"""
ADD_RM8_IMM8: int = 207
"""
``ADD r/m8, imm8``
``80 /0 ib``
``8086+``
``16/32/64-bit``
"""
OR_RM8_IMM8: int = 208
"""
``OR r/m8, imm8``
``80 /1 ib``
``8086+``
``16/32/64-bit``
"""
ADC_RM8_IMM8: int = 209
"""
``ADC r/m8, imm8``
``80 /2 ib``
``8086+``
``16/32/64-bit``
"""
SBB_RM8_IMM8: int = 210
"""
``SBB r/m8, imm8``
``80 /3 ib``
``8086+``
``16/32/64-bit``
"""
AND_RM8_IMM8: int = 211
"""
``AND r/m8, imm8``
``80 /4 ib``
``8086+``
``16/32/64-bit``
"""
SUB_RM8_IMM8: int = 212
"""
``SUB r/m8, imm8``
``80 /5 ib``
``8086+``
``16/32/64-bit``
"""
XOR_RM8_IMM8: int = 213
"""
``XOR r/m8, imm8``
``80 /6 ib``
``8086+``
``16/32/64-bit``
"""
CMP_RM8_IMM8: int = 214
"""
``CMP r/m8, imm8``
``80 /7 ib``
``8086+``
``16/32/64-bit``
"""
ADD_RM16_IMM16: int = 215
"""
``ADD r/m16, imm16``
``o16 81 /0 iw``
``8086+``
``16/32/64-bit``
"""
ADD_RM32_IMM32: int = 216
"""
``ADD r/m32, imm32``
``o32 81 /0 id``
``386+``
``16/32/64-bit``
"""
ADD_RM64_IMM32: int = 217
"""
``ADD r/m64, imm32``
``o64 81 /0 id``
``X64``
``64-bit``
"""
OR_RM16_IMM16: int = 218
"""
``OR r/m16, imm16``
``o16 81 /1 iw``
``8086+``
``16/32/64-bit``
"""
OR_RM32_IMM32: int = 219
"""
``OR r/m32, imm32``
``o32 81 /1 id``
``386+``
``16/32/64-bit``
"""
OR_RM64_IMM32: int = 220
"""
``OR r/m64, imm32``
``o64 81 /1 id``
``X64``
``64-bit``
"""
ADC_RM16_IMM16: int = 221
"""
``ADC r/m16, imm16``
``o16 81 /2 iw``
``8086+``
``16/32/64-bit``
"""
ADC_RM32_IMM32: int = 222
"""
``ADC r/m32, imm32``
``o32 81 /2 id``
``386+``
``16/32/64-bit``
"""
ADC_RM64_IMM32: int = 223
"""
``ADC r/m64, imm32``
``o64 81 /2 id``
``X64``
``64-bit``
"""
SBB_RM16_IMM16: int = 224
"""
``SBB r/m16, imm16``
``o16 81 /3 iw``
``8086+``
``16/32/64-bit``
"""
SBB_RM32_IMM32: int = 225
"""
``SBB r/m32, imm32``
``o32 81 /3 id``
``386+``
``16/32/64-bit``
"""
SBB_RM64_IMM32: int = 226
"""
``SBB r/m64, imm32``
``o64 81 /3 id``
``X64``
``64-bit``
"""
AND_RM16_IMM16: int = 227
"""
``AND r/m16, imm16``
``o16 81 /4 iw``
``8086+``
``16/32/64-bit``
"""
AND_RM32_IMM32: int = 228
"""
``AND r/m32, imm32``
``o32 81 /4 id``
``386+``
``16/32/64-bit``
"""
AND_RM64_IMM32: int = 229
"""
``AND r/m64, imm32``
``o64 81 /4 id``
``X64``
``64-bit``
"""
SUB_RM16_IMM16: int = 230
"""
``SUB r/m16, imm16``
``o16 81 /5 iw``
``8086+``
``16/32/64-bit``
"""
SUB_RM32_IMM32: int = 231
"""
``SUB r/m32, imm32``
``o32 81 /5 id``
``386+``
``16/32/64-bit``
"""
SUB_RM64_IMM32: int = 232
"""
``SUB r/m64, imm32``
``o64 81 /5 id``
``X64``
``64-bit``
"""
XOR_RM16_IMM16: int = 233
"""
``XOR r/m16, imm16``
``o16 81 /6 iw``
``8086+``
``16/32/64-bit``
"""
XOR_RM32_IMM32: int = 234
"""
``XOR r/m32, imm32``
``o32 81 /6 id``
``386+``
``16/32/64-bit``
"""
XOR_RM64_IMM32: int = 235
"""
``XOR r/m64, imm32``
``o64 81 /6 id``
``X64``
``64-bit``
"""
CMP_RM16_IMM16: int = 236
"""
``CMP r/m16, imm16``
``o16 81 /7 iw``
``8086+``
``16/32/64-bit``
"""
CMP_RM32_IMM32: int = 237
"""
``CMP r/m32, imm32``
``o32 81 /7 id``
``386+``
``16/32/64-bit``
"""
CMP_RM64_IMM32: int = 238
"""
``CMP r/m64, imm32``
``o64 81 /7 id``
``X64``
``64-bit``
"""
ADD_RM8_IMM8_82: int = 239
"""
``ADD r/m8, imm8``
``82 /0 ib``
``8086+``
``16/32-bit``
"""
OR_RM8_IMM8_82: int = 240
"""
``OR r/m8, imm8``
``82 /1 ib``
``8086+``
``16/32-bit``
"""
ADC_RM8_IMM8_82: int = 241
"""
``ADC r/m8, imm8``
``82 /2 ib``
``8086+``
``16/32-bit``
"""
SBB_RM8_IMM8_82: int = 242
"""
``SBB r/m8, imm8``
``82 /3 ib``
``8086+``
``16/32-bit``
"""
AND_RM8_IMM8_82: int = 243
"""
``AND r/m8, imm8``
``82 /4 ib``
``8086+``
``16/32-bit``
"""
SUB_RM8_IMM8_82: int = 244
"""
``SUB r/m8, imm8``
``82 /5 ib``
``8086+``
``16/32-bit``
"""
XOR_RM8_IMM8_82: int = 245
"""
``XOR r/m8, imm8``
``82 /6 ib``
``8086+``
``16/32-bit``
"""
CMP_RM8_IMM8_82: int = 246
"""
``CMP r/m8, imm8``
``82 /7 ib``
``8086+``
``16/32-bit``
"""
ADD_RM16_IMM8: int = 247
"""
``ADD r/m16, imm8``
``o16 83 /0 ib``
``8086+``
``16/32/64-bit``
"""
ADD_RM32_IMM8: int = 248
"""
``ADD r/m32, imm8``
``o32 83 /0 ib``
``386+``
``16/32/64-bit``
"""
ADD_RM64_IMM8: int = 249
"""
``ADD r/m64, imm8``
``o64 83 /0 ib``
``X64``
``64-bit``
"""
OR_RM16_IMM8: int = 250
"""
``OR r/m16, imm8``
``o16 83 /1 ib``
``8086+``
``16/32/64-bit``
"""
OR_RM32_IMM8: int = 251
"""
``OR r/m32, imm8``
``o32 83 /1 ib``
``386+``
``16/32/64-bit``
"""
OR_RM64_IMM8: int = 252
"""
``OR r/m64, imm8``
``o64 83 /1 ib``
``X64``
``64-bit``
"""
ADC_RM16_IMM8: int = 253
"""
``ADC r/m16, imm8``
``o16 83 /2 ib``
``8086+``
``16/32/64-bit``
"""
ADC_RM32_IMM8: int = 254
"""
``ADC r/m32, imm8``
``o32 83 /2 ib``
``386+``
``16/32/64-bit``
"""
ADC_RM64_IMM8: int = 255
"""
``ADC r/m64, imm8``
``o64 83 /2 ib``
``X64``
``64-bit``
"""
SBB_RM16_IMM8: int = 256
"""
``SBB r/m16, imm8``
``o16 83 /3 ib``
``8086+``
``16/32/64-bit``
"""
SBB_RM32_IMM8: int = 257
"""
``SBB r/m32, imm8``
``o32 83 /3 ib``
``386+``
``16/32/64-bit``
"""
SBB_RM64_IMM8: int = 258
"""
``SBB r/m64, imm8``
``o64 83 /3 ib``
``X64``
``64-bit``
"""
AND_RM16_IMM8: int = 259
"""
``AND r/m16, imm8``
``o16 83 /4 ib``
``8086+``
``16/32/64-bit``
"""
AND_RM32_IMM8: int = 260
"""
``AND r/m32, imm8``
``o32 83 /4 ib``
``386+``
``16/32/64-bit``
"""
AND_RM64_IMM8: int = 261
"""
``AND r/m64, imm8``
``o64 83 /4 ib``
``X64``
``64-bit``
"""
SUB_RM16_IMM8: int = 262
"""
``SUB r/m16, imm8``
``o16 83 /5 ib``
``8086+``
``16/32/64-bit``
"""
SUB_RM32_IMM8: int = 263
"""
``SUB r/m32, imm8``
``o32 83 /5 ib``
``386+``
``16/32/64-bit``
"""
SUB_RM64_IMM8: int = 264
"""
``SUB r/m64, imm8``
``o64 83 /5 ib``
``X64``
``64-bit``
"""
XOR_RM16_IMM8: int = 265
"""
``XOR r/m16, imm8``
``o16 83 /6 ib``
``8086+``
``16/32/64-bit``
"""
XOR_RM32_IMM8: int = 266
"""
``XOR r/m32, imm8``
``o32 83 /6 ib``
``386+``
``16/32/64-bit``
"""
XOR_RM64_IMM8: int = 267
"""
``XOR r/m64, imm8``
``o64 83 /6 ib``
``X64``
``64-bit``
"""
CMP_RM16_IMM8: int = 268
"""
``CMP r/m16, imm8``
``o16 83 /7 ib``
``8086+``
``16/32/64-bit``
"""
CMP_RM32_IMM8: int = 269
"""
``CMP r/m32, imm8``
``o32 83 /7 ib``
``386+``
``16/32/64-bit``
"""
CMP_RM64_IMM8: int = 270
"""
``CMP r/m64, imm8``
``o64 83 /7 ib``
``X64``
``64-bit``
"""
TEST_RM8_R8: int = 271
"""
``TEST r/m8, r8``
``84 /r``
``8086+``
``16/32/64-bit``
"""
TEST_RM16_R16: int = 272
"""
``TEST r/m16, r16``
``o16 85 /r``
``8086+``
``16/32/64-bit``
"""
TEST_RM32_R32: int = 273
"""
``TEST r/m32, r32``
``o32 85 /r``
``386+``
``16/32/64-bit``
"""
TEST_RM64_R64: int = 274
"""
``TEST r/m64, r64``
``o64 85 /r``
``X64``
``64-bit``
"""
XCHG_RM8_R8: int = 275
"""
``XCHG r/m8, r8``
``86 /r``
``8086+``
``16/32/64-bit``
"""
XCHG_RM16_R16: int = 276
"""
``XCHG r/m16, r16``
``o16 87 /r``
``8086+``
``16/32/64-bit``
"""
XCHG_RM32_R32: int = 277
"""
``XCHG r/m32, r32``
``o32 87 /r``
``386+``
``16/32/64-bit``
"""
XCHG_RM64_R64: int = 278
"""
``XCHG r/m64, r64``
``o64 87 /r``
``X64``
``64-bit``
"""
MOV_RM8_R8: int = 279
"""
``MOV r/m8, r8``
``88 /r``
``8086+``
``16/32/64-bit``
"""
MOV_RM16_R16: int = 280
"""
``MOV r/m16, r16``
``o16 89 /r``
``8086+``
``16/32/64-bit``
"""
MOV_RM32_R32: int = 281
"""
``MOV r/m32, r32``
``o32 89 /r``
``386+``
``16/32/64-bit``
"""
MOV_RM64_R64: int = 282
"""
``MOV r/m64, r64``
``o64 89 /r``
``X64``
``64-bit``
"""
MOV_R8_RM8: int = 283
"""
``MOV r8, r/m8``
``8A /r``
``8086+``
``16/32/64-bit``
"""
MOV_R16_RM16: int = 284
"""
``MOV r16, r/m16``
``o16 8B /r``
``8086+``
``16/32/64-bit``
"""
MOV_R32_RM32: int = 285
"""
``MOV r32, r/m32``
``o32 8B /r``
``386+``
``16/32/64-bit``
"""
MOV_R64_RM64: int = 286
"""
``MOV r64, r/m64``
``o64 8B /r``
``X64``
``64-bit``
"""
MOV_RM16_SREG: int = 287
"""
``MOV r/m16, Sreg``
``o16 8C /r``
``8086+``
``16/32/64-bit``
"""
MOV_R32M16_SREG: int = 288
"""
``MOV r32/m16, Sreg``
``o32 8C /r``
``386+``
``16/32/64-bit``
"""
MOV_R64M16_SREG: int = 289
"""
``MOV r64/m16, Sreg``
``o64 8C /r``
``X64``
``64-bit``
"""
LEA_R16_M: int = 290
"""
``LEA r16, m``
``o16 8D /r``
``8086+``
``16/32/64-bit``
"""
LEA_R32_M: int = 291
"""
``LEA r32, m``
``o32 8D /r``
``386+``
``16/32/64-bit``
"""
LEA_R64_M: int = 292
"""
``LEA r64, m``
``o64 8D /r``
``X64``
``64-bit``
"""
MOV_SREG_RM16: int = 293
"""
``MOV Sreg, r/m16``
``o16 8E /r``
``8086+``
``16/32/64-bit``
"""
MOV_SREG_R32M16: int = 294
"""
``MOV Sreg, r32/m16``
``o32 8E /r``
``386+``
``16/32/64-bit``
"""
MOV_SREG_R64M16: int = 295
"""
``MOV Sreg, r64/m16``
``o64 8E /r``
``X64``
``64-bit``
"""
POP_RM16: int = 296
"""
``POP r/m16``
``o16 8F /0``
``8086+``
``16/32/64-bit``
"""
POP_RM32: int = 297
"""
``POP r/m32``
``o32 8F /0``
``386+``
``16/32-bit``
"""
POP_RM64: int = 298
"""
``POP r/m64``
``o64 8F /0``
``X64``
``64-bit``
"""
NOPW: int = 299
"""
``NOP``
``o16 90``
``8086+``
``16/32/64-bit``
"""
NOPD: int = 300
"""
``NOP``
``o32 90``
``8086+``
``16/32/64-bit``
"""
NOPQ: int = 301
"""
``NOP``
``o64 90``
``8086+``
``64-bit``
"""
XCHG_R16_AX: int = 302
"""
``XCHG r16, AX``
``o16 90+rw``
``8086+``
``16/32/64-bit``
"""
XCHG_R32_EAX: int = 303
"""
``XCHG r32, EAX``
``o32 90+rd``
``386+``
``16/32/64-bit``
"""
XCHG_R64_RAX: int = 304
"""
``XCHG r64, RAX``
``o64 90+ro``
``X64``
``64-bit``
"""
PAUSE: int = 305
"""
``PAUSE``
``F3 90``
``Pentium 4 or later``
``16/32/64-bit``
"""
CBW: int = 306
"""
``CBW``
``o16 98``
``8086+``
``16/32/64-bit``
"""
CWDE: int = 307
"""
``CWDE``
``o32 98``
``386+``
``16/32/64-bit``
"""
CDQE: int = 308
"""
``CDQE``
``o64 98``
``X64``
``64-bit``
"""
CWD: int = 309
"""
``CWD``
``o16 99``
``8086+``
``16/32/64-bit``
"""
CDQ: int = 310
"""
``CDQ``
``o32 99``
``386+``
``16/32/64-bit``
"""
CQO: int = 311
"""
``CQO``
``o64 99``
``X64``
``64-bit``
"""
CALL_PTR1616: int = 312
"""
``CALL ptr16:16``
``o16 9A cd``
``8086+``
``16/32-bit``
"""
CALL_PTR1632: int = 313
"""
``CALL ptr16:32``
``o32 9A cp``
``386+``
``16/32-bit``
"""
WAIT: int = 314
"""
``WAIT``
``9B``
``8086+``
``16/32/64-bit``
"""
PUSHFW: int = 315
"""
``PUSHF``
``o16 9C``
``8086+``
``16/32/64-bit``
"""
PUSHFD: int = 316
"""
``PUSHFD``
``o32 9C``
``386+``
``16/32-bit``
"""
PUSHFQ: int = 317
"""
``PUSHFQ``
``o64 9C``
``X64``
``64-bit``
"""
POPFW: int = 318
"""
``POPF``
``o16 9D``
``8086+``
``16/32/64-bit``
"""
POPFD: int = 319
"""
``POPFD``
``o32 9D``
``386+``
``16/32-bit``
"""
POPFQ: int = 320
"""
``POPFQ``
``o64 9D``
``X64``
``64-bit``
"""
SAHF: int = 321
"""
``SAHF``
``9E``
``8086+``
``16/32/64-bit``
"""
LAHF: int = 322
"""
``LAHF``
``9F``
``8086+``
``16/32/64-bit``
"""
MOV_AL_MOFFS8: int = 323
"""
``MOV AL, moffs8``
``A0 mo``
``8086+``
``16/32/64-bit``
"""
MOV_AX_MOFFS16: int = 324
"""
``MOV AX, moffs16``
``o16 A1 mo``
``8086+``
``16/32/64-bit``
"""
MOV_EAX_MOFFS32: int = 325
"""
``MOV EAX, moffs32``
``o32 A1 mo``
``386+``
``16/32/64-bit``
"""
MOV_RAX_MOFFS64: int = 326
"""
``MOV RAX, moffs64``
``o64 A1 mo``
``X64``
``64-bit``
"""
MOV_MOFFS8_AL: int = 327
"""
``MOV moffs8, AL``
``A2 mo``
``8086+``
``16/32/64-bit``
"""
MOV_MOFFS16_AX: int = 328
"""
``MOV moffs16, AX``
``o16 A3 mo``
``8086+``
``16/32/64-bit``
"""
MOV_MOFFS32_EAX: int = 329
"""
``MOV moffs32, EAX``
``o32 A3 mo``
``386+``
``16/32/64-bit``
"""
MOV_MOFFS64_RAX: int = 330
"""
``MOV moffs64, RAX``
``o64 A3 mo``
``X64``
``64-bit``
"""
MOVSB_M8_M8: int = 331
"""
``MOVSB``
``A4``
``8086+``
``16/32/64-bit``
"""
MOVSW_M16_M16: int = 332
"""
``MOVSW``
``o16 A5``
``8086+``
``16/32/64-bit``
"""
MOVSD_M32_M32: int = 333
"""
``MOVSD``
``o32 A5``
``386+``
``16/32/64-bit``
"""
MOVSQ_M64_M64: int = 334
"""
``MOVSQ``
``o64 A5``
``X64``
``64-bit``
"""
CMPSB_M8_M8: int = 335
"""
``CMPSB``
``A6``
``8086+``
``16/32/64-bit``
"""
CMPSW_M16_M16: int = 336
"""
``CMPSW``
``o16 A7``
``8086+``
``16/32/64-bit``
"""
CMPSD_M32_M32: int = 337
"""
``CMPSD``
``o32 A7``
``386+``
``16/32/64-bit``
"""
CMPSQ_M64_M64: int = 338
"""
``CMPSQ``
``o64 A7``
``X64``
``64-bit``
"""
TEST_AL_IMM8: int = 339
"""
``TEST AL, imm8``
``A8 ib``
``8086+``
``16/32/64-bit``
"""
TEST_AX_IMM16: int = 340
"""
``TEST AX, imm16``
``o16 A9 iw``
``8086+``
``16/32/64-bit``
"""
TEST_EAX_IMM32: int = 341
"""
``TEST EAX, imm32``
``o32 A9 id``
``386+``
``16/32/64-bit``
"""
TEST_RAX_IMM32: int = 342
"""
``TEST RAX, imm32``
``o64 A9 id``
``X64``
``64-bit``
"""
STOSB_M8_AL: int = 343
"""
``STOSB``
``AA``
``8086+``
``16/32/64-bit``
"""
STOSW_M16_AX: int = 344
"""
``STOSW``
``o16 AB``
``8086+``
``16/32/64-bit``
"""
STOSD_M32_EAX: int = 345
"""
``STOSD``
``o32 AB``
``386+``
``16/32/64-bit``
"""
STOSQ_M64_RAX: int = 346
"""
``STOSQ``
``o64 AB``
``X64``
``64-bit``
"""
LODSB_AL_M8: int = 347
"""
``LODSB``
``AC``
``8086+``
``16/32/64-bit``
"""
LODSW_AX_M16: int = 348
"""
``LODSW``
``o16 AD``
``8086+``
``16/32/64-bit``
"""
LODSD_EAX_M32: int = 349
"""
``LODSD``
``o32 AD``
``386+``
``16/32/64-bit``
"""
LODSQ_RAX_M64: int = 350
"""
``LODSQ``
``o64 AD``
``X64``
``64-bit``
"""
SCASB_AL_M8: int = 351
"""
``SCASB``
``AE``
``8086+``
``16/32/64-bit``
"""
SCASW_AX_M16: int = 352
"""
``SCASW``
``o16 AF``
``8086+``
``16/32/64-bit``
"""
SCASD_EAX_M32: int = 353
"""
``SCASD``
``o32 AF``
``386+``
``16/32/64-bit``
"""
SCASQ_RAX_M64: int = 354
"""
``SCASQ``
``o64 AF``
``X64``
``64-bit``
"""
MOV_R8_IMM8: int = 355
"""
``MOV r8, imm8``
``B0+rb ib``
``8086+``
``16/32/64-bit``
"""
MOV_R16_IMM16: int = 356
"""
``MOV r16, imm16``
``o16 B8+rw iw``
``8086+``
``16/32/64-bit``
"""
MOV_R32_IMM32: int = 357
"""
``MOV r32, imm32``
``o32 B8+rd id``
``386+``
``16/32/64-bit``
"""
MOV_R64_IMM64: int = 358
"""
``MOV r64, imm64``
``o64 B8+ro io``
``X64``
``64-bit``
"""
ROL_RM8_IMM8: int = 359
"""
``ROL r/m8, imm8``
``C0 /0 ib``
``186+``
``16/32/64-bit``
"""
ROR_RM8_IMM8: int = 360
"""
``ROR r/m8, imm8``
``C0 /1 ib``
``186+``
``16/32/64-bit``
"""
RCL_RM8_IMM8: int = 361
"""
``RCL r/m8, imm8``
``C0 /2 ib``
``186+``
``16/32/64-bit``
"""
RCR_RM8_IMM8: int = 362
"""
``RCR r/m8, imm8``
``C0 /3 ib``
``186+``
``16/32/64-bit``
"""
SHL_RM8_IMM8: int = 363
"""
``SHL r/m8, imm8``
``C0 /4 ib``
``186+``
``16/32/64-bit``
"""
SHR_RM8_IMM8: int = 364
"""
``SHR r/m8, imm8``
``C0 /5 ib``
``186+``
``16/32/64-bit``
"""
SAL_RM8_IMM8: int = 365
"""
``SAL r/m8, imm8``
``C0 /6 ib``
``186+``
``16/32/64-bit``
"""
SAR_RM8_IMM8: int = 366
"""
``SAR r/m8, imm8``
``C0 /7 ib``
``186+``
``16/32/64-bit``
"""
ROL_RM16_IMM8: int = 367
"""
``ROL r/m16, imm8``
``o16 C1 /0 ib``
``186+``
``16/32/64-bit``
"""
ROL_RM32_IMM8: int = 368
"""
``ROL r/m32, imm8``
``o32 C1 /0 ib``
``386+``
``16/32/64-bit``
"""
ROL_RM64_IMM8: int = 369
"""
``ROL r/m64, imm8``
``o64 C1 /0 ib``
``X64``
``64-bit``
"""
ROR_RM16_IMM8: int = 370
"""
``ROR r/m16, imm8``
``o16 C1 /1 ib``
``186+``
``16/32/64-bit``
"""
ROR_RM32_IMM8: int = 371
"""
``ROR r/m32, imm8``
``o32 C1 /1 ib``
``386+``
``16/32/64-bit``
"""
ROR_RM64_IMM8: int = 372
"""
``ROR r/m64, imm8``
``o64 C1 /1 ib``
``X64``
``64-bit``
"""
RCL_RM16_IMM8: int = 373
"""
``RCL r/m16, imm8``
``o16 C1 /2 ib``
``186+``
``16/32/64-bit``
"""
RCL_RM32_IMM8: int = 374
"""
``RCL r/m32, imm8``
``o32 C1 /2 ib``
``386+``
``16/32/64-bit``
"""
RCL_RM64_IMM8: int = 375
"""
``RCL r/m64, imm8``
``o64 C1 /2 ib``
``X64``
``64-bit``
"""
RCR_RM16_IMM8: int = 376
"""
``RCR r/m16, imm8``
``o16 C1 /3 ib``
``186+``
``16/32/64-bit``
"""
RCR_RM32_IMM8: int = 377
"""
``RCR r/m32, imm8``
``o32 C1 /3 ib``
``386+``
``16/32/64-bit``
"""
RCR_RM64_IMM8: int = 378
"""
``RCR r/m64, imm8``
``o64 C1 /3 ib``
``X64``
``64-bit``
"""
SHL_RM16_IMM8: int = 379
"""
``SHL r/m16, imm8``
``o16 C1 /4 ib``
``186+``
``16/32/64-bit``
"""
SHL_RM32_IMM8: int = 380
"""
``SHL r/m32, imm8``
``o32 C1 /4 ib``
``386+``
``16/32/64-bit``
"""
SHL_RM64_IMM8: int = 381
"""
``SHL r/m64, imm8``
``o64 C1 /4 ib``
``X64``
``64-bit``
"""
SHR_RM16_IMM8: int = 382
"""
``SHR r/m16, imm8``
``o16 C1 /5 ib``
``186+``
``16/32/64-bit``
"""
SHR_RM32_IMM8: int = 383
"""
``SHR r/m32, imm8``
``o32 C1 /5 ib``
``386+``
``16/32/64-bit``
"""
SHR_RM64_IMM8: int = 384
"""
``SHR r/m64, imm8``
``o64 C1 /5 ib``
``X64``
``64-bit``
"""
SAL_RM16_IMM8: int = 385
"""
``SAL r/m16, imm8``
``o16 C1 /6 ib``
``186+``
``16/32/64-bit``
"""
SAL_RM32_IMM8: int = 386
"""
``SAL r/m32, imm8``
``o32 C1 /6 ib``
``386+``
``16/32/64-bit``
"""
SAL_RM64_IMM8: int = 387
"""
``SAL r/m64, imm8``
``o64 C1 /6 ib``
``X64``
``64-bit``
"""
SAR_RM16_IMM8: int = 388
"""
``SAR r/m16, imm8``
``o16 C1 /7 ib``
``186+``
``16/32/64-bit``
"""
SAR_RM32_IMM8: int = 389
"""
``SAR r/m32, imm8``
``o32 C1 /7 ib``
``386+``
``16/32/64-bit``
"""
SAR_RM64_IMM8: int = 390
"""
``SAR r/m64, imm8``
``o64 C1 /7 ib``
``X64``
``64-bit``
"""
RETNW_IMM16: int = 391
"""
``RET imm16``
``o16 C2 iw``
``8086+``
``16/32/64-bit``
"""
RETND_IMM16: int = 392
"""
``RET imm16``
``o32 C2 iw``
``386+``
``16/32-bit``
"""
RETNQ_IMM16: int = 393
"""
``RET imm16``
``o64 C2 iw``
``X64``
``64-bit``
"""
RETNW: int = 394
"""
``RET``
``o16 C3``
``8086+``
``16/32/64-bit``
"""
RETND: int = 395
"""
``RET``
``o32 C3``
``386+``
``16/32-bit``
"""
RETNQ: int = 396
"""
``RET``
``o64 C3``
``X64``
``64-bit``
"""
LES_R16_M1616: int = 397
"""
``LES r16, m16:16``
``o16 C4 /r``
``8086+``
``16/32-bit``
"""
LES_R32_M1632: int = 398
"""
``LES r32, m16:32``
``o32 C4 /r``
``386+``
``16/32-bit``
"""
LDS_R16_M1616: int = 399
"""
``LDS r16, m16:16``
``o16 C5 /r``
``8086+``
``16/32-bit``
"""
LDS_R32_M1632: int = 400
"""
``LDS r32, m16:32``
``o32 C5 /r``
``386+``
``16/32-bit``
"""
MOV_RM8_IMM8: int = 401
"""
``MOV r/m8, imm8``
``C6 /0 ib``
``8086+``
``16/32/64-bit``
"""
XABORT_IMM8: int = 402
"""
``XABORT imm8``
``C6 F8 ib``
``RTM``
``16/32/64-bit``
"""
MOV_RM16_IMM16: int = 403
"""
``MOV r/m16, imm16``
``o16 C7 /0 iw``
``8086+``
``16/32/64-bit``
"""
MOV_RM32_IMM32: int = 404
"""
``MOV r/m32, imm32``
``o32 C7 /0 id``
``386+``
``16/32/64-bit``
"""
MOV_RM64_IMM32: int = 405
"""
``MOV r/m64, imm32``
``o64 C7 /0 id``
``X64``
``64-bit``
"""
XBEGIN_REL16: int = 406
"""
``XBEGIN rel16``
``o16 C7 F8 cw``
``RTM``
``16/32/64-bit``
"""
XBEGIN_REL32: int = 407
"""
``XBEGIN rel32``
``o32 C7 F8 cd``
``RTM``
``16/32/64-bit``
"""
ENTERW_IMM16_IMM8: int = 408
"""
``ENTER imm16, imm8``
``o16 C8 iw ib``
``186+``
``16/32/64-bit``
"""
ENTERD_IMM16_IMM8: int = 409
"""
``ENTER imm16, imm8``
``o32 C8 iw ib``
``386+``
``16/32-bit``
"""
ENTERQ_IMM16_IMM8: int = 410
"""
``ENTER imm16, imm8``
``o64 C8 iw ib``
``X64``
``64-bit``
"""
LEAVEW: int = 411
"""
``LEAVE``
``o16 C9``
``186+``
``16/32/64-bit``
"""
LEAVED: int = 412
"""
``LEAVE``
``o32 C9``
``386+``
``16/32-bit``
"""
LEAVEQ: int = 413
"""
``LEAVE``
``o64 C9``
``X64``
``64-bit``
"""
RETFW_IMM16: int = 414
"""
``RETF imm16``
``o16 CA iw``
``8086+``
``16/32/64-bit``
"""
RETFD_IMM16: int = 415
"""
``RETF imm16``
``o32 CA iw``
``386+``
``16/32/64-bit``
"""
RETFQ_IMM16: int = 416
"""
``RETF imm16``
``o64 CA iw``
``X64``
``64-bit``
"""
RETFW: int = 417
"""
``RETF``
``o16 CB``
``8086+``
``16/32/64-bit``
"""
RETFD: int = 418
"""
``RETF``
``o32 CB``
``386+``
``16/32/64-bit``
"""
RETFQ: int = 419
"""
``RETF``
``o64 CB``
``X64``
``64-bit``
"""
INT3: int = 420
"""
``INT3``
``CC``
``8086+``
``16/32/64-bit``
"""
INT_IMM8: int = 421
"""
``INT imm8``
``CD ib``
``8086+``
``16/32/64-bit``
"""
INTO: int = 422
"""
``INTO``
``CE``
``8086+``
``16/32-bit``
"""
IRETW: int = 423
"""
``IRET``
``o16 CF``
``8086+``
``16/32/64-bit``
"""
IRETD: int = 424
"""
``IRETD``
``o32 CF``
``386+``
``16/32/64-bit``
"""
IRETQ: int = 425
"""
``IRETQ``
``o64 CF``
``X64``
``64-bit``
"""
ROL_RM8_1: int = 426
"""
``ROL r/m8, 1``
``D0 /0``
``8086+``
``16/32/64-bit``
"""
ROR_RM8_1: int = 427
"""
``ROR r/m8, 1``
``D0 /1``
``8086+``
``16/32/64-bit``
"""
RCL_RM8_1: int = 428
"""
``RCL r/m8, 1``
``D0 /2``
``8086+``
``16/32/64-bit``
"""
RCR_RM8_1: int = 429
"""
``RCR r/m8, 1``
``D0 /3``
``8086+``
``16/32/64-bit``
"""
SHL_RM8_1: int = 430
"""
``SHL r/m8, 1``
``D0 /4``
``8086+``
``16/32/64-bit``
"""
SHR_RM8_1: int = 431
"""
``SHR r/m8, 1``
``D0 /5``
``8086+``
``16/32/64-bit``
"""
SAL_RM8_1: int = 432
"""
``SAL r/m8, 1``
``D0 /6``
``8086+``
``16/32/64-bit``
"""
SAR_RM8_1: int = 433
"""
``SAR r/m8, 1``
``D0 /7``
``8086+``
``16/32/64-bit``
"""
ROL_RM16_1: int = 434
"""
``ROL r/m16, 1``
``o16 D1 /0``
``8086+``
``16/32/64-bit``
"""
ROL_RM32_1: int = 435
"""
``ROL r/m32, 1``
``o32 D1 /0``
``386+``
``16/32/64-bit``
"""
ROL_RM64_1: int = 436
"""
``ROL r/m64, 1``
``o64 D1 /0``
``X64``
``64-bit``
"""
ROR_RM16_1: int = 437
"""
``ROR r/m16, 1``
``o16 D1 /1``
``8086+``
``16/32/64-bit``
"""
ROR_RM32_1: int = 438
"""
``ROR r/m32, 1``
``o32 D1 /1``
``386+``
``16/32/64-bit``
"""
ROR_RM64_1: int = 439
"""
``ROR r/m64, 1``
``o64 D1 /1``
``X64``
``64-bit``
"""
RCL_RM16_1: int = 440
"""
``RCL r/m16, 1``
``o16 D1 /2``
``8086+``
``16/32/64-bit``
"""
RCL_RM32_1: int = 441
"""
``RCL r/m32, 1``
``o32 D1 /2``
``386+``
``16/32/64-bit``
"""
RCL_RM64_1: int = 442
"""
``RCL r/m64, 1``
``o64 D1 /2``
``X64``
``64-bit``
"""
RCR_RM16_1: int = 443
"""
``RCR r/m16, 1``
``o16 D1 /3``
``8086+``
``16/32/64-bit``
"""
RCR_RM32_1: int = 444
"""
``RCR r/m32, 1``
``o32 D1 /3``
``386+``
``16/32/64-bit``
"""
RCR_RM64_1: int = 445
"""
``RCR r/m64, 1``
``o64 D1 /3``
``X64``
``64-bit``
"""
SHL_RM16_1: int = 446
"""
``SHL r/m16, 1``
``o16 D1 /4``
``8086+``
``16/32/64-bit``
"""
SHL_RM32_1: int = 447
"""
``SHL r/m32, 1``
``o32 D1 /4``
``386+``
``16/32/64-bit``
"""
SHL_RM64_1: int = 448
"""
``SHL r/m64, 1``
``o64 D1 /4``
``X64``
``64-bit``
"""
SHR_RM16_1: int = 449
"""
``SHR r/m16, 1``
``o16 D1 /5``
``8086+``
``16/32/64-bit``
"""
SHR_RM32_1: int = 450
"""
``SHR r/m32, 1``
``o32 D1 /5``
``386+``
``16/32/64-bit``
"""
SHR_RM64_1: int = 451
"""
``SHR r/m64, 1``
``o64 D1 /5``
``X64``
``64-bit``
"""
SAL_RM16_1: int = 452
"""
``SAL r/m16, 1``
``o16 D1 /6``
``8086+``
``16/32/64-bit``
"""
SAL_RM32_1: int = 453
"""
``SAL r/m32, 1``
``o32 D1 /6``
``386+``
``16/32/64-bit``
"""
SAL_RM64_1: int = 454
"""
``SAL r/m64, 1``
``o64 D1 /6``
``X64``
``64-bit``
"""
SAR_RM16_1: int = 455
"""
``SAR r/m16, 1``
``o16 D1 /7``
``8086+``
``16/32/64-bit``
"""
SAR_RM32_1: int = 456
"""
``SAR r/m32, 1``
``o32 D1 /7``
``386+``
``16/32/64-bit``
"""
SAR_RM64_1: int = 457
"""
``SAR r/m64, 1``
``o64 D1 /7``
``X64``
``64-bit``
"""
ROL_RM8_CL: int = 458
"""
``ROL r/m8, CL``
``D2 /0``
``8086+``
``16/32/64-bit``
"""
ROR_RM8_CL: int = 459
"""
``ROR r/m8, CL``
``D2 /1``
``8086+``
``16/32/64-bit``
"""
RCL_RM8_CL: int = 460
"""
``RCL r/m8, CL``
``D2 /2``
``8086+``
``16/32/64-bit``
"""
RCR_RM8_CL: int = 461
"""
``RCR r/m8, CL``
``D2 /3``
``8086+``
``16/32/64-bit``
"""
SHL_RM8_CL: int = 462
"""
``SHL r/m8, CL``
``D2 /4``
``8086+``
``16/32/64-bit``
"""
SHR_RM8_CL: int = 463
"""
``SHR r/m8, CL``
``D2 /5``
``8086+``
``16/32/64-bit``
"""
SAL_RM8_CL: int = 464
"""
``SAL r/m8, CL``
``D2 /6``
``8086+``
``16/32/64-bit``
"""
SAR_RM8_CL: int = 465
"""
``SAR r/m8, CL``
``D2 /7``
``8086+``
``16/32/64-bit``
"""
ROL_RM16_CL: int = 466
"""
``ROL r/m16, CL``
``o16 D3 /0``
``8086+``
``16/32/64-bit``
"""
ROL_RM32_CL: int = 467
"""
``ROL r/m32, CL``
``o32 D3 /0``
``386+``
``16/32/64-bit``
"""
ROL_RM64_CL: int = 468
"""
``ROL r/m64, CL``
``o64 D3 /0``
``X64``
``64-bit``
"""
ROR_RM16_CL: int = 469
"""
``ROR r/m16, CL``
``o16 D3 /1``
``8086+``
``16/32/64-bit``
"""
ROR_RM32_CL: int = 470
"""
``ROR r/m32, CL``
``o32 D3 /1``
``386+``
``16/32/64-bit``
"""
ROR_RM64_CL: int = 471
"""
``ROR r/m64, CL``
``o64 D3 /1``
``X64``
``64-bit``
"""
RCL_RM16_CL: int = 472
"""
``RCL r/m16, CL``
``o16 D3 /2``
``8086+``
``16/32/64-bit``
"""
RCL_RM32_CL: int = 473
"""
``RCL r/m32, CL``
``o32 D3 /2``
``386+``
``16/32/64-bit``
"""
RCL_RM64_CL: int = 474
"""
``RCL r/m64, CL``
``o64 D3 /2``
``X64``
``64-bit``
"""
RCR_RM16_CL: int = 475
"""
``RCR r/m16, CL``
``o16 D3 /3``
``8086+``
``16/32/64-bit``
"""
RCR_RM32_CL: int = 476
"""
``RCR r/m32, CL``
``o32 D3 /3``
``386+``
``16/32/64-bit``
"""
RCR_RM64_CL: int = 477
"""
``RCR r/m64, CL``
``o64 D3 /3``
``X64``
``64-bit``
"""
SHL_RM16_CL: int = 478
"""
``SHL r/m16, CL``
``o16 D3 /4``
``8086+``
``16/32/64-bit``
"""
SHL_RM32_CL: int = 479
"""
``SHL r/m32, CL``
``o32 D3 /4``
``386+``
``16/32/64-bit``
"""
SHL_RM64_CL: int = 480
"""
``SHL r/m64, CL``
``o64 D3 /4``
``X64``
``64-bit``
"""
SHR_RM16_CL: int = 481
"""
``SHR r/m16, CL``
``o16 D3 /5``
``8086+``
``16/32/64-bit``
"""
SHR_RM32_CL: int = 482
"""
``SHR r/m32, CL``
``o32 D3 /5``
``386+``
``16/32/64-bit``
"""
SHR_RM64_CL: int = 483
"""
``SHR r/m64, CL``
``o64 D3 /5``
``X64``
``64-bit``
"""
SAL_RM16_CL: int = 484
"""
``SAL r/m16, CL``
``o16 D3 /6``
``8086+``
``16/32/64-bit``
"""
SAL_RM32_CL: int = 485
"""
``SAL r/m32, CL``
``o32 D3 /6``
``386+``
``16/32/64-bit``
"""
SAL_RM64_CL: int = 486
"""
``SAL r/m64, CL``
``o64 D3 /6``
``X64``
``64-bit``
"""
SAR_RM16_CL: int = 487
"""
``SAR r/m16, CL``
``o16 D3 /7``
``8086+``
``16/32/64-bit``
"""
SAR_RM32_CL: int = 488
"""
``SAR r/m32, CL``
``o32 D3 /7``
``386+``
``16/32/64-bit``
"""
SAR_RM64_CL: int = 489
"""
``SAR r/m64, CL``
``o64 D3 /7``
``X64``
``64-bit``
"""
AAM_IMM8: int = 490
"""
``AAM imm8``
``D4 ib``
``8086+``
``16/32-bit``
"""
AAD_IMM8: int = 491
"""
``AAD imm8``
``D5 ib``
``8086+``
``16/32-bit``
"""
SALC: int = 492
"""
``SALC``
``D6``
``8086+``
``16/32-bit``
"""
XLAT_M8: int = 493
"""
``XLATB``
``D7``
``8086+``
``16/32/64-bit``
"""
FADD_M32FP: int = 494
"""
``FADD m32fp``
``D8 /0``
``8087+``
``16/32/64-bit``
"""
FMUL_M32FP: int = 495
"""
``FMUL m32fp``
``D8 /1``
``8087+``
``16/32/64-bit``
"""
FCOM_M32FP: int = 496
"""
``FCOM m32fp``
``D8 /2``
``8087+``
``16/32/64-bit``
"""
FCOMP_M32FP: int = 497
"""
``FCOMP m32fp``
``D8 /3``
``8087+``
``16/32/64-bit``
"""
FSUB_M32FP: int = 498
"""
``FSUB m32fp``
``D8 /4``
``8087+``
``16/32/64-bit``
"""
FSUBR_M32FP: int = 499
"""
``FSUBR m32fp``
``D8 /5``
``8087+``
``16/32/64-bit``
"""
FDIV_M32FP: int = 500
"""
``FDIV m32fp``
``D8 /6``
``8087+``
``16/32/64-bit``
"""
FDIVR_M32FP: int = 501
"""
``FDIVR m32fp``
``D8 /7``
``8087+``
``16/32/64-bit``
"""
FADD_ST0_STI: int = 502
"""
``FADD ST(0), ST(i)``
``D8 C0+i``
``8087+``
``16/32/64-bit``
"""
FMUL_ST0_STI: int = 503
"""
``FMUL ST(0), ST(i)``
``D8 C8+i``
``8087+``
``16/32/64-bit``
"""
FCOM_ST0_STI: int = 504
"""
``FCOM ST(i)``
``D8 D0+i``
``8087+``
``16/32/64-bit``
"""
FCOMP_ST0_STI: int = 505
"""
``FCOMP ST(i)``
``D8 D8+i``
``8087+``
``16/32/64-bit``
"""
FSUB_ST0_STI: int = 506
"""
``FSUB ST(0), ST(i)``
``D8 E0+i``
``8087+``
``16/32/64-bit``
"""
FSUBR_ST0_STI: int = 507
"""
``FSUBR ST(0), ST(i)``
``D8 E8+i``
``8087+``
``16/32/64-bit``
"""
FDIV_ST0_STI: int = 508
"""
``FDIV ST(0), ST(i)``
``D8 F0+i``
``8087+``
``16/32/64-bit``
"""
FDIVR_ST0_STI: int = 509
"""
``FDIVR ST(0), ST(i)``
``D8 F8+i``
``8087+``
``16/32/64-bit``
"""
FLD_M32FP: int = 510
"""
``FLD m32fp``
``D9 /0``
``8087+``
``16/32/64-bit``
"""
FST_M32FP: int = 511
"""
``FST m32fp``
``D9 /2``
``8087+``
``16/32/64-bit``
"""
FSTP_M32FP: int = 512
"""
``FSTP m32fp``
``D9 /3``
``8087+``
``16/32/64-bit``
"""
FLDENV_M14BYTE: int = 513
"""
``FLDENV m14byte``
``o16 D9 /4``
``8087+``
``16/32/64-bit``
"""
FLDENV_M28BYTE: int = 514
"""
``FLDENV m28byte``
``o32 D9 /4``
``387+``
``16/32/64-bit``
"""
FLDCW_M2BYTE: int = 515
"""
``FLDCW m2byte``
``D9 /5``
``8087+``
``16/32/64-bit``
"""
FNSTENV_M14BYTE: int = 516
"""
``FNSTENV m14byte``
``o16 D9 /6``
``8087+``
``16/32/64-bit``
"""
FSTENV_M14BYTE: int = 517
"""
``FSTENV m14byte``
``9B o16 D9 /6``
``8087+``
``16/32/64-bit``
"""
FNSTENV_M28BYTE: int = 518
"""
``FNSTENV m28byte``
``o32 D9 /6``
``387+``
``16/32/64-bit``
"""
FSTENV_M28BYTE: int = 519
"""
``FSTENV m28byte``
``9B o32 D9 /6``
``387+``
``16/32/64-bit``
"""
FNSTCW_M2BYTE: int = 520
"""
``FNSTCW m2byte``
``D9 /7``
``8087+``
``16/32/64-bit``
"""
FSTCW_M2BYTE: int = 521
"""
``FSTCW m2byte``
``9B D9 /7``
``8087+``
``16/32/64-bit``
"""
FLD_STI: int = 522
"""
``FLD ST(i)``
``D9 C0+i``
``8087+``
``16/32/64-bit``
"""
FXCH_ST0_STI: int = 523
"""
``FXCH ST(i)``
``D9 C8+i``
``8087+``
``16/32/64-bit``
"""
FNOP: int = 524
"""
``FNOP``
``D9 D0``
``8087+``
``16/32/64-bit``
"""
FSTPNCE_STI: int = 525
"""
``FSTPNCE ST(i)``
``D9 D8+i``
``8087+``
``16/32/64-bit``
"""
FCHS: int = 526
"""
``FCHS``
``D9 E0``
``8087+``
``16/32/64-bit``
"""
FABS: int = 527
"""
``FABS``
``D9 E1``
``8087+``
``16/32/64-bit``
"""
FTST: int = 528
"""
``FTST``
``D9 E4``
``8087+``
``16/32/64-bit``
"""
FXAM: int = 529
"""
``FXAM``
``D9 E5``
``8087+``
``16/32/64-bit``
"""
FLD1: int = 530
"""
``FLD1``
``D9 E8``
``8087+``
``16/32/64-bit``
"""
FLDL2T: int = 531
"""
``FLDL2T``
``D9 E9``
``8087+``
``16/32/64-bit``
"""
FLDL2E: int = 532
"""
``FLDL2E``
``D9 EA``
``8087+``
``16/32/64-bit``
"""
FLDPI: int = 533
"""
``FLDPI``
``D9 EB``
``8087+``
``16/32/64-bit``
"""
FLDLG2: int = 534
"""
``FLDLG2``
``D9 EC``
``8087+``
``16/32/64-bit``
"""
FLDLN2: int = 535
"""
``FLDLN2``
``D9 ED``
``8087+``
``16/32/64-bit``
"""
FLDZ: int = 536
"""
``FLDZ``
``D9 EE``
``8087+``
``16/32/64-bit``
"""
F2XM1: int = 537
"""
``F2XM1``
``D9 F0``
``8087+``
``16/32/64-bit``
"""
FYL2X: int = 538
"""
``FYL2X``
``D9 F1``
``8087+``
``16/32/64-bit``
"""
FPTAN: int = 539
"""
``FPTAN``
``D9 F2``
``8087+``
``16/32/64-bit``
"""
FPATAN: int = 540
"""
``FPATAN``
``D9 F3``
``8087+``
``16/32/64-bit``
"""
FXTRACT: int = 541
"""
``FXTRACT``
``D9 F4``
``8087+``
``16/32/64-bit``
"""
FPREM1: int = 542
"""
``FPREM1``
``D9 F5``
``387+``
``16/32/64-bit``
"""
FDECSTP: int = 543
"""
``FDECSTP``
``D9 F6``
``8087+``
``16/32/64-bit``
"""
FINCSTP: int = 544
"""
``FINCSTP``
``D9 F7``
``8087+``
``16/32/64-bit``
"""
FPREM: int = 545
"""
``FPREM``
``D9 F8``
``8087+``
``16/32/64-bit``
"""
FYL2XP1: int = 546
"""
``FYL2XP1``
``D9 F9``
``8087+``
``16/32/64-bit``
"""
FSQRT: int = 547
"""
``FSQRT``
``D9 FA``
``8087+``
``16/32/64-bit``
"""
FSINCOS: int = 548
"""
``FSINCOS``
``D9 FB``
``387+``
``16/32/64-bit``
"""
FRNDINT: int = 549
"""
``FRNDINT``
``D9 FC``
``8087+``
``16/32/64-bit``
"""
FSCALE: int = 550
"""
``FSCALE``
``D9 FD``
``8087+``
``16/32/64-bit``
"""
FSIN: int = 551
"""
``FSIN``
``D9 FE``
``387+``
``16/32/64-bit``
"""
FCOS: int = 552
"""
``FCOS``
``D9 FF``
``387+``
``16/32/64-bit``
"""
FIADD_M32INT: int = 553
"""
``FIADD m32int``
``DA /0``
``8087+``
``16/32/64-bit``
"""
FIMUL_M32INT: int = 554
"""
``FIMUL m32int``
``DA /1``
``8087+``
``16/32/64-bit``
"""
FICOM_M32INT: int = 555
"""
``FICOM m32int``
``DA /2``
``8087+``
``16/32/64-bit``
"""
FICOMP_M32INT: int = 556
"""
``FICOMP m32int``
``DA /3``
``8087+``
``16/32/64-bit``
"""
FISUB_M32INT: int = 557
"""
``FISUB m32int``
``DA /4``
``8087+``
``16/32/64-bit``
"""
FISUBR_M32INT: int = 558
"""
``FISUBR m32int``
``DA /5``
``8087+``
``16/32/64-bit``
"""
FIDIV_M32INT: int = 559
"""
``FIDIV m32int``
``DA /6``
``8087+``
``16/32/64-bit``
"""
FIDIVR_M32INT: int = 560
"""
``FIDIVR m32int``
``DA /7``
``8087+``
``16/32/64-bit``
"""
FCMOVB_ST0_STI: int = 561
"""
``FCMOVB ST(0), ST(i)``
``DA C0+i``
``8087+ and CMOV``
``16/32/64-bit``
"""
FCMOVE_ST0_STI: int = 562
"""
``FCMOVE ST(0), ST(i)``
``DA C8+i``
``8087+ and CMOV``
``16/32/64-bit``
"""
FCMOVBE_ST0_STI: int = 563
"""
``FCMOVBE ST(0), ST(i)``
``DA D0+i``
``8087+ and CMOV``
``16/32/64-bit``
"""
FCMOVU_ST0_STI: int = 564
"""
``FCMOVU ST(0), ST(i)``
``DA D8+i``
``8087+ and CMOV``
``16/32/64-bit``
"""
FUCOMPP: int = 565
"""
``FUCOMPP``
``DA E9``
``387+``
``16/32/64-bit``
"""
FILD_M32INT: int = 566
"""
``FILD m32int``
``DB /0``
``8087+``
``16/32/64-bit``
"""
FISTTP_M32INT: int = 567
"""
``FISTTP m32int``
``DB /1``
``8087+ and SSE3``
``16/32/64-bit``
"""
FIST_M32INT: int = 568
"""
``FIST m32int``
``DB /2``
``8087+``
``16/32/64-bit``
"""
FISTP_M32INT: int = 569
"""
``FISTP m32int``
``DB /3``
``8087+``
``16/32/64-bit``
"""
FLD_M80FP: int = 570
"""
``FLD m80fp``
``DB /5``
``8087+``
``16/32/64-bit``
"""
FSTP_M80FP: int = 571
"""
``FSTP m80fp``
``DB /7``
``8087+``
``16/32/64-bit``
"""
FCMOVNB_ST0_STI: int = 572
"""
``FCMOVNB ST(0), ST(i)``
``DB C0+i``
``8087+ and CMOV``
``16/32/64-bit``
"""
FCMOVNE_ST0_STI: int = 573
"""
``FCMOVNE ST(0), ST(i)``
``DB C8+i``
``8087+ and CMOV``
``16/32/64-bit``
"""
FCMOVNBE_ST0_STI: int = 574
"""
``FCMOVNBE ST(0), ST(i)``
``DB D0+i``
``8087+ and CMOV``
``16/32/64-bit``
"""
FCMOVNU_ST0_STI: int = 575
"""
``FCMOVNU ST(0), ST(i)``
``DB D8+i``
``8087+ and CMOV``
``16/32/64-bit``
"""
FNENI: int = 576
"""
``FNENI``
``DB E0``
``8087+``
``16/32/64-bit``
"""
FENI: int = 577
"""
``FENI``
``9B DB E0``
``8087+``
``16/32/64-bit``
"""
FNDISI: int = 578
"""
``FNDISI``
``DB E1``
``8087+``
``16/32/64-bit``
"""
FDISI: int = 579
"""
``FDISI``
``9B DB E1``
``8087+``
``16/32/64-bit``
"""
FNCLEX: int = 580
"""
``FNCLEX``
``DB E2``
``8087+``
``16/32/64-bit``
"""
FCLEX: int = 581
"""
``FCLEX``
``9B DB E2``
``8087+``
``16/32/64-bit``
"""
FNINIT: int = 582
"""
``FNINIT``
``DB E3``
``8087+``
``16/32/64-bit``
"""
FINIT: int = 583
"""
``FINIT``
``9B DB E3``
``8087+``
``16/32/64-bit``
"""
FNSETPM: int = 584
"""
``FNSETPM``
``DB E4``
``287+``
``16/32/64-bit``
"""
FSETPM: int = 585
"""
``FSETPM``
``9B DB E4``
``287+``
``16/32/64-bit``
"""
FRSTPM: int = 586
"""
``FRSTPM``
``DB E5``
``287 XL``
``16/32-bit``
"""
FUCOMI_ST0_STI: int = 587
"""
``FUCOMI ST, ST(i)``
``DB E8+i``
``8087+ and CMOV``
``16/32/64-bit``
"""
FCOMI_ST0_STI: int = 588
"""
``FCOMI ST, ST(i)``
``DB F0+i``
``8087+ and CMOV``
``16/32/64-bit``
"""
FADD_M64FP: int = 589
"""
``FADD m64fp``
``DC /0``
``8087+``
``16/32/64-bit``
"""
FMUL_M64FP: int = 590
"""
``FMUL m64fp``
``DC /1``
``8087+``
``16/32/64-bit``
"""
FCOM_M64FP: int = 591
"""
``FCOM m64fp``
``DC /2``
``8087+``
``16/32/64-bit``
"""
FCOMP_M64FP: int = 592
"""
``FCOMP m64fp``
``DC /3``
``8087+``
``16/32/64-bit``
"""
FSUB_M64FP: int = 593
"""
``FSUB m64fp``
``DC /4``
``8087+``
``16/32/64-bit``
"""
FSUBR_M64FP: int = 594
"""
``FSUBR m64fp``
``DC /5``
``8087+``
``16/32/64-bit``
"""
FDIV_M64FP: int = 595
"""
``FDIV m64fp``
``DC /6``
``8087+``
``16/32/64-bit``
"""
FDIVR_M64FP: int = 596
"""
``FDIVR m64fp``
``DC /7``
``8087+``
``16/32/64-bit``
"""
FADD_STI_ST0: int = 597
"""
``FADD ST(i), ST(0)``
``DC C0+i``
``8087+``
``16/32/64-bit``
"""
FMUL_STI_ST0: int = 598
"""
``FMUL ST(i), ST(0)``
``DC C8+i``
``8087+``
``16/32/64-bit``
"""
FCOM_ST0_STI_DCD0: int = 599
"""
``FCOM ST(i)``
``DC D0+i``
``8087+``
``16/32/64-bit``
"""
FCOMP_ST0_STI_DCD8: int = 600
"""
``FCOMP ST(i)``
``DC D8+i``
``8087+``
``16/32/64-bit``
"""
FSUBR_STI_ST0: int = 601
"""
``FSUBR ST(i), ST(0)``
``DC E0+i``
``8087+``
``16/32/64-bit``
"""
FSUB_STI_ST0: int = 602
"""
``FSUB ST(i), ST(0)``
``DC E8+i``
``8087+``
``16/32/64-bit``
"""
FDIVR_STI_ST0: int = 603
"""
``FDIVR ST(i), ST(0)``
``DC F0+i``
``8087+``
``16/32/64-bit``
"""
FDIV_STI_ST0: int = 604
"""
``FDIV ST(i), ST(0)``
``DC F8+i``
``8087+``
``16/32/64-bit``
"""
FLD_M64FP: int = 605
"""
``FLD m64fp``
``DD /0``
``8087+``
``16/32/64-bit``
"""
FISTTP_M64INT: int = 606
"""
``FISTTP m64int``
``DD /1``
``8087+ and SSE3``
``16/32/64-bit``
"""
FST_M64FP: int = 607
"""
``FST m64fp``
``DD /2``
``8087+``
``16/32/64-bit``
"""
FSTP_M64FP: int = 608
"""
``FSTP m64fp``
``DD /3``
``8087+``
``16/32/64-bit``
"""
FRSTOR_M94BYTE: int = 609
"""
``FRSTOR m94byte``
``o16 DD /4``
``8087+``
``16/32/64-bit``
"""
FRSTOR_M108BYTE: int = 610
"""
``FRSTOR m108byte``
``o32 DD /4``
``387+``
``16/32/64-bit``
"""
FNSAVE_M94BYTE: int = 611
"""
``FNSAVE m94byte``
``o16 DD /6``
``8087+``
``16/32/64-bit``
"""
FSAVE_M94BYTE: int = 612
"""
``FSAVE m94byte``
``9B o16 DD /6``
``8087+``
``16/32/64-bit``
"""
FNSAVE_M108BYTE: int = 613
"""
``FNSAVE m108byte``
``o32 DD /6``
``387+``
``16/32/64-bit``
"""
FSAVE_M108BYTE: int = 614
"""
``FSAVE m108byte``
``9B o32 DD /6``
``387+``
``16/32/64-bit``
"""
FNSTSW_M2BYTE: int = 615
"""
``FNSTSW m2byte``
``DD /7``
``8087+``
``16/32/64-bit``
"""
FSTSW_M2BYTE: int = 616
"""
``FSTSW m2byte``
``9B DD /7``
``8087+``
``16/32/64-bit``
"""
FFREE_STI: int = 617
"""
``FFREE ST(i)``
``DD C0+i``
``8087+``
``16/32/64-bit``
"""
FXCH_ST0_STI_DDC8: int = 618
"""
``FXCH ST(i)``
``DD C8+i``
``8087+``
``16/32/64-bit``
"""
FST_STI: int = 619
"""
``FST ST(i)``
``DD D0+i``
``8087+``
``16/32/64-bit``
"""
FSTP_STI: int = 620
"""
``FSTP ST(i)``
``DD D8+i``
``8087+``
``16/32/64-bit``
"""
FUCOM_ST0_STI: int = 621
"""
``FUCOM ST(i)``
``DD E0+i``
``8087+``
``16/32/64-bit``
"""
FUCOMP_ST0_STI: int = 622
"""
``FUCOMP ST(i)``
``DD E8+i``
``8087+``
``16/32/64-bit``
"""
FIADD_M16INT: int = 623
"""
``FIADD m16int``
``DE /0``
``8087+``
``16/32/64-bit``
"""
FIMUL_M16INT: int = 624
"""
``FIMUL m16int``
``DE /1``
``8087+``
``16/32/64-bit``
"""
FICOM_M16INT: int = 625
"""
``FICOM m16int``
``DE /2``
``8087+``
``16/32/64-bit``
"""
FICOMP_M16INT: int = 626
"""
``FICOMP m16int``
``DE /3``
``8087+``
``16/32/64-bit``
"""
FISUB_M16INT: int = 627
"""
``FISUB m16int``
``DE /4``
``8087+``
``16/32/64-bit``
"""
FISUBR_M16INT: int = 628
"""
``FISUBR m16int``
``DE /5``
``8087+``
``16/32/64-bit``
"""
FIDIV_M16INT: int = 629
"""
``FIDIV m16int``
``DE /6``
``8087+``
``16/32/64-bit``
"""
FIDIVR_M16INT: int = 630
"""
``FIDIVR m16int``
``DE /7``
``8087+``
``16/32/64-bit``
"""
FADDP_STI_ST0: int = 631
"""
``FADDP ST(i), ST(0)``
``DE C0+i``
``8087+``
``16/32/64-bit``
"""
FMULP_STI_ST0: int = 632
"""
``FMULP ST(i), ST(0)``
``DE C8+i``
``8087+``
``16/32/64-bit``
"""
FCOMP_ST0_STI_DED0: int = 633
"""
``FCOMP ST(i)``
``DE D0+i``
``8087+``
``16/32/64-bit``
"""
FCOMPP: int = 634
"""
``FCOMPP``
``DE D9``
``8087+``
``16/32/64-bit``
"""
FSUBRP_STI_ST0: int = 635
"""
``FSUBRP ST(i), ST(0)``
``DE E0+i``
``8087+``
``16/32/64-bit``
"""
FSUBP_STI_ST0: int = 636
"""
``FSUBP ST(i), ST(0)``
``DE E8+i``
``8087+``
``16/32/64-bit``
"""
FDIVRP_STI_ST0: int = 637
"""
``FDIVRP ST(i), ST(0)``
``DE F0+i``
``8087+``
``16/32/64-bit``
"""
FDIVP_STI_ST0: int = 638
"""
``FDIVP ST(i), ST(0)``
``DE F8+i``
``8087+``
``16/32/64-bit``
"""
FILD_M16INT: int = 639
"""
``FILD m16int``
``DF /0``
``8087+``
``16/32/64-bit``
"""
FISTTP_M16INT: int = 640
"""
``FISTTP m16int``
``DF /1``
``8087+ and SSE3``
``16/32/64-bit``
"""
FIST_M16INT: int = 641
"""
``FIST m16int``
``DF /2``
``8087+``
``16/32/64-bit``
"""
FISTP_M16INT: int = 642
"""
``FISTP m16int``
``DF /3``
``8087+``
``16/32/64-bit``
"""
FBLD_M80BCD: int = 643
"""
``FBLD m80bcd``
``DF /4``
``8087+``
``16/32/64-bit``
"""
FILD_M64INT: int = 644
"""
``FILD m64int``
``DF /5``
``8087+``
``16/32/64-bit``
"""
FBSTP_M80BCD: int = 645
"""
``FBSTP m80bcd``
``DF /6``
``8087+``
``16/32/64-bit``
"""
FISTP_M64INT: int = 646
"""
``FISTP m64int``
``DF /7``
``8087+``
``16/32/64-bit``
"""
FFREEP_STI: int = 647
"""
``FFREEP ST(i)``
``DF C0+i``
``8087+``
``16/32/64-bit``
"""
FXCH_ST0_STI_DFC8: int = 648
"""
``FXCH ST(i)``
``DF C8+i``
``8087+``
``16/32/64-bit``
"""
FSTP_STI_DFD0: int = 649
"""
``FSTP ST(i)``
``DF D0+i``
``8087+``
``16/32/64-bit``
"""
FSTP_STI_DFD8: int = 650
"""
``FSTP ST(i)``
``DF D8+i``
``8087+``
``16/32/64-bit``
"""
FNSTSW_AX: int = 651
"""
``FNSTSW AX``
``DF E0``
``287+``
``16/32/64-bit``
"""
FSTSW_AX: int = 652
"""
``FSTSW AX``
``9B DF E0``
``287+``
``16/32/64-bit``
"""
FSTDW_AX: int = 653
"""
``FSTDW AX``
``9B DF E1``
``387 SL``
``16/32-bit``
"""
FSTSG_AX: int = 654
"""
``FSTSG AX``
``9B DF E2``
``387 SL``
``16/32-bit``
"""
FUCOMIP_ST0_STI: int = 655
"""
``FUCOMIP ST, ST(i)``
``DF E8+i``
``8087+ and CMOV``
``16/32/64-bit``
"""
FCOMIP_ST0_STI: int = 656
"""
``FCOMIP ST, ST(i)``
``DF F0+i``
``8087+ and CMOV``
``16/32/64-bit``
"""
LOOPNE_REL8_16_CX: int = 657
"""
``LOOPNE rel8``
``a16 o16 E0 cb``
``8086+``
``16/32-bit``
"""
LOOPNE_REL8_32_CX: int = 658
"""
``LOOPNE rel8``
``a16 o32 E0 cb``
``386+``
``16/32-bit``
"""
LOOPNE_REL8_16_ECX: int = 659
"""
``LOOPNE rel8``
``a32 o16 E0 cb``
``386+``
``16/32/64-bit``
"""
LOOPNE_REL8_32_ECX: int = 660
"""
``LOOPNE rel8``
``a32 o32 E0 cb``
``386+``
``16/32-bit``
"""
LOOPNE_REL8_64_ECX: int = 661
"""
``LOOPNE rel8``
``a32 o64 E0 cb``
``X64``
``64-bit``
"""
LOOPNE_REL8_16_RCX: int = 662
"""
``LOOPNE rel8``
``a64 o16 E0 cb``
``X64``
``64-bit``
"""
LOOPNE_REL8_64_RCX: int = 663
"""
``LOOPNE rel8``
``a64 o64 E0 cb``
``X64``
``64-bit``
"""
LOOPE_REL8_16_CX: int = 664
"""
``LOOPE rel8``
``a16 o16 E1 cb``
``8086+``
``16/32-bit``
"""
LOOPE_REL8_32_CX: int = 665
"""
``LOOPE rel8``
``a16 o32 E1 cb``
``386+``
``16/32-bit``
"""
LOOPE_REL8_16_ECX: int = 666
"""
``LOOPE rel8``
``a32 o16 E1 cb``
``386+``
``16/32/64-bit``
"""
LOOPE_REL8_32_ECX: int = 667
"""
``LOOPE rel8``
``a32 o32 E1 cb``
``386+``
``16/32-bit``
"""
LOOPE_REL8_64_ECX: int = 668
"""
``LOOPE rel8``
``a32 o64 E1 cb``
``X64``
``64-bit``
"""
LOOPE_REL8_16_RCX: int = 669
"""
``LOOPE rel8``
``a64 o16 E1 cb``
``X64``
``64-bit``
"""
LOOPE_REL8_64_RCX: int = 670
"""
``LOOPE rel8``
``a64 o64 E1 cb``
``X64``
``64-bit``
"""
LOOP_REL8_16_CX: int = 671
"""
``LOOP rel8``
``a16 o16 E2 cb``
``8086+``
``16/32-bit``
"""
LOOP_REL8_32_CX: int = 672
"""
``LOOP rel8``
``a16 o32 E2 cb``
``386+``
``16/32-bit``
"""
LOOP_REL8_16_ECX: int = 673
"""
``LOOP rel8``
``a32 o16 E2 cb``
``386+``
``16/32/64-bit``
"""
LOOP_REL8_32_ECX: int = 674
"""
``LOOP rel8``
``a32 o32 E2 cb``
``386+``
``16/32-bit``
"""
LOOP_REL8_64_ECX: int = 675
"""
``LOOP rel8``
``a32 o64 E2 cb``
``X64``
``64-bit``
"""
LOOP_REL8_16_RCX: int = 676
"""
``LOOP rel8``
``a64 o16 E2 cb``
``X64``
``64-bit``
"""
LOOP_REL8_64_RCX: int = 677
"""
``LOOP rel8``
``a64 o64 E2 cb``
``X64``
``64-bit``
"""
JCXZ_REL8_16: int = 678
"""
``JCXZ rel8``
``a16 o16 E3 cb``
``8086+``
``16/32-bit``
"""
JCXZ_REL8_32: int = 679
"""
``JCXZ rel8``
``a16 o32 E3 cb``
``386+``
``16/32-bit``
"""
JECXZ_REL8_16: int = 680
"""
``JECXZ rel8``
``a32 o16 E3 cb``
``386+``
``16/32/64-bit``
"""
JECXZ_REL8_32: int = 681
"""
``JECXZ rel8``
``a32 o32 E3 cb``
``386+``
``16/32-bit``
"""
JECXZ_REL8_64: int = 682
"""
``JECXZ rel8``
``a32 o64 E3 cb``
``X64``
``64-bit``
"""
JRCXZ_REL8_16: int = 683
"""
``JRCXZ rel8``
``a64 o16 E3 cb``
``X64``
``64-bit``
"""
JRCXZ_REL8_64: int = 684
"""
``JRCXZ rel8``
``a64 o64 E3 cb``
``X64``
``64-bit``
"""
IN_AL_IMM8: int = 685
"""
``IN AL, imm8``
``E4 ib``
``8086+``
``16/32/64-bit``
"""
IN_AX_IMM8: int = 686
"""
``IN AX, imm8``
``o16 E5 ib``
``8086+``
``16/32/64-bit``
"""
IN_EAX_IMM8: int = 687
"""
``IN EAX, imm8``
``o32 E5 ib``
``386+``
``16/32/64-bit``
"""
OUT_IMM8_AL: int = 688
"""
``OUT imm8, AL``
``E6 ib``
``8086+``
``16/32/64-bit``
"""
OUT_IMM8_AX: int = 689
"""
``OUT imm8, AX``
``o16 E7 ib``
``8086+``
``16/32/64-bit``
"""
OUT_IMM8_EAX: int = 690
"""
``OUT imm8, EAX``
``o32 E7 ib``
``386+``
``16/32/64-bit``
"""
CALL_REL16: int = 691
"""
``CALL rel16``
``o16 E8 cw``
``8086+``
``16/32/64-bit``
"""
CALL_REL32_32: int = 692
"""
``CALL rel32``
``o32 E8 cd``
``386+``
``16/32-bit``
"""
CALL_REL32_64: int = 693
"""
``CALL rel32``
``o64 E8 cd``
``X64``
``64-bit``
"""
JMP_REL16: int = 694
"""
``JMP rel16``
``o16 E9 cw``
``8086+``
``16/32/64-bit``
"""
JMP_REL32_32: int = 695
"""
``JMP rel32``
``o32 E9 cd``
``386+``
``16/32-bit``
"""
JMP_REL32_64: int = 696
"""
``JMP rel32``
``o64 E9 cd``
``X64``
``64-bit``
"""
JMP_PTR1616: int = 697
"""
``JMP ptr16:16``
``o16 EA cd``
``8086+``
``16/32-bit``
"""
JMP_PTR1632: int = 698
"""
``JMP ptr16:32``
``o32 EA cp``
``386+``
``16/32-bit``
"""
JMP_REL8_16: int = 699
"""
``JMP rel8``
``o16 EB cb``
``8086+``
``16/32/64-bit``
"""
JMP_REL8_32: int = 700
"""
``JMP rel8``
``o32 EB cb``
``386+``
``16/32-bit``
"""
JMP_REL8_64: int = 701
"""
``JMP rel8``
``o64 EB cb``
``X64``
``64-bit``
"""
IN_AL_DX: int = 702
"""
``IN AL, DX``
``EC``
``8086+``
``16/32/64-bit``
"""
IN_AX_DX: int = 703
"""
``IN AX, DX``
``o16 ED``
``8086+``
``16/32/64-bit``
"""
IN_EAX_DX: int = 704
"""
``IN EAX, DX``
``o32 ED``
``386+``
``16/32/64-bit``
"""
OUT_DX_AL: int = 705
"""
``OUT DX, AL``
``EE``
``8086+``
``16/32/64-bit``
"""
OUT_DX_AX: int = 706
"""
``OUT DX, AX``
``o16 EF``
``8086+``
``16/32/64-bit``
"""
OUT_DX_EAX: int = 707
"""
``OUT DX, EAX``
``o32 EF``
``386+``
``16/32/64-bit``
"""
INT1: int = 708
"""
``INT1``
``F1``
``386+``
``16/32/64-bit``
"""
HLT: int = 709
"""
``HLT``
``F4``
``8086+``
``16/32/64-bit``
"""
CMC: int = 710
"""
``CMC``
``F5``
``8086+``
``16/32/64-bit``
"""
TEST_RM8_IMM8: int = 711
"""
``TEST r/m8, imm8``
``F6 /0 ib``
``8086+``
``16/32/64-bit``
"""
TEST_RM8_IMM8_F6R1: int = 712
"""
``TEST r/m8, imm8``
``F6 /1 ib``
``8086+``
``16/32/64-bit``
"""
NOT_RM8: int = 713
"""
``NOT r/m8``
``F6 /2``
``8086+``
``16/32/64-bit``
"""
NEG_RM8: int = 714
"""
``NEG r/m8``
``F6 /3``
``8086+``
``16/32/64-bit``
"""
MUL_RM8: int = 715
"""
``MUL r/m8``
``F6 /4``
``8086+``
``16/32/64-bit``
"""
IMUL_RM8: int = 716
"""
``IMUL r/m8``
``F6 /5``
``8086+``
``16/32/64-bit``
"""
DIV_RM8: int = 717
"""
``DIV r/m8``
``F6 /6``
``8086+``
``16/32/64-bit``
"""
IDIV_RM8: int = 718
"""
``IDIV r/m8``
``F6 /7``
``8086+``
``16/32/64-bit``
"""
TEST_RM16_IMM16: int = 719
"""
``TEST r/m16, imm16``
``o16 F7 /0 iw``
``8086+``
``16/32/64-bit``
"""
TEST_RM32_IMM32: int = 720
"""
``TEST r/m32, imm32``
``o32 F7 /0 id``
``386+``
``16/32/64-bit``
"""
TEST_RM64_IMM32: int = 721
"""
``TEST r/m64, imm32``
``o64 F7 /0 id``
``X64``
``64-bit``
"""
TEST_RM16_IMM16_F7R1: int = 722
"""
``TEST r/m16, imm16``
``o16 F7 /1 iw``
``8086+``
``16/32/64-bit``
"""
TEST_RM32_IMM32_F7R1: int = 723
"""
``TEST r/m32, imm32``
``o32 F7 /1 id``
``386+``
``16/32/64-bit``
"""
TEST_RM64_IMM32_F7R1: int = 724
"""
``TEST r/m64, imm32``
``o64 F7 /1 id``
``X64``
``64-bit``
"""
NOT_RM16: int = 725
"""
``NOT r/m16``
``o16 F7 /2``
``8086+``
``16/32/64-bit``
"""
NOT_RM32: int = 726
"""
``NOT r/m32``
``o32 F7 /2``
``386+``
``16/32/64-bit``
"""
NOT_RM64: int = 727
"""
``NOT r/m64``
``o64 F7 /2``
``X64``
``64-bit``
"""
NEG_RM16: int = 728
"""
``NEG r/m16``
``o16 F7 /3``
``8086+``
``16/32/64-bit``
"""
NEG_RM32: int = 729
"""
``NEG r/m32``
``o32 F7 /3``
``386+``
``16/32/64-bit``
"""
NEG_RM64: int = 730
"""
``NEG r/m64``
``o64 F7 /3``
``X64``
``64-bit``
"""
MUL_RM16: int = 731
"""
``MUL r/m16``
``o16 F7 /4``
``8086+``
``16/32/64-bit``
"""
MUL_RM32: int = 732
"""
``MUL r/m32``
``o32 F7 /4``
``386+``
``16/32/64-bit``
"""
MUL_RM64: int = 733
"""
``MUL r/m64``
``o64 F7 /4``
``X64``
``64-bit``
"""
IMUL_RM16: int = 734
"""
``IMUL r/m16``
``o16 F7 /5``
``8086+``
``16/32/64-bit``
"""
IMUL_RM32: int = 735
"""
``IMUL r/m32``
``o32 F7 /5``
``386+``
``16/32/64-bit``
"""
IMUL_RM64: int = 736
"""
``IMUL r/m64``
``o64 F7 /5``
``X64``
``64-bit``
"""
DIV_RM16: int = 737
"""
``DIV r/m16``
``o16 F7 /6``
``8086+``
``16/32/64-bit``
"""
DIV_RM32: int = 738
"""
``DIV r/m32``
``o32 F7 /6``
``386+``
``16/32/64-bit``
"""
DIV_RM64: int = 739
"""
``DIV r/m64``
``o64 F7 /6``
``X64``
``64-bit``
"""
IDIV_RM16: int = 740
"""
``IDIV r/m16``
``o16 F7 /7``
``8086+``
``16/32/64-bit``
"""
IDIV_RM32: int = 741
"""
``IDIV r/m32``
``o32 F7 /7``
``386+``
``16/32/64-bit``
"""
IDIV_RM64: int = 742
"""
``IDIV r/m64``
``o64 F7 /7``
``X64``
``64-bit``
"""
CLC: int = 743
"""
``CLC``
``F8``
``8086+``
``16/32/64-bit``
"""
STC: int = 744
"""
``STC``
``F9``
``8086+``
``16/32/64-bit``
"""
CLI: int = 745
"""
``CLI``
``FA``
``8086+``
``16/32/64-bit``
"""
STI: int = 746
"""
``STI``
``FB``
``8086+``
``16/32/64-bit``
"""
CLD: int = 747
"""
``CLD``
``FC``
``8086+``
``16/32/64-bit``
"""
STD: int = 748
"""
``STD``
``FD``
``8086+``
``16/32/64-bit``
"""
INC_RM8: int = 749
"""
``INC r/m8``
``FE /0``
``8086+``
``16/32/64-bit``
"""
DEC_RM8: int = 750
"""
``DEC r/m8``
``FE /1``
``8086+``
``16/32/64-bit``
"""
INC_RM16: int = 751
"""
``INC r/m16``
``o16 FF /0``
``8086+``
``16/32/64-bit``
"""
INC_RM32: int = 752
"""
``INC r/m32``
``o32 FF /0``
``386+``
``16/32/64-bit``
"""
INC_RM64: int = 753
"""
``INC r/m64``
``o64 FF /0``
``X64``
``64-bit``
"""
DEC_RM16: int = 754
"""
``DEC r/m16``
``o16 FF /1``
``8086+``
``16/32/64-bit``
"""
DEC_RM32: int = 755
"""
``DEC r/m32``
``o32 FF /1``
``386+``
``16/32/64-bit``
"""
DEC_RM64: int = 756
"""
``DEC r/m64``
``o64 FF /1``
``X64``
``64-bit``
"""
CALL_RM16: int = 757
"""
``CALL r/m16``
``o16 FF /2``
``8086+``
``16/32/64-bit``
"""
CALL_RM32: int = 758
"""
``CALL r/m32``
``o32 FF /2``
``386+``
``16/32-bit``
"""
CALL_RM64: int = 759
"""
``CALL r/m64``
``o64 FF /2``
``X64``
``64-bit``
"""
CALL_M1616: int = 760
"""
``CALL m16:16``
``o16 FF /3``
``8086+``
``16/32/64-bit``
"""
CALL_M1632: int = 761
"""
``CALL m16:32``
``o32 FF /3``
``386+``
``16/32/64-bit``
"""
CALL_M1664: int = 762
"""
``CALL m16:64``
``o64 FF /3``
``X64``
``64-bit``
"""
JMP_RM16: int = 763
"""
``JMP r/m16``
``o16 FF /4``
``8086+``
``16/32/64-bit``
"""
JMP_RM32: int = 764
"""
``JMP r/m32``
``o32 FF /4``
``386+``
``16/32-bit``
"""
JMP_RM64: int = 765
"""
``JMP r/m64``
``o64 FF /4``
``X64``
``64-bit``
"""
JMP_M1616: int = 766
"""
``JMP m16:16``
``o16 FF /5``
``8086+``
``16/32/64-bit``
"""
JMP_M1632: int = 767
"""
``JMP m16:32``
``o32 FF /5``
``386+``
``16/32/64-bit``
"""
JMP_M1664: int = 768
"""
``JMP m16:64``
``o64 FF /5``
``X64``
``64-bit``
"""
PUSH_RM16: int = 769
"""
``PUSH r/m16``
``o16 FF /6``
``8086+``
``16/32/64-bit``
"""
PUSH_RM32: int = 770
"""
``PUSH r/m32``
``o32 FF /6``
``386+``
``16/32-bit``
"""
PUSH_RM64: int = 771
"""
``PUSH r/m64``
``o64 FF /6``
``X64``
``64-bit``
"""
SLDT_RM16: int = 772
"""
``SLDT r/m16``
``o16 0F 00 /0``
``286+``
``16/32/64-bit``
"""
SLDT_R32M16: int = 773
"""
``SLDT r32/m16``
``o32 0F 00 /0``
``386+``
``16/32/64-bit``
"""
SLDT_R64M16: int = 774
"""
``SLDT r64/m16``
``o64 0F 00 /0``
``X64``
``64-bit``
"""
STR_RM16: int = 775
"""
``STR r/m16``
``o16 0F 00 /1``
``286+``
``16/32/64-bit``
"""
STR_R32M16: int = 776
"""
``STR r32/m16``
``o32 0F 00 /1``
``386+``
``16/32/64-bit``
"""
STR_R64M16: int = 777
"""
``STR r64/m16``
``o64 0F 00 /1``
``X64``
``64-bit``
"""
LLDT_RM16: int = 778
"""
``LLDT r/m16``
``o16 0F 00 /2``
``286+``
``16/32/64-bit``
"""
LLDT_R32M16: int = 779
"""
``LLDT r32/m16``
``o32 0F 00 /2``
``386+``
``16/32/64-bit``
"""
LLDT_R64M16: int = 780
"""
``LLDT r64/m16``
``o64 0F 00 /2``
``X64``
``64-bit``
"""
LTR_RM16: int = 781
"""
``LTR r/m16``
``o16 0F 00 /3``
``286+``
``16/32/64-bit``
"""
LTR_R32M16: int = 782
"""
``LTR r32/m16``
``o32 0F 00 /3``
``386+``
``16/32/64-bit``
"""
LTR_R64M16: int = 783
"""
``LTR r64/m16``
``o64 0F 00 /3``
``X64``
``64-bit``
"""
VERR_RM16: int = 784
"""
``VERR r/m16``
``o16 0F 00 /4``
``286+``
``16/32/64-bit``
"""
VERR_R32M16: int = 785
"""
``VERR r32/m16``
``o32 0F 00 /4``
``386+``
``16/32/64-bit``
"""
VERR_R64M16: int = 786
"""
``VERR r64/m16``
``o64 0F 00 /4``
``X64``
``64-bit``
"""
VERW_RM16: int = 787
"""
``VERW r/m16``
``o16 0F 00 /5``
``286+``
``16/32/64-bit``
"""
VERW_R32M16: int = 788
"""
``VERW r32/m16``
``o32 0F 00 /5``
``386+``
``16/32/64-bit``
"""
VERW_R64M16: int = 789
"""
``VERW r64/m16``
``o64 0F 00 /5``
``X64``
``64-bit``
"""
JMPE_RM16: int = 790
"""
``JMPE r/m16``
``o16 0F 00 /6``
``IA-64``
``16/32-bit``
"""
JMPE_RM32: int = 791
"""
``JMPE r/m32``
``o32 0F 00 /6``
``IA-64``
``16/32-bit``
"""
SGDT_M1632_16: int = 792
"""
``SGDT m``
``o16 0F 01 /0``
``286+``
``16/32-bit``
"""
SGDT_M1632: int = 793
"""
``SGDT m``
``o32 0F 01 /0``
``386+``
``16/32-bit``
"""
SGDT_M1664: int = 794
"""
``SGDT m``
``0F 01 /0``
``X64``
``64-bit``
"""
SIDT_M1632_16: int = 795
"""
``SIDT m``
``o16 0F 01 /1``
``286+``
``16/32-bit``
"""
SIDT_M1632: int = 796
"""
``SIDT m``
``o32 0F 01 /1``
``386+``
``16/32-bit``
"""
SIDT_M1664: int = 797
"""
``SIDT m``
``0F 01 /1``
``X64``
``64-bit``
"""
LGDT_M1632_16: int = 798
"""
``LGDT m16&32``
``o16 0F 01 /2``
``286+``
``16/32-bit``
"""
LGDT_M1632: int = 799
"""
``LGDT m16&32``
``o32 0F 01 /2``
``386+``
``16/32-bit``
"""
LGDT_M1664: int = 800
"""
``LGDT m16&64``
``0F 01 /2``
``X64``
``64-bit``
"""
LIDT_M1632_16: int = 801
"""
``LIDT m16&32``
``o16 0F 01 /3``
``286+``
``16/32-bit``
"""
LIDT_M1632: int = 802
"""
``LIDT m16&32``
``o32 0F 01 /3``
``386+``
``16/32-bit``
"""
LIDT_M1664: int = 803
"""
``LIDT m16&64``
``0F 01 /3``
``X64``
``64-bit``
"""
SMSW_RM16: int = 804
"""
``SMSW r/m16``
``o16 0F 01 /4``
``286+``
``16/32/64-bit``
"""
SMSW_R32M16: int = 805
"""
``SMSW r32/m16``
``o32 0F 01 /4``
``386+``
``16/32/64-bit``
"""
SMSW_R64M16: int = 806
"""
``SMSW r64/m16``
``o64 0F 01 /4``
``X64``
``64-bit``
"""
RSTORSSP_M64: int = 807
"""
``RSTORSSP m64``
``F3 0F 01 /5``
``CET_SS``
``16/32/64-bit``
"""
LMSW_RM16: int = 808
"""
``LMSW r/m16``
``o16 0F 01 /6``
``286+``
``16/32/64-bit``
"""
LMSW_R32M16: int = 809
"""
``LMSW r32/m16``
``o32 0F 01 /6``
``386+``
``16/32/64-bit``
"""
LMSW_R64M16: int = 810
"""
``LMSW r64/m16``
``o64 0F 01 /6``
``X64``
``64-bit``
"""
INVLPG_M: int = 811
"""
``INVLPG m``
``0F 01 /7``
``486+``
``16/32/64-bit``
"""
ENCLV: int = 812
"""
``ENCLV``
``NP 0F 01 C0``
``OSS``
``16/32/64-bit``
"""
VMCALL: int = 813
"""
``VMCALL``
``NP 0F 01 C1``
``VMX``
``16/32/64-bit``
"""
VMLAUNCH: int = 814
"""
``VMLAUNCH``
``NP 0F 01 C2``
``VMX``
``16/32/64-bit``
"""
VMRESUME: int = 815
"""
``VMRESUME``
``NP 0F 01 C3``
``VMX``
``16/32/64-bit``
"""
VMXOFF: int = 816
"""
``VMXOFF``
``NP 0F 01 C4``
``VMX``
``16/32/64-bit``
"""
PCONFIG: int = 817
"""
``PCONFIG``
``NP 0F 01 C5``
``PCONFIG``
``16/32/64-bit``
"""
MONITORW: int = 818
"""
``MONITOR``
``a16 NP 0F 01 C8``
``MONITOR``
``16/32-bit``
"""
MONITORD: int = 819
"""
``MONITOR``
``a32 NP 0F 01 C8``
``MONITOR``
``16/32/64-bit``
"""
MONITORQ: int = 820
"""
``MONITOR``
``a64 NP 0F 01 C8``
``MONITOR``
``64-bit``
"""
MWAIT: int = 821
"""
``MWAIT``
``NP 0F 01 C9``
``MONITOR``
``16/32/64-bit``
"""
CLAC: int = 822
"""
``CLAC``
``NP 0F 01 CA``
``SMAP``
``16/32/64-bit``
"""
STAC: int = 823
"""
``STAC``
``NP 0F 01 CB``
``SMAP``
``16/32/64-bit``
"""
ENCLS: int = 824
"""
``ENCLS``
``NP 0F 01 CF``
``SGX1``
``16/32/64-bit``
"""
XGETBV: int = 825
"""
``XGETBV``
``NP 0F 01 D0``
``XSAVE``
``16/32/64-bit``
"""
XSETBV: int = 826
"""
``XSETBV``
``NP 0F 01 D1``
``XSAVE``
``16/32/64-bit``
"""
VMFUNC: int = 827
"""
``VMFUNC``
``NP 0F 01 D4``
``VMX``
``16/32/64-bit``
"""
XEND: int = 828
"""
``XEND``
``NP 0F 01 D5``
``RTM``
``16/32/64-bit``
"""
XTEST: int = 829
"""
``XTEST``
``NP 0F 01 D6``
``HLE or RTM``
``16/32/64-bit``
"""
ENCLU: int = 830
"""
``ENCLU``
``NP 0F 01 D7``
``SGX1``
``16/32/64-bit``
"""
VMRUNW: int = 831
"""
``VMRUN``
``a16 0F 01 D8``
``SVM``
``16/32-bit``
"""
VMRUND: int = 832
"""
``VMRUN``
``a32 0F 01 D8``
``SVM``
``16/32/64-bit``
"""
VMRUNQ: int = 833
"""
``VMRUN``
``a64 0F 01 D8``
``SVM``
``64-bit``
"""
VMMCALL: int = 834
"""
``VMMCALL``
``0F 01 D9``
``SVM``
``16/32/64-bit``
"""
VMLOADW: int = 835
"""
``VMLOAD``
``a16 0F 01 DA``
``SVM``
``16/32-bit``
"""
VMLOADD: int = 836
"""
``VMLOAD``
``a32 0F 01 DA``
``SVM``
``16/32/64-bit``
"""
VMLOADQ: int = 837
"""
``VMLOAD``
``a64 0F 01 DA``
``SVM``
``64-bit``
"""
VMSAVEW: int = 838
"""
``VMSAVE``
``a16 0F 01 DB``
``SVM``
``16/32-bit``
"""
VMSAVED: int = 839
"""
``VMSAVE``
``a32 0F 01 DB``
``SVM``
``16/32/64-bit``
"""
VMSAVEQ: int = 840
"""
``VMSAVE``
``a64 0F 01 DB``
``SVM``
``64-bit``
"""
STGI: int = 841
"""
``STGI``
``0F 01 DC``
``SKINIT or SVM``
``16/32/64-bit``
"""
CLGI: int = 842
"""
``CLGI``
``0F 01 DD``
``SVM``
``16/32/64-bit``
"""
SKINIT: int = 843
"""
``SKINIT``
``0F 01 DE``
``SKINIT or SVM``
``16/32/64-bit``
"""
INVLPGAW: int = 844
"""
``INVLPGA``
``a16 0F 01 DF``
``SVM``
``16/32-bit``
"""
INVLPGAD: int = 845
"""
``INVLPGA``
``a32 0F 01 DF``
``SVM``
``16/32/64-bit``
"""
INVLPGAQ: int = 846
"""
``INVLPGA``
``a64 0F 01 DF``
``SVM``
``64-bit``
"""
SETSSBSY: int = 847
"""
``SETSSBSY``
``F3 0F 01 E8``
``CET_SS``
``16/32/64-bit``
"""
SAVEPREVSSP: int = 848
"""
``SAVEPREVSSP``
``F3 0F 01 EA``
``CET_SS``
``16/32/64-bit``
"""
RDPKRU: int = 849
"""
``RDPKRU``
``NP 0F 01 EE``
``PKU``
``16/32/64-bit``
"""
WRPKRU: int = 850
"""
``WRPKRU``
``NP 0F 01 EF``
``PKU``
``16/32/64-bit``
"""
SWAPGS: int = 851
"""
``SWAPGS``
``0F 01 F8``
``X64``
``64-bit``
"""
RDTSCP: int = 852
"""
``RDTSCP``
``0F 01 F9``
``RDTSCP``
``16/32/64-bit``
"""
MONITORXW: int = 853
"""
``MONITORX``
``a16 NP 0F 01 FA``
``MONITORX``
``16/32-bit``
"""
MONITORXD: int = 854
"""
``MONITORX``
``a32 NP 0F 01 FA``
``MONITORX``
``16/32/64-bit``
"""
MONITORXQ: int = 855
"""
``MONITORX``
``a64 NP 0F 01 FA``
``MONITORX``
``64-bit``
"""
MCOMMIT: int = 856
"""
``MCOMMIT``
``F3 0F 01 FA``
``MCOMMIT``
``16/32/64-bit``
"""
MWAITX: int = 857
"""
``MWAITX``
``NP 0F 01 FB``
``MONITORX``
``16/32/64-bit``
"""
CLZEROW: int = 858
"""
``CLZERO``
``a16 0F 01 FC``
``CLZERO``
``16/32-bit``
"""
CLZEROD: int = 859
"""
``CLZERO``
``a32 0F 01 FC``
``CLZERO``
``16/32/64-bit``
"""
CLZEROQ: int = 860
"""
``CLZERO``
``a64 0F 01 FC``
``CLZERO``
``64-bit``
"""
RDPRU: int = 861
"""
``RDPRU``
``0F 01 FD``
``RDPRU``
``16/32/64-bit``
"""
LAR_R16_RM16: int = 862
"""
``LAR r16, r/m16``
``o16 0F 02 /r``
``286+``
``16/32/64-bit``
"""
LAR_R32_R32M16: int = 863
"""
``LAR r32, r32/m16``
``o32 0F 02 /r``
``386+``
``16/32/64-bit``
"""
LAR_R64_R64M16: int = 864
"""
``LAR r64, r64/m16``
``o64 0F 02 /r``
``X64``
``64-bit``
"""
LSL_R16_RM16: int = 865
"""
``LSL r16, r/m16``
``o16 0F 03 /r``
``286+``
``16/32/64-bit``
"""
LSL_R32_R32M16: int = 866
"""
``LSL r32, r32/m16``
``o32 0F 03 /r``
``386+``
``16/32/64-bit``
"""
LSL_R64_R64M16: int = 867
"""
``LSL r64, r64/m16``
``o64 0F 03 /r``
``X64``
``64-bit``
"""
STOREALL: int = 868
"""
``STOREALL``
``0F 04``
``286``
``16/32-bit``
"""
LOADALL286: int = 869
"""
``LOADALL``
``0F 05``
``286``
``16/32-bit``
"""
SYSCALL: int = 870
"""
``SYSCALL``
``0F 05``
``SYSCALL``
``16/32/64-bit``
"""
CLTS: int = 871
"""
``CLTS``
``0F 06``
``286+``
``16/32/64-bit``
"""
LOADALL386: int = 872
"""
``LOADALL``
``0F 07``
``386``
``16/32-bit``
"""
SYSRETD: int = 873
"""
``SYSRET``
``0F 07``
``SYSCALL``
``16/32/64-bit``
"""
SYSRETQ: int = 874
"""
``SYSRETQ``
``o64 0F 07``
``SYSCALL``
``64-bit``
"""
INVD: int = 875
"""
``INVD``
``0F 08``
``486+``
``16/32/64-bit``
"""
WBINVD: int = 876
"""
``WBINVD``
``0F 09``
``486+``
``16/32/64-bit``
"""
WBNOINVD: int = 877
"""
``WBNOINVD``
``F3 0F 09``
``WBNOINVD``
``16/32/64-bit``
"""
CL1INVMB: int = 878
"""
``CL1INVMB``
``0F 0A``
``CL1INVMB``
``16/32-bit``
"""
UD2: int = 879
"""
``UD2``
``0F 0B``
``286+``
``16/32/64-bit``
"""
RESERVEDNOP_RM16_R16_0F0D: int = 880
"""
``RESERVEDNOP r/m16, r16``
``o16 0F 0D /r``
``CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B``
``16/32/64-bit``
"""
RESERVEDNOP_RM32_R32_0F0D: int = 881
"""
``RESERVEDNOP r/m32, r32``
``o32 0F 0D /r``
``CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B``
``16/32/64-bit``
"""
RESERVEDNOP_RM64_R64_0F0D: int = 882
"""
``RESERVEDNOP r/m64, r64``
``o64 0F 0D /r``
``CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B``
``64-bit``
"""
PREFETCH_M8: int = 883
"""
``PREFETCH m8``
``0F 0D /0``
``PREFETCHW``
``16/32/64-bit``
"""
PREFETCHW_M8: int = 884
"""
``PREFETCHW m8``
``0F 0D /1``
``PREFETCHW``
``16/32/64-bit``
"""
PREFETCHWT1_M8: int = 885
"""
``PREFETCHWT1 m8``
``0F 0D /2``
``PREFETCHWT1``
``16/32/64-bit``
"""
FEMMS: int = 886
"""
``FEMMS``
``0F 0E``
``3DNOW``
``16/32/64-bit``
"""
UMOV_RM8_R8: int = 887
"""
``UMOV r/m8, r8``
``0F 10 /r``
``386/486``
``16/32-bit``
"""
UMOV_RM16_R16: int = 888
"""
``UMOV r/m16, r16``
``o16 0F 11 /r``
``386/486``
``16/32-bit``
"""
UMOV_RM32_R32: int = 889
"""
``UMOV r/m32, r32``
``o32 0F 11 /r``
``386/486``
``16/32-bit``
"""
UMOV_R8_RM8: int = 890
"""
``UMOV r8, r/m8``
``0F 12 /r``
``386/486``
``16/32-bit``
"""
UMOV_R16_RM16: int = 891
"""
``UMOV r16, r/m16``
``o16 0F 13 /r``
``386/486``
``16/32-bit``
"""
UMOV_R32_RM32: int = 892
"""
``UMOV r32, r/m32``
``o32 0F 13 /r``
``386/486``
``16/32-bit``
"""
MOVUPS_XMM_XMMM128: int = 893
"""
``MOVUPS xmm1, xmm2/m128``
``NP 0F 10 /r``
``SSE``
``16/32/64-bit``
"""
VEX_VMOVUPS_XMM_XMMM128: int = 894
"""
``VMOVUPS xmm1, xmm2/m128``
``VEX.128.0F.WIG 10 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VMOVUPS_YMM_YMMM256: int = 895
"""
``VMOVUPS ymm1, ymm2/m256``
``VEX.256.0F.WIG 10 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMOVUPS_XMM_K1Z_XMMM128: int = 896
"""
``VMOVUPS xmm1 {k1}{z}, xmm2/m128``
``EVEX.128.0F.W0 10 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVUPS_YMM_K1Z_YMMM256: int = 897
"""
``VMOVUPS ymm1 {k1}{z}, ymm2/m256``
``EVEX.256.0F.W0 10 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVUPS_ZMM_K1Z_ZMMM512: int = 898
"""
``VMOVUPS zmm1 {k1}{z}, zmm2/m512``
``EVEX.512.0F.W0 10 /r``
``AVX512F``
``16/32/64-bit``
"""
MOVUPD_XMM_XMMM128: int = 899
"""
``MOVUPD xmm1, xmm2/m128``
``66 0F 10 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VMOVUPD_XMM_XMMM128: int = 900
"""
``VMOVUPD xmm1, xmm2/m128``
``VEX.128.66.0F.WIG 10 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VMOVUPD_YMM_YMMM256: int = 901
"""
``VMOVUPD ymm1, ymm2/m256``
``VEX.256.66.0F.WIG 10 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMOVUPD_XMM_K1Z_XMMM128: int = 902
"""
``VMOVUPD xmm1 {k1}{z}, xmm2/m128``
``EVEX.128.66.0F.W1 10 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVUPD_YMM_K1Z_YMMM256: int = 903
"""
``VMOVUPD ymm1 {k1}{z}, ymm2/m256``
``EVEX.256.66.0F.W1 10 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVUPD_ZMM_K1Z_ZMMM512: int = 904
"""
``VMOVUPD zmm1 {k1}{z}, zmm2/m512``
``EVEX.512.66.0F.W1 10 /r``
``AVX512F``
``16/32/64-bit``
"""
MOVSS_XMM_XMMM32: int = 905
"""
``MOVSS xmm1, xmm2/m32``
``F3 0F 10 /r``
``SSE``
``16/32/64-bit``
"""
VEX_VMOVSS_XMM_XMM_XMM: int = 906
"""
``VMOVSS xmm1, xmm2, xmm3``
``VEX.LIG.F3.0F.WIG 10 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VMOVSS_XMM_M32: int = 907
"""
``VMOVSS xmm1, m32``
``VEX.LIG.F3.0F.WIG 10 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMOVSS_XMM_K1Z_XMM_XMM: int = 908
"""
``VMOVSS xmm1 {k1}{z}, xmm2, xmm3``
``EVEX.LIG.F3.0F.W0 10 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVSS_XMM_K1Z_M32: int = 909
"""
``VMOVSS xmm1 {k1}{z}, m32``
``EVEX.LIG.F3.0F.W0 10 /r``
``AVX512F``
``16/32/64-bit``
"""
MOVSD_XMM_XMMM64: int = 910
"""
``MOVSD xmm1, xmm2/m64``
``F2 0F 10 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VMOVSD_XMM_XMM_XMM: int = 911
"""
``VMOVSD xmm1, xmm2, xmm3``
``VEX.LIG.F2.0F.WIG 10 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VMOVSD_XMM_M64: int = 912
"""
``VMOVSD xmm1, m64``
``VEX.LIG.F2.0F.WIG 10 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMOVSD_XMM_K1Z_XMM_XMM: int = 913
"""
``VMOVSD xmm1 {k1}{z}, xmm2, xmm3``
``EVEX.LIG.F2.0F.W1 10 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVSD_XMM_K1Z_M64: int = 914
"""
``VMOVSD xmm1 {k1}{z}, m64``
``EVEX.LIG.F2.0F.W1 10 /r``
``AVX512F``
``16/32/64-bit``
"""
MOVUPS_XMMM128_XMM: int = 915
"""
``MOVUPS xmm2/m128, xmm1``
``NP 0F 11 /r``
``SSE``
``16/32/64-bit``
"""
VEX_VMOVUPS_XMMM128_XMM: int = 916
"""
``VMOVUPS xmm2/m128, xmm1``
``VEX.128.0F.WIG 11 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VMOVUPS_YMMM256_YMM: int = 917
"""
``VMOVUPS ymm2/m256, ymm1``
``VEX.256.0F.WIG 11 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMOVUPS_XMMM128_K1Z_XMM: int = 918
"""
``VMOVUPS xmm2/m128 {k1}{z}, xmm1``
``EVEX.128.0F.W0 11 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVUPS_YMMM256_K1Z_YMM: int = 919
"""
``VMOVUPS ymm2/m256 {k1}{z}, ymm1``
``EVEX.256.0F.W0 11 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVUPS_ZMMM512_K1Z_ZMM: int = 920
"""
``VMOVUPS zmm2/m512 {k1}{z}, zmm1``
``EVEX.512.0F.W0 11 /r``
``AVX512F``
``16/32/64-bit``
"""
MOVUPD_XMMM128_XMM: int = 921
"""
``MOVUPD xmm2/m128, xmm1``
``66 0F 11 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VMOVUPD_XMMM128_XMM: int = 922
"""
``VMOVUPD xmm2/m128, xmm1``
``VEX.128.66.0F.WIG 11 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VMOVUPD_YMMM256_YMM: int = 923
"""
``VMOVUPD ymm2/m256, ymm1``
``VEX.256.66.0F.WIG 11 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMOVUPD_XMMM128_K1Z_XMM: int = 924
"""
``VMOVUPD xmm2/m128 {k1}{z}, xmm1``
``EVEX.128.66.0F.W1 11 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVUPD_YMMM256_K1Z_YMM: int = 925
"""
``VMOVUPD ymm2/m256 {k1}{z}, ymm1``
``EVEX.256.66.0F.W1 11 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVUPD_ZMMM512_K1Z_ZMM: int = 926
"""
``VMOVUPD zmm2/m512 {k1}{z}, zmm1``
``EVEX.512.66.0F.W1 11 /r``
``AVX512F``
``16/32/64-bit``
"""
MOVSS_XMMM32_XMM: int = 927
"""
``MOVSS xmm2/m32, xmm1``
``F3 0F 11 /r``
``SSE``
``16/32/64-bit``
"""
VEX_VMOVSS_XMM_XMM_XMM_0F11: int = 928
"""
``VMOVSS xmm1, xmm2, xmm3``
``VEX.LIG.F3.0F.WIG 11 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VMOVSS_M32_XMM: int = 929
"""
``VMOVSS m32, xmm1``
``VEX.LIG.F3.0F.WIG 11 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMOVSS_XMM_K1Z_XMM_XMM_0F11: int = 930
"""
``VMOVSS xmm1 {k1}{z}, xmm2, xmm3``
``EVEX.LIG.F3.0F.W0 11 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVSS_M32_K1_XMM: int = 931
"""
``VMOVSS m32 {k1}, xmm1``
``EVEX.LIG.F3.0F.W0 11 /r``
``AVX512F``
``16/32/64-bit``
"""
MOVSD_XMMM64_XMM: int = 932
"""
``MOVSD xmm1/m64, xmm2``
``F2 0F 11 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VMOVSD_XMM_XMM_XMM_0F11: int = 933
"""
``VMOVSD xmm1, xmm2, xmm3``
``VEX.LIG.F2.0F.WIG 11 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VMOVSD_M64_XMM: int = 934
"""
``VMOVSD m64, xmm1``
``VEX.LIG.F2.0F.WIG 11 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMOVSD_XMM_K1Z_XMM_XMM_0F11: int = 935
"""
``VMOVSD xmm1 {k1}{z}, xmm2, xmm3``
``EVEX.LIG.F2.0F.W1 11 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVSD_M64_K1_XMM: int = 936
"""
``VMOVSD m64 {k1}, xmm1``
``EVEX.LIG.F2.0F.W1 11 /r``
``AVX512F``
``16/32/64-bit``
"""
MOVHLPS_XMM_XMM: int = 937
"""
``MOVHLPS xmm1, xmm2``
``NP 0F 12 /r``
``SSE``
``16/32/64-bit``
"""
MOVLPS_XMM_M64: int = 938
"""
``MOVLPS xmm1, m64``
``NP 0F 12 /r``
``SSE``
``16/32/64-bit``
"""
VEX_VMOVHLPS_XMM_XMM_XMM: int = 939
"""
``VMOVHLPS xmm1, xmm2, xmm3``
``VEX.128.0F.WIG 12 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VMOVLPS_XMM_XMM_M64: int = 940
"""
``VMOVLPS xmm2, xmm1, m64``
``VEX.128.0F.WIG 12 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMOVHLPS_XMM_XMM_XMM: int = 941
"""
``VMOVHLPS xmm1, xmm2, xmm3``
``EVEX.128.0F.W0 12 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVLPS_XMM_XMM_M64: int = 942
"""
``VMOVLPS xmm2, xmm1, m64``
``EVEX.128.0F.W0 12 /r``
``AVX512F``
``16/32/64-bit``
"""
MOVLPD_XMM_M64: int = 943
"""
``MOVLPD xmm1, m64``
``66 0F 12 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VMOVLPD_XMM_XMM_M64: int = 944
"""
``VMOVLPD xmm2, xmm1, m64``
``VEX.128.66.0F.WIG 12 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMOVLPD_XMM_XMM_M64: int = 945
"""
``VMOVLPD xmm2, xmm1, m64``
``EVEX.128.66.0F.W1 12 /r``
``AVX512F``
``16/32/64-bit``
"""
MOVSLDUP_XMM_XMMM128: int = 946
"""
``MOVSLDUP xmm1, xmm2/m128``
``F3 0F 12 /r``
``SSE3``
``16/32/64-bit``
"""
VEX_VMOVSLDUP_XMM_XMMM128: int = 947
"""
``VMOVSLDUP xmm1, xmm2/m128``
``VEX.128.F3.0F.WIG 12 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VMOVSLDUP_YMM_YMMM256: int = 948
"""
``VMOVSLDUP ymm1, ymm2/m256``
``VEX.256.F3.0F.WIG 12 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMOVSLDUP_XMM_K1Z_XMMM128: int = 949
"""
``VMOVSLDUP xmm1 {k1}{z}, xmm2/m128``
``EVEX.128.F3.0F.W0 12 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVSLDUP_YMM_K1Z_YMMM256: int = 950
"""
``VMOVSLDUP ymm1 {k1}{z}, ymm2/m256``
``EVEX.256.F3.0F.W0 12 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVSLDUP_ZMM_K1Z_ZMMM512: int = 951
"""
``VMOVSLDUP zmm1 {k1}{z}, zmm2/m512``
``EVEX.512.F3.0F.W0 12 /r``
``AVX512F``
``16/32/64-bit``
"""
MOVDDUP_XMM_XMMM64: int = 952
"""
``MOVDDUP xmm1, xmm2/m64``
``F2 0F 12 /r``
``SSE3``
``16/32/64-bit``
"""
VEX_VMOVDDUP_XMM_XMMM64: int = 953
"""
``VMOVDDUP xmm1, xmm2/m64``
``VEX.128.F2.0F.WIG 12 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VMOVDDUP_YMM_YMMM256: int = 954
"""
``VMOVDDUP ymm1, ymm2/m256``
``VEX.256.F2.0F.WIG 12 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMOVDDUP_XMM_K1Z_XMMM64: int = 955
"""
``VMOVDDUP xmm1 {k1}{z}, xmm2/m64``
``EVEX.128.F2.0F.W1 12 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVDDUP_YMM_K1Z_YMMM256: int = 956
"""
``VMOVDDUP ymm1 {k1}{z}, ymm2/m256``
``EVEX.256.F2.0F.W1 12 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVDDUP_ZMM_K1Z_ZMMM512: int = 957
"""
``VMOVDDUP zmm1 {k1}{z}, zmm2/m512``
``EVEX.512.F2.0F.W1 12 /r``
``AVX512F``
``16/32/64-bit``
"""
MOVLPS_M64_XMM: int = 958
"""
``MOVLPS m64, xmm1``
``NP 0F 13 /r``
``SSE``
``16/32/64-bit``
"""
VEX_VMOVLPS_M64_XMM: int = 959
"""
``VMOVLPS m64, xmm1``
``VEX.128.0F.WIG 13 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMOVLPS_M64_XMM: int = 960
"""
``VMOVLPS m64, xmm1``
``EVEX.128.0F.W0 13 /r``
``AVX512F``
``16/32/64-bit``
"""
MOVLPD_M64_XMM: int = 961
"""
``MOVLPD m64, xmm1``
``66 0F 13 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VMOVLPD_M64_XMM: int = 962
"""
``VMOVLPD m64, xmm1``
``VEX.128.66.0F.WIG 13 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMOVLPD_M64_XMM: int = 963
"""
``VMOVLPD m64, xmm1``
``EVEX.128.66.0F.W1 13 /r``
``AVX512F``
``16/32/64-bit``
"""
UNPCKLPS_XMM_XMMM128: int = 964
"""
``UNPCKLPS xmm1, xmm2/m128``
``NP 0F 14 /r``
``SSE``
``16/32/64-bit``
"""
VEX_VUNPCKLPS_XMM_XMM_XMMM128: int = 965
"""
``VUNPCKLPS xmm1, xmm2, xmm3/m128``
``VEX.128.0F.WIG 14 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VUNPCKLPS_YMM_YMM_YMMM256: int = 966
"""
``VUNPCKLPS ymm1, ymm2, ymm3/m256``
``VEX.256.0F.WIG 14 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VUNPCKLPS_XMM_K1Z_XMM_XMMM128B32: int = 967
"""
``VUNPCKLPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.0F.W0 14 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VUNPCKLPS_YMM_K1Z_YMM_YMMM256B32: int = 968
"""
``VUNPCKLPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.0F.W0 14 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VUNPCKLPS_ZMM_K1Z_ZMM_ZMMM512B32: int = 969
"""
``VUNPCKLPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.0F.W0 14 /r``
``AVX512F``
``16/32/64-bit``
"""
UNPCKLPD_XMM_XMMM128: int = 970
"""
``UNPCKLPD xmm1, xmm2/m128``
``66 0F 14 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VUNPCKLPD_XMM_XMM_XMMM128: int = 971
"""
``VUNPCKLPD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG 14 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VUNPCKLPD_YMM_YMM_YMMM256: int = 972
"""
``VUNPCKLPD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG 14 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VUNPCKLPD_XMM_K1Z_XMM_XMMM128B64: int = 973
"""
``VUNPCKLPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F.W1 14 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VUNPCKLPD_YMM_K1Z_YMM_YMMM256B64: int = 974
"""
``VUNPCKLPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F.W1 14 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VUNPCKLPD_ZMM_K1Z_ZMM_ZMMM512B64: int = 975
"""
``VUNPCKLPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F.W1 14 /r``
``AVX512F``
``16/32/64-bit``
"""
UNPCKHPS_XMM_XMMM128: int = 976
"""
``UNPCKHPS xmm1, xmm2/m128``
``NP 0F 15 /r``
``SSE``
``16/32/64-bit``
"""
VEX_VUNPCKHPS_XMM_XMM_XMMM128: int = 977
"""
``VUNPCKHPS xmm1, xmm2, xmm3/m128``
``VEX.128.0F.WIG 15 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VUNPCKHPS_YMM_YMM_YMMM256: int = 978
"""
``VUNPCKHPS ymm1, ymm2, ymm3/m256``
``VEX.256.0F.WIG 15 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VUNPCKHPS_XMM_K1Z_XMM_XMMM128B32: int = 979
"""
``VUNPCKHPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.0F.W0 15 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VUNPCKHPS_YMM_K1Z_YMM_YMMM256B32: int = 980
"""
``VUNPCKHPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.0F.W0 15 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VUNPCKHPS_ZMM_K1Z_ZMM_ZMMM512B32: int = 981
"""
``VUNPCKHPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.0F.W0 15 /r``
``AVX512F``
``16/32/64-bit``
"""
UNPCKHPD_XMM_XMMM128: int = 982
"""
``UNPCKHPD xmm1, xmm2/m128``
``66 0F 15 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VUNPCKHPD_XMM_XMM_XMMM128: int = 983
"""
``VUNPCKHPD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG 15 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VUNPCKHPD_YMM_YMM_YMMM256: int = 984
"""
``VUNPCKHPD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG 15 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VUNPCKHPD_XMM_K1Z_XMM_XMMM128B64: int = 985
"""
``VUNPCKHPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F.W1 15 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VUNPCKHPD_YMM_K1Z_YMM_YMMM256B64: int = 986
"""
``VUNPCKHPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F.W1 15 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VUNPCKHPD_ZMM_K1Z_ZMM_ZMMM512B64: int = 987
"""
``VUNPCKHPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F.W1 15 /r``
``AVX512F``
``16/32/64-bit``
"""
MOVLHPS_XMM_XMM: int = 988
"""
``MOVLHPS xmm1, xmm2``
``NP 0F 16 /r``
``SSE``
``16/32/64-bit``
"""
VEX_VMOVLHPS_XMM_XMM_XMM: int = 989
"""
``VMOVLHPS xmm1, xmm2, xmm3``
``VEX.128.0F.WIG 16 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMOVLHPS_XMM_XMM_XMM: int = 990
"""
``VMOVLHPS xmm1, xmm2, xmm3``
``EVEX.128.0F.W0 16 /r``
``AVX512F``
``16/32/64-bit``
"""
MOVHPS_XMM_M64: int = 991
"""
``MOVHPS xmm1, m64``
``NP 0F 16 /r``
``SSE``
``16/32/64-bit``
"""
VEX_VMOVHPS_XMM_XMM_M64: int = 992
"""
``VMOVHPS xmm2, xmm1, m64``
``VEX.128.0F.WIG 16 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMOVHPS_XMM_XMM_M64: int = 993
"""
``VMOVHPS xmm2, xmm1, m64``
``EVEX.128.0F.W0 16 /r``
``AVX512F``
``16/32/64-bit``
"""
MOVHPD_XMM_M64: int = 994
"""
``MOVHPD xmm1, m64``
``66 0F 16 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VMOVHPD_XMM_XMM_M64: int = 995
"""
``VMOVHPD xmm2, xmm1, m64``
``VEX.128.66.0F.WIG 16 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMOVHPD_XMM_XMM_M64: int = 996
"""
``VMOVHPD xmm2, xmm1, m64``
``EVEX.128.66.0F.W1 16 /r``
``AVX512F``
``16/32/64-bit``
"""
MOVSHDUP_XMM_XMMM128: int = 997
"""
``MOVSHDUP xmm1, xmm2/m128``
|
``F3 0F 16 /r``
``SSE3``
``16/32/64-bit``
"""
VEX_VMOVSHDUP_XMM_XMMM128: int = 998
"""
``VMOVSHDUP xmm1, xmm2/m128``
``VEX.128.F3.0F.WIG 16 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VMOVSHDUP_YMM_YMMM256: int = 999
"""
``VMOVSHDUP ymm1, ymm2/m256``
``VEX.256.F3.0F.WIG 16 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMOVSHDUP_XMM_K1Z_XMMM128: int = 1000
"""
``VMOVSHDUP xmm1 {k1}{z}, xmm2/m128``
``EVEX.128.F3.0F.W0 16 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVSHDUP_YMM_K1Z_YMMM256: int = 1001
"""
``VMOVSHDUP ymm1 {k1}{z}, ymm2/m256``
``EVEX.256.F3.0F.W0 16 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVSHDUP_ZMM_K1Z_ZMMM512: int = 1002
"""
``VMOVSHDUP zmm1 {k1}{z}, zmm2/m512``
``EVEX.512.F3.0F.W0 16 /r``
``AVX512F``
``16/32/64-bit``
"""
MOVHPS_M64_XMM: int = 1003
"""
``MOVHPS m64, xmm1``
``NP 0F 17 /r``
``SSE``
``16/32/64-bit``
"""
VEX_VMOVHPS_M64_XMM: int = 1004
"""
``VMOVHPS m64, xmm1``
``VEX.128.0F.WIG 17 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMOVHPS_M64_XMM: int = 1005
"""
``VMOVHPS m64, xmm1``
``EVEX.128.0F.W0 17 /r``
``AVX512F``
``16/32/64-bit``
"""
MOVHPD_M64_XMM: int = 1006
"""
``MOVHPD m64, xmm1``
``66 0F 17 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VMOVHPD_M64_XMM: int = 1007
"""
``VMOVHPD m64, xmm1``
``VEX.128.66.0F.WIG 17 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMOVHPD_M64_XMM: int = 1008
"""
``VMOVHPD m64, xmm1``
``EVEX.128.66.0F.W1 17 /r``
``AVX512F``
``16/32/64-bit``
"""
RESERVEDNOP_RM16_R16_0F18: int = 1009
"""
``RESERVEDNOP r/m16, r16``
``o16 0F 18 /r``
``CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B``
``16/32/64-bit``
"""
RESERVEDNOP_RM32_R32_0F18: int = 1010
"""
``RESERVEDNOP r/m32, r32``
``o32 0F 18 /r``
``CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B``
``16/32/64-bit``
"""
RESERVEDNOP_RM64_R64_0F18: int = 1011
"""
``RESERVEDNOP r/m64, r64``
``o64 0F 18 /r``
``CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B``
``64-bit``
"""
RESERVEDNOP_RM16_R16_0F19: int = 1012
"""
``RESERVEDNOP r/m16, r16``
``o16 0F 19 /r``
``CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B``
``16/32/64-bit``
"""
RESERVEDNOP_RM32_R32_0F19: int = 1013
"""
``RESERVEDNOP r/m32, r32``
``o32 0F 19 /r``
``CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B``
``16/32/64-bit``
"""
RESERVEDNOP_RM64_R64_0F19: int = 1014
"""
``RESERVEDNOP r/m64, r64``
``o64 0F 19 /r``
``CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B``
``64-bit``
"""
RESERVEDNOP_RM16_R16_0F1A: int = 1015
"""
``RESERVEDNOP r/m16, r16``
``o16 0F 1A /r``
``CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B``
``16/32/64-bit``
"""
RESERVEDNOP_RM32_R32_0F1A: int = 1016
"""
``RESERVEDNOP r/m32, r32``
``o32 0F 1A /r``
``CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B``
``16/32/64-bit``
"""
RESERVEDNOP_RM64_R64_0F1A: int = 1017
"""
``RESERVEDNOP r/m64, r64``
``o64 0F 1A /r``
``CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B``
``64-bit``
"""
RESERVEDNOP_RM16_R16_0F1B: int = 1018
"""
``RESERVEDNOP r/m16, r16``
``o16 0F 1B /r``
``CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B``
``16/32/64-bit``
"""
RESERVEDNOP_RM32_R32_0F1B: int = 1019
"""
``RESERVEDNOP r/m32, r32``
``o32 0F 1B /r``
``CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B``
``16/32/64-bit``
"""
RESERVEDNOP_RM64_R64_0F1B: int = 1020
"""
``RESERVEDNOP r/m64, r64``
``o64 0F 1B /r``
``CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B``
``64-bit``
"""
RESERVEDNOP_RM16_R16_0F1C: int = 1021
"""
``RESERVEDNOP r/m16, r16``
``o16 0F 1C /r``
``CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B``
``16/32/64-bit``
"""
RESERVEDNOP_RM32_R32_0F1C: int = 1022
"""
``RESERVEDNOP r/m32, r32``
``o32 0F 1C /r``
``CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B``
``16/32/64-bit``
"""
RESERVEDNOP_RM64_R64_0F1C: int = 1023
"""
``RESERVEDNOP r/m64, r64``
``o64 0F 1C /r``
``CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B``
``64-bit``
"""
RESERVEDNOP_RM16_R16_0F1D: int = 1024
"""
``RESERVEDNOP r/m16, r16``
``o16 0F 1D /r``
``CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B``
``16/32/64-bit``
"""
RESERVEDNOP_RM32_R32_0F1D: int = 1025
"""
``RESERVEDNOP r/m32, r32``
``o32 0F 1D /r``
``CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B``
``16/32/64-bit``
"""
RESERVEDNOP_RM64_R64_0F1D: int = 1026
"""
``RESERVEDNOP r/m64, r64``
``o64 0F 1D /r``
``CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B``
``64-bit``
"""
RESERVEDNOP_RM16_R16_0F1E: int = 1027
"""
``RESERVEDNOP r/m16, r16``
``o16 0F 1E /r``
``CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B``
``16/32/64-bit``
"""
RESERVEDNOP_RM32_R32_0F1E: int = 1028
"""
``RESERVEDNOP r/m32, r32``
``o32 0F 1E /r``
``CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B``
``16/32/64-bit``
"""
RESERVEDNOP_RM64_R64_0F1E: int = 1029
"""
``RESERVEDNOP r/m64, r64``
``o64 0F 1E /r``
``CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B``
``64-bit``
"""
RESERVEDNOP_RM16_R16_0F1F: int = 1030
"""
``RESERVEDNOP r/m16, r16``
``o16 0F 1F /r``
``CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B``
``16/32/64-bit``
"""
RESERVEDNOP_RM32_R32_0F1F: int = 1031
"""
``RESERVEDNOP r/m32, r32``
``o32 0F 1F /r``
``CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B``
``16/32/64-bit``
"""
RESERVEDNOP_RM64_R64_0F1F: int = 1032
"""
``RESERVEDNOP r/m64, r64``
``o64 0F 1F /r``
``CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B``
``64-bit``
"""
PREFETCHNTA_M8: int = 1033
"""
``PREFETCHNTA m8``
``0F 18 /0``
``SSE``
``16/32/64-bit``
"""
PREFETCHT0_M8: int = 1034
"""
``PREFETCHT0 m8``
``0F 18 /1``
``SSE``
``16/32/64-bit``
"""
PREFETCHT1_M8: int = 1035
"""
``PREFETCHT1 m8``
``0F 18 /2``
``SSE``
``16/32/64-bit``
"""
PREFETCHT2_M8: int = 1036
"""
``PREFETCHT2 m8``
``0F 18 /3``
``SSE``
``16/32/64-bit``
"""
BNDLDX_BND_MIB: int = 1037
"""
``BNDLDX bnd, mib``
``NP 0F 1A /r``
``MPX``
``16/32/64-bit``
"""
BNDMOV_BND_BNDM64: int = 1038
"""
``BNDMOV bnd1, bnd2/m64``
``66 0F 1A /r``
``MPX``
``16/32-bit``
"""
BNDMOV_BND_BNDM128: int = 1039
"""
``BNDMOV bnd1, bnd2/m128``
``66 0F 1A /r``
``MPX``
``64-bit``
"""
BNDCL_BND_RM32: int = 1040
"""
``BNDCL bnd, r/m32``
``F3 0F 1A /r``
``MPX``
``16/32-bit``
"""
BNDCL_BND_RM64: int = 1041
"""
``BNDCL bnd, r/m64``
``F3 0F 1A /r``
``MPX``
``64-bit``
"""
BNDCU_BND_RM32: int = 1042
"""
``BNDCU bnd, r/m32``
``F2 0F 1A /r``
``MPX``
``16/32-bit``
"""
BNDCU_BND_RM64: int = 1043
"""
``BNDCU bnd, r/m64``
``F2 0F 1A /r``
``MPX``
``64-bit``
"""
BNDSTX_MIB_BND: int = 1044
"""
``BNDSTX mib, bnd``
``NP 0F 1B /r``
``MPX``
``16/32/64-bit``
"""
BNDMOV_BNDM64_BND: int = 1045
"""
``BNDMOV bnd1/m64, bnd2``
``66 0F 1B /r``
``MPX``
``16/32-bit``
"""
BNDMOV_BNDM128_BND: int = 1046
"""
``BNDMOV bnd1/m128, bnd2``
``66 0F 1B /r``
``MPX``
``64-bit``
"""
BNDMK_BND_M32: int = 1047
"""
``BNDMK bnd, m32``
``F3 0F 1B /r``
``MPX``
``16/32-bit``
"""
BNDMK_BND_M64: int = 1048
"""
``BNDMK bnd, m64``
``F3 0F 1B /r``
``MPX``
``64-bit``
"""
BNDCN_BND_RM32: int = 1049
"""
``BNDCN bnd, r/m32``
``F2 0F 1B /r``
``MPX``
``16/32-bit``
"""
BNDCN_BND_RM64: int = 1050
"""
``BNDCN bnd, r/m64``
``F2 0F 1B /r``
``MPX``
``64-bit``
"""
CLDEMOTE_M8: int = 1051
"""
``CLDEMOTE m8``
``NP 0F 1C /0``
``CLDEMOTE``
``16/32/64-bit``
"""
RDSSPD_R32: int = 1052
"""
``RDSSPD r32``
``F3 0F 1E /1``
``CET_SS``
``16/32/64-bit``
"""
RDSSPQ_R64: int = 1053
"""
``RDSSPQ r64``
``F3 o64 0F 1E /1``
``CET_SS``
``64-bit``
"""
ENDBR64: int = 1054
"""
``ENDBR64``
``F3 0F 1E FA``
``CET_IBT``
``16/32/64-bit``
"""
ENDBR32: int = 1055
"""
``ENDBR32``
``F3 0F 1E FB``
``CET_IBT``
``16/32/64-bit``
"""
NOP_RM16: int = 1056
"""
``NOP r/m16``
``o16 0F 1F /0``
``CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B``
``16/32/64-bit``
"""
NOP_RM32: int = 1057
"""
``NOP r/m32``
``o32 0F 1F /0``
``CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B``
``16/32/64-bit``
"""
NOP_RM64: int = 1058
"""
``NOP r/m64``
``o64 0F 1F /0``
``CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B``
``64-bit``
"""
MOV_R32_CR: int = 1059
"""
``MOV r32, cr``
``0F 20 /r``
``386+``
``16/32-bit``
"""
MOV_R64_CR: int = 1060
"""
``MOV r64, cr``
``0F 20 /r``
``X64``
``64-bit``
"""
MOV_R32_DR: int = 1061
"""
``MOV r32, dr``
``0F 21 /r``
``386+``
``16/32-bit``
"""
MOV_R64_DR: int = 1062
"""
``MOV r64, dr``
``0F 21 /r``
``X64``
``64-bit``
"""
MOV_CR_R32: int = 1063
"""
``MOV cr, r32``
``0F 22 /r``
``386+``
``16/32-bit``
"""
MOV_CR_R64: int = 1064
"""
``MOV cr, r64``
``0F 22 /r``
``X64``
``64-bit``
"""
MOV_DR_R32: int = 1065
"""
``MOV dr, r32``
``0F 23 /r``
``386+``
``16/32-bit``
"""
MOV_DR_R64: int = 1066
"""
``MOV dr, r64``
``0F 23 /r``
``X64``
``64-bit``
"""
MOV_R32_TR: int = 1067
"""
``MOV r32, tr``
``0F 24 /r``
``386/486/Cyrix/Geode``
``16/32-bit``
"""
MOV_TR_R32: int = 1068
"""
``MOV tr, r32``
``0F 26 /r``
``386/486/Cyrix/Geode``
``16/32-bit``
"""
MOVAPS_XMM_XMMM128: int = 1069
"""
``MOVAPS xmm1, xmm2/m128``
``NP 0F 28 /r``
``SSE``
``16/32/64-bit``
"""
VEX_VMOVAPS_XMM_XMMM128: int = 1070
"""
``VMOVAPS xmm1, xmm2/m128``
``VEX.128.0F.WIG 28 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VMOVAPS_YMM_YMMM256: int = 1071
"""
``VMOVAPS ymm1, ymm2/m256``
``VEX.256.0F.WIG 28 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMOVAPS_XMM_K1Z_XMMM128: int = 1072
"""
``VMOVAPS xmm1 {k1}{z}, xmm2/m128``
``EVEX.128.0F.W0 28 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVAPS_YMM_K1Z_YMMM256: int = 1073
"""
``VMOVAPS ymm1 {k1}{z}, ymm2/m256``
``EVEX.256.0F.W0 28 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVAPS_ZMM_K1Z_ZMMM512: int = 1074
"""
``VMOVAPS zmm1 {k1}{z}, zmm2/m512``
``EVEX.512.0F.W0 28 /r``
``AVX512F``
``16/32/64-bit``
"""
MOVAPD_XMM_XMMM128: int = 1075
"""
``MOVAPD xmm1, xmm2/m128``
``66 0F 28 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VMOVAPD_XMM_XMMM128: int = 1076
"""
``VMOVAPD xmm1, xmm2/m128``
``VEX.128.66.0F.WIG 28 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VMOVAPD_YMM_YMMM256: int = 1077
"""
``VMOVAPD ymm1, ymm2/m256``
``VEX.256.66.0F.WIG 28 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMOVAPD_XMM_K1Z_XMMM128: int = 1078
"""
``VMOVAPD xmm1 {k1}{z}, xmm2/m128``
``EVEX.128.66.0F.W1 28 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVAPD_YMM_K1Z_YMMM256: int = 1079
"""
``VMOVAPD ymm1 {k1}{z}, ymm2/m256``
``EVEX.256.66.0F.W1 28 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVAPD_ZMM_K1Z_ZMMM512: int = 1080
"""
``VMOVAPD zmm1 {k1}{z}, zmm2/m512``
``EVEX.512.66.0F.W1 28 /r``
``AVX512F``
``16/32/64-bit``
"""
MOVAPS_XMMM128_XMM: int = 1081
"""
``MOVAPS xmm2/m128, xmm1``
``NP 0F 29 /r``
``SSE``
``16/32/64-bit``
"""
VEX_VMOVAPS_XMMM128_XMM: int = 1082
"""
``VMOVAPS xmm2/m128, xmm1``
``VEX.128.0F.WIG 29 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VMOVAPS_YMMM256_YMM: int = 1083
"""
``VMOVAPS ymm2/m256, ymm1``
``VEX.256.0F.WIG 29 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMOVAPS_XMMM128_K1Z_XMM: int = 1084
"""
``VMOVAPS xmm2/m128 {k1}{z}, xmm1``
``EVEX.128.0F.W0 29 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVAPS_YMMM256_K1Z_YMM: int = 1085
"""
``VMOVAPS ymm2/m256 {k1}{z}, ymm1``
``EVEX.256.0F.W0 29 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVAPS_ZMMM512_K1Z_ZMM: int = 1086
"""
``VMOVAPS zmm2/m512 {k1}{z}, zmm1``
``EVEX.512.0F.W0 29 /r``
``AVX512F``
``16/32/64-bit``
"""
MOVAPD_XMMM128_XMM: int = 1087
"""
``MOVAPD xmm2/m128, xmm1``
``66 0F 29 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VMOVAPD_XMMM128_XMM: int = 1088
"""
``VMOVAPD xmm2/m128, xmm1``
``VEX.128.66.0F.WIG 29 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VMOVAPD_YMMM256_YMM: int = 1089
"""
``VMOVAPD ymm2/m256, ymm1``
``VEX.256.66.0F.WIG 29 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMOVAPD_XMMM128_K1Z_XMM: int = 1090
"""
``VMOVAPD xmm2/m128 {k1}{z}, xmm1``
``EVEX.128.66.0F.W1 29 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVAPD_YMMM256_K1Z_YMM: int = 1091
"""
``VMOVAPD ymm2/m256 {k1}{z}, ymm1``
``EVEX.256.66.0F.W1 29 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVAPD_ZMMM512_K1Z_ZMM: int = 1092
"""
``VMOVAPD zmm2/m512 {k1}{z}, zmm1``
``EVEX.512.66.0F.W1 29 /r``
``AVX512F``
``16/32/64-bit``
"""
CVTPI2PS_XMM_MMM64: int = 1093
"""
``CVTPI2PS xmm, mm/m64``
``NP 0F 2A /r``
``SSE``
``16/32/64-bit``
"""
CVTPI2PD_XMM_MMM64: int = 1094
"""
``CVTPI2PD xmm, mm/m64``
``66 0F 2A /r``
``SSE2``
``16/32/64-bit``
"""
CVTSI2SS_XMM_RM32: int = 1095
"""
``CVTSI2SS xmm1, r/m32``
``F3 0F 2A /r``
``SSE``
``16/32/64-bit``
"""
CVTSI2SS_XMM_RM64: int = 1096
"""
``CVTSI2SS xmm1, r/m64``
``F3 o64 0F 2A /r``
``SSE``
``64-bit``
"""
VEX_VCVTSI2SS_XMM_XMM_RM32: int = 1097
"""
``VCVTSI2SS xmm1, xmm2, r/m32``
``VEX.LIG.F3.0F.W0 2A /r``
``AVX``
``16/32/64-bit``
"""
VEX_VCVTSI2SS_XMM_XMM_RM64: int = 1098
"""
``VCVTSI2SS xmm1, xmm2, r/m64``
``VEX.LIG.F3.0F.W1 2A /r``
``AVX``
``64-bit``
"""
EVEX_VCVTSI2SS_XMM_XMM_RM32_ER: int = 1099
"""
``VCVTSI2SS xmm1, xmm2, r/m32{er}``
``EVEX.LIG.F3.0F.W0 2A /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTSI2SS_XMM_XMM_RM64_ER: int = 1100
"""
``VCVTSI2SS xmm1, xmm2, r/m64{er}``
``EVEX.LIG.F3.0F.W1 2A /r``
``AVX512F``
``64-bit``
"""
CVTSI2SD_XMM_RM32: int = 1101
"""
``CVTSI2SD xmm1, r/m32``
``F2 0F 2A /r``
``SSE2``
``16/32/64-bit``
"""
CVTSI2SD_XMM_RM64: int = 1102
"""
``CVTSI2SD xmm1, r/m64``
``F2 o64 0F 2A /r``
``SSE2``
``64-bit``
"""
VEX_VCVTSI2SD_XMM_XMM_RM32: int = 1103
"""
``VCVTSI2SD xmm1, xmm2, r/m32``
``VEX.LIG.F2.0F.W0 2A /r``
``AVX``
``16/32/64-bit``
"""
VEX_VCVTSI2SD_XMM_XMM_RM64: int = 1104
"""
``VCVTSI2SD xmm1, xmm2, r/m64``
``VEX.LIG.F2.0F.W1 2A /r``
``AVX``
``64-bit``
"""
EVEX_VCVTSI2SD_XMM_XMM_RM32_ER: int = 1105
"""
``VCVTSI2SD xmm1, xmm2, r/m32{er}``
``EVEX.LIG.F2.0F.W0 2A /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTSI2SD_XMM_XMM_RM64_ER: int = 1106
"""
``VCVTSI2SD xmm1, xmm2, r/m64{er}``
``EVEX.LIG.F2.0F.W1 2A /r``
``AVX512F``
``64-bit``
"""
MOVNTPS_M128_XMM: int = 1107
"""
``MOVNTPS m128, xmm1``
``NP 0F 2B /r``
``SSE``
``16/32/64-bit``
"""
VEX_VMOVNTPS_M128_XMM: int = 1108
"""
``VMOVNTPS m128, xmm1``
``VEX.128.0F.WIG 2B /r``
``AVX``
``16/32/64-bit``
"""
VEX_VMOVNTPS_M256_YMM: int = 1109
"""
``VMOVNTPS m256, ymm1``
``VEX.256.0F.WIG 2B /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMOVNTPS_M128_XMM: int = 1110
"""
``VMOVNTPS m128, xmm1``
``EVEX.128.0F.W0 2B /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVNTPS_M256_YMM: int = 1111
"""
``VMOVNTPS m256, ymm1``
``EVEX.256.0F.W0 2B /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVNTPS_M512_ZMM: int = 1112
"""
``VMOVNTPS m512, zmm1``
``EVEX.512.0F.W0 2B /r``
``AVX512F``
``16/32/64-bit``
"""
MOVNTPD_M128_XMM: int = 1113
"""
``MOVNTPD m128, xmm1``
``66 0F 2B /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VMOVNTPD_M128_XMM: int = 1114
"""
``VMOVNTPD m128, xmm1``
``VEX.128.66.0F.WIG 2B /r``
``AVX``
``16/32/64-bit``
"""
VEX_VMOVNTPD_M256_YMM: int = 1115
"""
``VMOVNTPD m256, ymm1``
``VEX.256.66.0F.WIG 2B /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMOVNTPD_M128_XMM: int = 1116
"""
``VMOVNTPD m128, xmm1``
``EVEX.128.66.0F.W1 2B /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVNTPD_M256_YMM: int = 1117
"""
``VMOVNTPD m256, ymm1``
``EVEX.256.66.0F.W1 2B /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVNTPD_M512_ZMM: int = 1118
"""
``VMOVNTPD m512, zmm1``
``EVEX.512.66.0F.W1 2B /r``
``AVX512F``
``16/32/64-bit``
"""
MOVNTSS_M32_XMM: int = 1119
"""
``MOVNTSS m32, xmm1``
``F3 0F 2B /r``
``SSE4A``
``16/32/64-bit``
"""
MOVNTSD_M64_XMM: int = 1120
"""
``MOVNTSD m64, xmm1``
``F2 0F 2B /r``
``SSE4A``
``16/32/64-bit``
"""
CVTTPS2PI_MM_XMMM64: int = 1121
"""
``CVTTPS2PI mm, xmm/m64``
``NP 0F 2C /r``
``SSE``
``16/32/64-bit``
"""
CVTTPD2PI_MM_XMMM128: int = 1122
"""
``CVTTPD2PI mm, xmm/m128``
``66 0F 2C /r``
``SSE2``
``16/32/64-bit``
"""
CVTTSS2SI_R32_XMMM32: int = 1123
"""
``CVTTSS2SI r32, xmm1/m32``
``F3 0F 2C /r``
``SSE``
``16/32/64-bit``
"""
CVTTSS2SI_R64_XMMM32: int = 1124
"""
``CVTTSS2SI r64, xmm1/m32``
``F3 o64 0F 2C /r``
``SSE``
``64-bit``
"""
VEX_VCVTTSS2SI_R32_XMMM32: int = 1125
"""
``VCVTTSS2SI r32, xmm1/m32``
``VEX.LIG.F3.0F.W0 2C /r``
``AVX``
``16/32/64-bit``
"""
VEX_VCVTTSS2SI_R64_XMMM32: int = 1126
"""
``VCVTTSS2SI r64, xmm1/m32``
``VEX.LIG.F3.0F.W1 2C /r``
``AVX``
``64-bit``
"""
EVEX_VCVTTSS2SI_R32_XMMM32_SAE: int = 1127
"""
``VCVTTSS2SI r32, xmm1/m32{sae}``
``EVEX.LIG.F3.0F.W0 2C /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTTSS2SI_R64_XMMM32_SAE: int = 1128
"""
``VCVTTSS2SI r64, xmm1/m32{sae}``
``EVEX.LIG.F3.0F.W1 2C /r``
``AVX512F``
``64-bit``
"""
CVTTSD2SI_R32_XMMM64: int = 1129
"""
``CVTTSD2SI r32, xmm1/m64``
``F2 0F 2C /r``
``SSE2``
``16/32/64-bit``
"""
CVTTSD2SI_R64_XMMM64: int = 1130
"""
``CVTTSD2SI r64, xmm1/m64``
``F2 o64 0F 2C /r``
``SSE2``
``64-bit``
"""
VEX_VCVTTSD2SI_R32_XMMM64: int = 1131
"""
``VCVTTSD2SI r32, xmm1/m64``
``VEX.LIG.F2.0F.W0 2C /r``
``AVX``
``16/32/64-bit``
"""
VEX_VCVTTSD2SI_R64_XMMM64: int = 1132
"""
``VCVTTSD2SI r64, xmm1/m64``
``VEX.LIG.F2.0F.W1 2C /r``
``AVX``
``64-bit``
"""
EVEX_VCVTTSD2SI_R32_XMMM64_SAE: int = 1133
"""
``VCVTTSD2SI r32, xmm1/m64{sae}``
``EVEX.LIG.F2.0F.W0 2C /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTTSD2SI_R64_XMMM64_SAE: int = 1134
"""
``VCVTTSD2SI r64, xmm1/m64{sae}``
``EVEX.LIG.F2.0F.W1 2C /r``
``AVX512F``
``64-bit``
"""
CVTPS2PI_MM_XMMM64: int = 1135
"""
``CVTPS2PI mm, xmm/m64``
``NP 0F 2D /r``
``SSE``
``16/32/64-bit``
"""
CVTPD2PI_MM_XMMM128: int = 1136
"""
``CVTPD2PI mm, xmm/m128``
``66 0F 2D /r``
``SSE2``
``16/32/64-bit``
"""
CVTSS2SI_R32_XMMM32: int = 1137
"""
``CVTSS2SI r32, xmm1/m32``
``F3 0F 2D /r``
``SSE``
``16/32/64-bit``
"""
CVTSS2SI_R64_XMMM32: int = 1138
"""
``CVTSS2SI r64, xmm1/m32``
``F3 o64 0F 2D /r``
``SSE``
``64-bit``
"""
VEX_VCVTSS2SI_R32_XMMM32: int = 1139
"""
``VCVTSS2SI r32, xmm1/m32``
``VEX.LIG.F3.0F.W0 2D /r``
``AVX``
``16/32/64-bit``
"""
VEX_VCVTSS2SI_R64_XMMM32: int = 1140
"""
``VCVTSS2SI r64, xmm1/m32``
``VEX.LIG.F3.0F.W1 2D /r``
``AVX``
``64-bit``
"""
EVEX_VCVTSS2SI_R32_XMMM32_ER: int = 1141
"""
``VCVTSS2SI r32, xmm1/m32{er}``
``EVEX.LIG.F3.0F.W0 2D /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTSS2SI_R64_XMMM32_ER: int = 1142
"""
``VCVTSS2SI r64, xmm1/m32{er}``
``EVEX.LIG.F3.0F.W1 2D /r``
``AVX512F``
``64-bit``
"""
CVTSD2SI_R32_XMMM64: int = 1143
"""
``CVTSD2SI r32, xmm1/m64``
``F2 0F 2D /r``
``SSE2``
``16/32/64-bit``
"""
CVTSD2SI_R64_XMMM64: int = 1144
"""
``CVTSD2SI r64, xmm1/m64``
``F2 o64 0F 2D /r``
``SSE2``
``64-bit``
"""
VEX_VCVTSD2SI_R32_XMMM64: int = 1145
"""
``VCVTSD2SI r32, xmm1/m64``
``VEX.LIG.F2.0F.W0 2D /r``
``AVX``
``16/32/64-bit``
"""
VEX_VCVTSD2SI_R64_XMMM64: int = 1146
"""
``VCVTSD2SI r64, xmm1/m64``
``VEX.LIG.F2.0F.W1 2D /r``
``AVX``
``64-bit``
"""
EVEX_VCVTSD2SI_R32_XMMM64_ER: int = 1147
"""
``VCVTSD2SI r32, xmm1/m64{er}``
``EVEX.LIG.F2.0F.W0 2D /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTSD2SI_R64_XMMM64_ER: int = 1148
"""
``VCVTSD2SI r64, xmm1/m64{er}``
``EVEX.LIG.F2.0F.W1 2D /r``
``AVX512F``
``64-bit``
"""
UCOMISS_XMM_XMMM32: int = 1149
"""
``UCOMISS xmm1, xmm2/m32``
``NP 0F 2E /r``
``SSE``
``16/32/64-bit``
"""
VEX_VUCOMISS_XMM_XMMM32: int = 1150
"""
``VUCOMISS xmm1, xmm2/m32``
``VEX.LIG.0F.WIG 2E /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VUCOMISS_XMM_XMMM32_SAE: int = 1151
"""
``VUCOMISS xmm1, xmm2/m32{sae}``
``EVEX.LIG.0F.W0 2E /r``
``AVX512F``
``16/32/64-bit``
"""
UCOMISD_XMM_XMMM64: int = 1152
"""
``UCOMISD xmm1, xmm2/m64``
``66 0F 2E /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VUCOMISD_XMM_XMMM64: int = 1153
"""
``VUCOMISD xmm1, xmm2/m64``
``VEX.LIG.66.0F.WIG 2E /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VUCOMISD_XMM_XMMM64_SAE: int = 1154
"""
``VUCOMISD xmm1, xmm2/m64{sae}``
``EVEX.LIG.66.0F.W1 2E /r``
``AVX512F``
``16/32/64-bit``
"""
COMISS_XMM_XMMM32: int = 1155
"""
``COMISS xmm1, xmm2/m32``
``NP 0F 2F /r``
``SSE``
``16/32/64-bit``
"""
COMISD_XMM_XMMM64: int = 1156
"""
``COMISD xmm1, xmm2/m64``
``66 0F 2F /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VCOMISS_XMM_XMMM32: int = 1157
"""
``VCOMISS xmm1, xmm2/m32``
``VEX.LIG.0F.WIG 2F /r``
``AVX``
``16/32/64-bit``
"""
VEX_VCOMISD_XMM_XMMM64: int = 1158
"""
``VCOMISD xmm1, xmm2/m64``
``VEX.LIG.66.0F.WIG 2F /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VCOMISS_XMM_XMMM32_SAE: int = 1159
"""
``VCOMISS xmm1, xmm2/m32{sae}``
``EVEX.LIG.0F.W0 2F /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VCOMISD_XMM_XMMM64_SAE: int = 1160
"""
``VCOMISD xmm1, xmm2/m64{sae}``
``EVEX.LIG.66.0F.W1 2F /r``
``AVX512F``
``16/32/64-bit``
"""
WRMSR: int = 1161
"""
``WRMSR``
``0F 30``
``MSR``
``16/32/64-bit``
"""
RDTSC: int = 1162
"""
``RDTSC``
``0F 31``
``TSC``
``16/32/64-bit``
"""
RDMSR: int = 1163
"""
``RDMSR``
``0F 32``
``MSR``
``16/32/64-bit``
"""
RDPMC: int = 1164
"""
``RDPMC``
``0F 33``
``Pentium MMX or later, or Pentium Pro or later``
``16/32/64-bit``
"""
SYSENTER: int = 1165
"""
``SYSENTER``
``0F 34``
``SEP``
``16/32/64-bit``
"""
SYSEXITD: int = 1166
"""
``SYSEXIT``
``0F 35``
``SEP``
``16/32/64-bit``
"""
SYSEXITQ: int = 1167
"""
``SYSEXITQ``
``o64 0F 35``
``SEP``
``64-bit``
"""
GETSECD: int = 1168
"""
``GETSEC``
``NP 0F 37``
``SMX``
``16/32/64-bit``
"""
CMOVO_R16_RM16: int = 1169
"""
``CMOVO r16, r/m16``
``o16 0F 40 /r``
``CMOV``
``16/32/64-bit``
"""
CMOVO_R32_RM32: int = 1170
"""
``CMOVO r32, r/m32``
``o32 0F 40 /r``
``CMOV``
``16/32/64-bit``
"""
CMOVO_R64_RM64: int = 1171
"""
``CMOVO r64, r/m64``
``o64 0F 40 /r``
``CMOV``
``64-bit``
"""
CMOVNO_R16_RM16: int = 1172
"""
``CMOVNO r16, r/m16``
``o16 0F 41 /r``
``CMOV``
``16/32/64-bit``
"""
CMOVNO_R32_RM32: int = 1173
"""
``CMOVNO r32, r/m32``
``o32 0F 41 /r``
``CMOV``
``16/32/64-bit``
"""
CMOVNO_R64_RM64: int = 1174
"""
``CMOVNO r64, r/m64``
``o64 0F 41 /r``
``CMOV``
``64-bit``
"""
CMOVB_R16_RM16: int = 1175
"""
``CMOVB r16, r/m16``
``o16 0F 42 /r``
``CMOV``
``16/32/64-bit``
"""
CMOVB_R32_RM32: int = 1176
"""
``CMOVB r32, r/m32``
``o32 0F 42 /r``
``CMOV``
``16/32/64-bit``
"""
CMOVB_R64_RM64: int = 1177
"""
``CMOVB r64, r/m64``
``o64 0F 42 /r``
``CMOV``
``64-bit``
"""
CMOVAE_R16_RM16: int = 1178
"""
``CMOVAE r16, r/m16``
``o16 0F 43 /r``
``CMOV``
``16/32/64-bit``
"""
CMOVAE_R32_RM32: int = 1179
"""
``CMOVAE r32, r/m32``
``o32 0F 43 /r``
``CMOV``
``16/32/64-bit``
"""
CMOVAE_R64_RM64: int = 1180
"""
``CMOVAE r64, r/m64``
``o64 0F 43 /r``
``CMOV``
``64-bit``
"""
CMOVE_R16_RM16: int = 1181
"""
``CMOVE r16, r/m16``
``o16 0F 44 /r``
``CMOV``
``16/32/64-bit``
"""
CMOVE_R32_RM32: int = 1182
"""
``CMOVE r32, r/m32``
``o32 0F 44 /r``
``CMOV``
``16/32/64-bit``
"""
CMOVE_R64_RM64: int = 1183
"""
``CMOVE r64, r/m64``
``o64 0F 44 /r``
``CMOV``
``64-bit``
"""
CMOVNE_R16_RM16: int = 1184
"""
``CMOVNE r16, r/m16``
``o16 0F 45 /r``
``CMOV``
``16/32/64-bit``
"""
CMOVNE_R32_RM32: int = 1185
"""
``CMOVNE r32, r/m32``
``o32 0F 45 /r``
``CMOV``
``16/32/64-bit``
"""
CMOVNE_R64_RM64: int = 1186
"""
``CMOVNE r64, r/m64``
``o64 0F 45 /r``
``CMOV``
``64-bit``
"""
CMOVBE_R16_RM16: int = 1187
"""
``CMOVBE r16, r/m16``
``o16 0F 46 /r``
``CMOV``
``16/32/64-bit``
"""
CMOVBE_R32_RM32: int = 1188
"""
``CMOVBE r32, r/m32``
``o32 0F 46 /r``
``CMOV``
``16/32/64-bit``
"""
CMOVBE_R64_RM64: int = 1189
"""
``CMOVBE r64, r/m64``
``o64 0F 46 /r``
``CMOV``
``64-bit``
"""
CMOVA_R16_RM16: int = 1190
"""
``CMOVA r16, r/m16``
``o16 0F 47 /r``
``CMOV``
``16/32/64-bit``
"""
CMOVA_R32_RM32: int = 1191
"""
``CMOVA r32, r/m32``
``o32 0F 47 /r``
``CMOV``
``16/32/64-bit``
"""
CMOVA_R64_RM64: int = 1192
"""
``CMOVA r64, r/m64``
``o64 0F 47 /r``
``CMOV``
``64-bit``
"""
CMOVS_R16_RM16: int = 1193
"""
``CMOVS r16, r/m16``
``o16 0F 48 /r``
``CMOV``
``16/32/64-bit``
"""
CMOVS_R32_RM32: int = 1194
"""
``CMOVS r32, r/m32``
``o32 0F 48 /r``
``CMOV``
``16/32/64-bit``
"""
CMOVS_R64_RM64: int = 1195
"""
``CMOVS r64, r/m64``
``o64 0F 48 /r``
``CMOV``
``64-bit``
"""
CMOVNS_R16_RM16: int = 1196
"""
``CMOVNS r16, r/m16``
``o16 0F 49 /r``
``CMOV``
``16/32/64-bit``
"""
CMOVNS_R32_RM32: int = 1197
"""
``CMOVNS r32, r/m32``
``o32 0F 49 /r``
``CMOV``
``16/32/64-bit``
"""
CMOVNS_R64_RM64: int = 1198
"""
``CMOVNS r64, r/m64``
``o64 0F 49 /r``
``CMOV``
``64-bit``
"""
CMOVP_R16_RM16: int = 1199
"""
``CMOVP r16, r/m16``
``o16 0F 4A /r``
``CMOV``
``16/32/64-bit``
"""
CMOVP_R32_RM32: int = 1200
"""
``CMOVP r32, r/m32``
``o32 0F 4A /r``
``CMOV``
``16/32/64-bit``
"""
CMOVP_R64_RM64: int = 1201
"""
``CMOVP r64, r/m64``
``o64 0F 4A /r``
``CMOV``
``64-bit``
"""
CMOVNP_R16_RM16: int = 1202
"""
``CMOVNP r16, r/m16``
``o16 0F 4B /r``
``CMOV``
``16/32/64-bit``
"""
CMOVNP_R32_RM32: int = 1203
"""
``CMOVNP r32, r/m32``
``o32 0F 4B /r``
``CMOV``
``16/32/64-bit``
"""
CMOVNP_R64_RM64: int = 1204
"""
``CMOVNP r64, r/m64``
``o64 0F 4B /r``
``CMOV``
``64-bit``
"""
CMOVL_R16_RM16: int = 1205
"""
``CMOVL r16, r/m16``
``o16 0F 4C /r``
``CMOV``
``16/32/64-bit``
"""
CMOVL_R32_RM32: int = 1206
"""
``CMOVL r32, r/m32``
``o32 0F 4C /r``
``CMOV``
``16/32/64-bit``
"""
CMOVL_R64_RM64: int = 1207
"""
``CMOVL r64, r/m64``
``o64 0F 4C /r``
``CMOV``
``64-bit``
"""
CMOVGE_R16_RM16: int = 1208
"""
``CMOVGE r16, r/m16``
``o16 0F 4D /r``
``CMOV``
``16/32/64-bit``
"""
CMOVGE_R32_RM32: int = 1209
"""
``CMOVGE r32, r/m32``
``o32 0F 4D /r``
``CMOV``
``16/32/64-bit``
"""
CMOVGE_R64_RM64: int = 1210
"""
``CMOVGE r64, r/m64``
``o64 0F 4D /r``
``CMOV``
``64-bit``
"""
CMOVLE_R16_RM16: int = 1211
"""
``CMOVLE r16, r/m16``
``o16 0F 4E /r``
``CMOV``
``16/32/64-bit``
"""
CMOVLE_R32_RM32: int = 1212
"""
``CMOVLE r32, r/m32``
``o32 0F 4E /r``
``CMOV``
``16/32/64-bit``
"""
CMOVLE_R64_RM64: int = 1213
"""
``CMOVLE r64, r/m64``
``o64 0F 4E /r``
``CMOV``
``64-bit``
"""
CMOVG_R16_RM16: int = 1214
"""
``CMOVG r16, r/m16``
``o16 0F 4F /r``
``CMOV``
``16/32/64-bit``
"""
CMOVG_R32_RM32: int = 1215
"""
``CMOVG r32, r/m32``
``o32 0F 4F /r``
``CMOV``
``16/32/64-bit``
"""
CMOVG_R64_RM64: int = 1216
"""
``CMOVG r64, r/m64``
``o64 0F 4F /r``
``CMOV``
``64-bit``
"""
VEX_KANDW_KR_KR_KR: int = 1217
"""
``KANDW k1, k2, k3``
``VEX.L1.0F.W0 41 /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_KANDQ_KR_KR_KR: int = 1218
"""
``KANDQ k1, k2, k3``
``VEX.L1.0F.W1 41 /r``
``AVX512BW``
``16/32/64-bit``
"""
VEX_KANDB_KR_KR_KR: int = 1219
"""
``KANDB k1, k2, k3``
``VEX.L1.66.0F.W0 41 /r``
``AVX512DQ``
``16/32/64-bit``
"""
VEX_KANDD_KR_KR_KR: int = 1220
"""
``KANDD k1, k2, k3``
``VEX.L1.66.0F.W1 41 /r``
``AVX512BW``
``16/32/64-bit``
"""
VEX_KANDNW_KR_KR_KR: int = 1221
"""
``KANDNW k1, k2, k3``
``VEX.L1.0F.W0 42 /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_KANDNQ_KR_KR_KR: int = 1222
"""
``KANDNQ k1, k2, k3``
``VEX.L1.0F.W1 42 /r``
``AVX512BW``
``16/32/64-bit``
"""
VEX_KANDNB_KR_KR_KR: int = 1223
"""
``KANDNB k1, k2, k3``
``VEX.L1.66.0F.W0 42 /r``
``AVX512DQ``
``16/32/64-bit``
"""
VEX_KANDND_KR_KR_KR: int = 1224
"""
``KANDND k1, k2, k3``
``VEX.L1.66.0F.W1 42 /r``
``AVX512BW``
``16/32/64-bit``
"""
VEX_KNOTW_KR_KR: int = 1225
"""
``KNOTW k1, k2``
``VEX.L0.0F.W0 44 /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_KNOTQ_KR_KR: int = 1226
"""
``KNOTQ k1, k2``
``VEX.L0.0F.W1 44 /r``
``AVX512BW``
``16/32/64-bit``
"""
VEX_KNOTB_KR_KR: int = 1227
"""
``KNOTB k1, k2``
``VEX.L0.66.0F.W0 44 /r``
``AVX512DQ``
``16/32/64-bit``
"""
VEX_KNOTD_KR_KR: int = 1228
"""
``KNOTD k1, k2``
``VEX.L0.66.0F.W1 44 /r``
``AVX512BW``
``16/32/64-bit``
"""
VEX_KORW_KR_KR_KR: int = 1229
"""
``KORW k1, k2, k3``
``VEX.L1.0F.W0 45 /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_KORQ_KR_KR_KR: int = 1230
"""
``KORQ k1, k2, k3``
``VEX.L1.0F.W1 45 /r``
``AVX512BW``
``16/32/64-bit``
"""
VEX_KORB_KR_KR_KR: int = 1231
"""
``KORB k1, k2, k3``
``VEX.L1.66.0F.W0 45 /r``
``AVX512DQ``
``16/32/64-bit``
"""
VEX_KORD_KR_KR_KR: int = 1232
"""
``KORD k1, k2, k3``
``VEX.L1.66.0F.W1 45 /r``
``AVX512BW``
``16/32/64-bit``
"""
VEX_KXNORW_KR_KR_KR: int = 1233
"""
``KXNORW k1, k2, k3``
``VEX.L1.0F.W0 46 /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_KXNORQ_KR_KR_KR: int = 1234
"""
``KXNORQ k1, k2, k3``
``VEX.L1.0F.W1 46 /r``
``AVX512BW``
``16/32/64-bit``
"""
VEX_KXNORB_KR_KR_KR: int = 1235
"""
``KXNORB k1, k2, k3``
``VEX.L1.66.0F.W0 46 /r``
``AVX512DQ``
``16/32/64-bit``
"""
VEX_KXNORD_KR_KR_KR: int = 1236
"""
``KXNORD k1, k2, k3``
``VEX.L1.66.0F.W1 46 /r``
``AVX512BW``
``16/32/64-bit``
"""
VEX_KXORW_KR_KR_KR: int = 1237
"""
``KXORW k1, k2, k3``
``VEX.L1.0F.W0 47 /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_KXORQ_KR_KR_KR: int = 1238
"""
``KXORQ k1, k2, k3``
``VEX.L1.0F.W1 47 /r``
``AVX512BW``
``16/32/64-bit``
"""
VEX_KXORB_KR_KR_KR: int = 1239
"""
``KXORB k1, k2, k3``
``VEX.L1.66.0F.W0 47 /r``
``AVX512DQ``
``16/32/64-bit``
"""
VEX_KXORD_KR_KR_KR: int = 1240
"""
``KXORD k1, k2, k3``
``VEX.L1.66.0F.W1 47 /r``
``AVX512BW``
``16/32/64-bit``
"""
VEX_KADDW_KR_KR_KR: int = 1241
"""
``KADDW k1, k2, k3``
``VEX.L1.0F.W0 4A /r``
``AVX512DQ``
``16/32/64-bit``
"""
VEX_KADDQ_KR_KR_KR: int = 1242
"""
``KADDQ k1, k2, k3``
``VEX.L1.0F.W1 4A /r``
``AVX512BW``
``16/32/64-bit``
"""
VEX_KADDB_KR_KR_KR: int = 1243
"""
``KADDB k1, k2, k3``
``VEX.L1.66.0F.W0 4A /r``
``AVX512DQ``
``16/32/64-bit``
"""
VEX_KADDD_KR_KR_KR: int = 1244
"""
``KADDD k1, k2, k3``
``VEX.L1.66.0F.W1 4A /r``
``AVX512BW``
``16/32/64-bit``
"""
VEX_KUNPCKWD_KR_KR_KR: int = 1245
"""
``KUNPCKWD k1, k2, k3``
``VEX.L1.0F.W0 4B /r``
``AVX512BW``
``16/32/64-bit``
"""
VEX_KUNPCKDQ_KR_KR_KR: int = 1246
"""
``KUNPCKDQ k1, k2, k3``
``VEX.L1.0F.W1 4B /r``
``AVX512BW``
``16/32/64-bit``
"""
VEX_KUNPCKBW_KR_KR_KR: int = 1247
"""
``KUNPCKBW k1, k2, k3``
``VEX.L1.66.0F.W0 4B /r``
``AVX512F``
``16/32/64-bit``
"""
MOVMSKPS_R32_XMM: int = 1248
"""
``MOVMSKPS r32, xmm``
``NP 0F 50 /r``
``SSE``
``16/32/64-bit``
"""
MOVMSKPS_R64_XMM: int = 1249
"""
``MOVMSKPS r64, xmm``
``NP o64 0F 50 /r``
``SSE``
``64-bit``
"""
VEX_VMOVMSKPS_R32_XMM: int = 1250
"""
``VMOVMSKPS r32, xmm2``
``VEX.128.0F.W0 50 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VMOVMSKPS_R64_XMM: int = 1251
"""
``VMOVMSKPS r64, xmm2``
``VEX.128.0F.W1 50 /r``
``AVX``
``64-bit``
"""
VEX_VMOVMSKPS_R32_YMM: int = 1252
"""
``VMOVMSKPS r32, ymm2``
``VEX.256.0F.W0 50 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VMOVMSKPS_R64_YMM: int = 1253
"""
``VMOVMSKPS r64, ymm2``
``VEX.256.0F.W1 50 /r``
``AVX``
``64-bit``
"""
MOVMSKPD_R32_XMM: int = 1254
"""
``MOVMSKPD r32, xmm``
``66 0F 50 /r``
``SSE2``
``16/32/64-bit``
"""
MOVMSKPD_R64_XMM: int = 1255
"""
``MOVMSKPD r64, xmm``
``66 o64 0F 50 /r``
``SSE2``
``64-bit``
"""
VEX_VMOVMSKPD_R32_XMM: int = 1256
"""
``VMOVMSKPD r32, xmm2``
``VEX.128.66.0F.W0 50 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VMOVMSKPD_R64_XMM: int = 1257
"""
``VMOVMSKPD r64, xmm2``
``VEX.128.66.0F.W1 50 /r``
``AVX``
``64-bit``
"""
VEX_VMOVMSKPD_R32_YMM: int = 1258
"""
``VMOVMSKPD r32, ymm2``
``VEX.256.66.0F.W0 50 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VMOVMSKPD_R64_YMM: int = 1259
"""
``VMOVMSKPD r64, ymm2``
``VEX.256.66.0F.W1 50 /r``
``AVX``
``64-bit``
"""
SQRTPS_XMM_XMMM128: int = 1260
"""
``SQRTPS xmm1, xmm2/m128``
``NP 0F 51 /r``
``SSE``
``16/32/64-bit``
"""
VEX_VSQRTPS_XMM_XMMM128: int = 1261
"""
``VSQRTPS xmm1, xmm2/m128``
``VEX.128.0F.WIG 51 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VSQRTPS_YMM_YMMM256: int = 1262
"""
``VSQRTPS ymm1, ymm2/m256``
``VEX.256.0F.WIG 51 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VSQRTPS_XMM_K1Z_XMMM128B32: int = 1263
"""
``VSQRTPS xmm1 {k1}{z}, xmm2/m128/m32bcst``
``EVEX.128.0F.W0 51 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VSQRTPS_YMM_K1Z_YMMM256B32: int = 1264
"""
``VSQRTPS ymm1 {k1}{z}, ymm2/m256/m32bcst``
``EVEX.256.0F.W0 51 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VSQRTPS_ZMM_K1Z_ZMMM512B32_ER: int = 1265
"""
``VSQRTPS zmm1 {k1}{z}, zmm2/m512/m32bcst{er}``
``EVEX.512.0F.W0 51 /r``
``AVX512F``
``16/32/64-bit``
"""
SQRTPD_XMM_XMMM128: int = 1266
"""
``SQRTPD xmm1, xmm2/m128``
``66 0F 51 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VSQRTPD_XMM_XMMM128: int = 1267
"""
``VSQRTPD xmm1, xmm2/m128``
``VEX.128.66.0F.WIG 51 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VSQRTPD_YMM_YMMM256: int = 1268
"""
``VSQRTPD ymm1, ymm2/m256``
``VEX.256.66.0F.WIG 51 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VSQRTPD_XMM_K1Z_XMMM128B64: int = 1269
"""
``VSQRTPD xmm1 {k1}{z}, xmm2/m128/m64bcst``
``EVEX.128.66.0F.W1 51 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VSQRTPD_YMM_K1Z_YMMM256B64: int = 1270
"""
``VSQRTPD ymm1 {k1}{z}, ymm2/m256/m64bcst``
``EVEX.256.66.0F.W1 51 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VSQRTPD_ZMM_K1Z_ZMMM512B64_ER: int = 1271
"""
``VSQRTPD zmm1 {k1}{z}, zmm2/m512/m64bcst{er}``
``EVEX.512.66.0F.W1 51 /r``
``AVX512F``
``16/32/64-bit``
"""
SQRTSS_XMM_XMMM32: int = 1272
"""
``SQRTSS xmm1, xmm2/m32``
``F3 0F 51 /r``
``SSE``
``16/32/64-bit``
"""
VEX_VSQRTSS_XMM_XMM_XMMM32: int = 1273
"""
``VSQRTSS xmm1, xmm2, xmm3/m32``
``VEX.LIG.F3.0F.WIG 51 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VSQRTSS_XMM_K1Z_XMM_XMMM32_ER: int = 1274
"""
``VSQRTSS xmm1 {k1}{z}, xmm2, xmm3/m32{er}``
``EVEX.LIG.F3.0F.W0 51 /r``
``AVX512F``
``16/32/64-bit``
"""
SQRTSD_XMM_XMMM64: int = 1275
"""
``SQRTSD xmm1, xmm2/m64``
``F2 0F 51 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VSQRTSD_XMM_XMM_XMMM64: int = 1276
"""
``VSQRTSD xmm1, xmm2, xmm3/m64``
``VEX.LIG.F2.0F.WIG 51 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VSQRTSD_XMM_K1Z_XMM_XMMM64_ER: int = 1277
"""
``VSQRTSD xmm1 {k1}{z}, xmm2, xmm3/m64{er}``
``EVEX.LIG.F2.0F.W1 51 /r``
``AVX512F``
``16/32/64-bit``
"""
RSQRTPS_XMM_XMMM128: int = 1278
"""
``RSQRTPS xmm1, xmm2/m128``
``NP 0F 52 /r``
``SSE``
``16/32/64-bit``
"""
VEX_VRSQRTPS_XMM_XMMM128: int = 1279
"""
``VRSQRTPS xmm1, xmm2/m128``
``VEX.128.0F.WIG 52 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VRSQRTPS_YMM_YMMM256: int = 1280
"""
``VRSQRTPS ymm1, ymm2/m256``
``VEX.256.0F.WIG 52 /r``
``AVX``
``16/32/64-bit``
"""
RSQRTSS_XMM_XMMM32: int = 1281
"""
``RSQRTSS xmm1, xmm2/m32``
``F3 0F 52 /r``
``SSE``
``16/32/64-bit``
"""
VEX_VRSQRTSS_XMM_XMM_XMMM32: int = 1282
"""
``VRSQRTSS xmm1, xmm2, xmm3/m32``
``VEX.LIG.F3.0F.WIG 52 /r``
``AVX``
``16/32/64-bit``
"""
RCPPS_XMM_XMMM128: int = 1283
"""
``RCPPS xmm1, xmm2/m128``
``NP 0F 53 /r``
``SSE``
``16/32/64-bit``
"""
VEX_VRCPPS_XMM_XMMM128: int = 1284
"""
``VRCPPS xmm1, xmm2/m128``
``VEX.128.0F.WIG 53 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VRCPPS_YMM_YMMM256: int = 1285
"""
``VRCPPS ymm1, ymm2/m256``
``VEX.256.0F.WIG 53 /r``
``AVX``
``16/32/64-bit``
"""
RCPSS_XMM_XMMM32: int = 1286
"""
``RCPSS xmm1, xmm2/m32``
``F3 0F 53 /r``
``SSE``
``16/32/64-bit``
"""
VEX_VRCPSS_XMM_XMM_XMMM32: int = 1287
"""
``VRCPSS xmm1, xmm2, xmm3/m32``
``VEX.LIG.F3.0F.WIG 53 /r``
``AVX``
``16/32/64-bit``
"""
ANDPS_XMM_XMMM128: int = 1288
"""
``ANDPS xmm1, xmm2/m128``
``NP 0F 54 /r``
``SSE``
``16/32/64-bit``
"""
VEX_VANDPS_XMM_XMM_XMMM128: int = 1289
"""
``VANDPS xmm1, xmm2, xmm3/m128``
``VEX.128.0F.WIG 54 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VANDPS_YMM_YMM_YMMM256: int = 1290
"""
``VANDPS ymm1, ymm2, ymm3/m256``
``VEX.256.0F.WIG 54 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VANDPS_XMM_K1Z_XMM_XMMM128B32: int = 1291
"""
``VANDPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.0F.W0 54 /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VANDPS_YMM_K1Z_YMM_YMMM256B32: int = 1292
"""
``VANDPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.0F.W0 54 /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VANDPS_ZMM_K1Z_ZMM_ZMMM512B32: int = 1293
"""
``VANDPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.0F.W0 54 /r``
``AVX512DQ``
``16/32/64-bit``
"""
ANDPD_XMM_XMMM128: int = 1294
"""
``ANDPD xmm1, xmm2/m128``
``66 0F 54 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VANDPD_XMM_XMM_XMMM128: int = 1295
"""
``VANDPD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG 54 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VANDPD_YMM_YMM_YMMM256: int = 1296
"""
``VANDPD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG 54 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VANDPD_XMM_K1Z_XMM_XMMM128B64: int = 1297
"""
``VANDPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F.W1 54 /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VANDPD_YMM_K1Z_YMM_YMMM256B64: int = 1298
"""
``VANDPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F.W1 54 /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VANDPD_ZMM_K1Z_ZMM_ZMMM512B64: int = 1299
"""
``VANDPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F.W1 54 /r``
``AVX512DQ``
``16/32/64-bit``
"""
ANDNPS_XMM_XMMM128: int = 1300
"""
``ANDNPS xmm1, xmm2/m128``
``NP 0F 55 /r``
``SSE``
``16/32/64-bit``
"""
VEX_VANDNPS_XMM_XMM_XMMM128: int = 1301
"""
``VANDNPS xmm1, xmm2, xmm3/m128``
``VEX.128.0F.WIG 55 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VANDNPS_YMM_YMM_YMMM256: int = 1302
"""
``VANDNPS ymm1, ymm2, ymm3/m256``
``VEX.256.0F.WIG 55 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VANDNPS_XMM_K1Z_XMM_XMMM128B32: int = 1303
"""
``VANDNPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.0F.W0 55 /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VANDNPS_YMM_K1Z_YMM_YMMM256B32: int = 1304
"""
``VANDNPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.0F.W0 55 /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VANDNPS_ZMM_K1Z_ZMM_ZMMM512B32: int = 1305
"""
``VANDNPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.0F.W0 55 /r``
``AVX512DQ``
``16/32/64-bit``
"""
ANDNPD_XMM_XMMM128: int = 1306
"""
``ANDNPD xmm1, xmm2/m128``
``66 0F 55 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VANDNPD_XMM_XMM_XMMM128: int = 1307
"""
``VANDNPD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG 55 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VANDNPD_YMM_YMM_YMMM256: int = 1308
"""
``VANDNPD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG 55 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VANDNPD_XMM_K1Z_XMM_XMMM128B64: int = 1309
"""
``VANDNPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F.W1 55 /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VANDNPD_YMM_K1Z_YMM_YMMM256B64: int = 1310
"""
``VANDNPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F.W1 55 /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VANDNPD_ZMM_K1Z_ZMM_ZMMM512B64: int = 1311
"""
``VANDNPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F.W1 55 /r``
``AVX512DQ``
``16/32/64-bit``
"""
ORPS_XMM_XMMM128: int = 1312
"""
``ORPS xmm1, xmm2/m128``
``NP 0F 56 /r``
``SSE``
``16/32/64-bit``
"""
VEX_VORPS_XMM_XMM_XMMM128: int = 1313
"""
``VORPS xmm1, xmm2, xmm3/m128``
``VEX.128.0F.WIG 56 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VORPS_YMM_YMM_YMMM256: int = 1314
"""
``VORPS ymm1, ymm2, ymm3/m256``
``VEX.256.0F.WIG 56 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VORPS_XMM_K1Z_XMM_XMMM128B32: int = 1315
"""
``VORPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.0F.W0 56 /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VORPS_YMM_K1Z_YMM_YMMM256B32: int = 1316
"""
``VORPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.0F.W0 56 /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VORPS_ZMM_K1Z_ZMM_ZMMM512B32: int = 1317
"""
``VORPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.0F.W0 56 /r``
``AVX512DQ``
``16/32/64-bit``
"""
ORPD_XMM_XMMM128: int = 1318
"""
``ORPD xmm1, xmm2/m128``
``66 0F 56 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VORPD_XMM_XMM_XMMM128: int = 1319
"""
``VORPD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG 56 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VORPD_YMM_YMM_YMMM256: int = 1320
"""
``VORPD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG 56 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VORPD_XMM_K1Z_XMM_XMMM128B64: int = 1321
"""
``VORPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F.W1 56 /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VORPD_YMM_K1Z_YMM_YMMM256B64: int = 1322
"""
``VORPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F.W1 56 /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VORPD_ZMM_K1Z_ZMM_ZMMM512B64: int = 1323
"""
``VORPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F.W1 56 /r``
``AVX512DQ``
``16/32/64-bit``
"""
XORPS_XMM_XMMM128: int = 1324
"""
``XORPS xmm1, xmm2/m128``
``NP 0F 57 /r``
``SSE``
``16/32/64-bit``
"""
VEX_VXORPS_XMM_XMM_XMMM128: int = 1325
"""
``VXORPS xmm1, xmm2, xmm3/m128``
``VEX.128.0F.WIG 57 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VXORPS_YMM_YMM_YMMM256: int = 1326
"""
``VXORPS ymm1, ymm2, ymm3/m256``
``VEX.256.0F.WIG 57 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VXORPS_XMM_K1Z_XMM_XMMM128B32: int = 1327
"""
``VXORPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.0F.W0 57 /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VXORPS_YMM_K1Z_YMM_YMMM256B32: int = 1328
"""
``VXORPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.0F.W0 57 /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VXORPS_ZMM_K1Z_ZMM_ZMMM512B32: int = 1329
"""
``VXORPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.0F.W0 57 /r``
``AVX512DQ``
``16/32/64-bit``
"""
XORPD_XMM_XMMM128: int = 1330
"""
``XORPD xmm1, xmm2/m128``
``66 0F 57 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VXORPD_XMM_XMM_XMMM128: int = 1331
"""
``VXORPD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG 57 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VXORPD_YMM_YMM_YMMM256: int = 1332
"""
``VXORPD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG 57 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VXORPD_XMM_K1Z_XMM_XMMM128B64: int = 1333
"""
``VXORPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F.W1 57 /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VXORPD_YMM_K1Z_YMM_YMMM256B64: int = 1334
"""
``VXORPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F.W1 57 /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VXORPD_ZMM_K1Z_ZMM_ZMMM512B64: int = 1335
"""
``VXORPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F.W1 57 /r``
``AVX512DQ``
``16/32/64-bit``
"""
ADDPS_XMM_XMMM128: int = 1336
"""
``ADDPS xmm1, xmm2/m128``
``NP 0F 58 /r``
``SSE``
``16/32/64-bit``
"""
VEX_VADDPS_XMM_XMM_XMMM128: int = 1337
"""
``VADDPS xmm1, xmm2, xmm3/m128``
``VEX.128.0F.WIG 58 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VADDPS_YMM_YMM_YMMM256: int = 1338
"""
``VADDPS ymm1, ymm2, ymm3/m256``
``VEX.256.0F.WIG 58 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VADDPS_XMM_K1Z_XMM_XMMM128B32: int = 1339
"""
``VADDPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.0F.W0 58 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VADDPS_YMM_K1Z_YMM_YMMM256B32: int = 1340
"""
``VADDPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.0F.W0 58 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VADDPS_ZMM_K1Z_ZMM_ZMMM512B32_ER: int = 1341
"""
``VADDPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}``
``EVEX.512.0F.W0 58 /r``
``AVX512F``
``16/32/64-bit``
"""
ADDPD_XMM_XMMM128: int = 1342
"""
``ADDPD xmm1, xmm2/m128``
``66 0F 58 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VADDPD_XMM_XMM_XMMM128: int = 1343
"""
``VADDPD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG 58 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VADDPD_YMM_YMM_YMMM256: int = 1344
"""
``VADDPD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG 58 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VADDPD_XMM_K1Z_XMM_XMMM128B64: int = 1345
"""
``VADDPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F.W1 58 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VADDPD_YMM_K1Z_YMM_YMMM256B64: int = 1346
"""
``VADDPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F.W1 58 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VADDPD_ZMM_K1Z_ZMM_ZMMM512B64_ER: int = 1347
"""
``VADDPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}``
``EVEX.512.66.0F.W1 58 /r``
``AVX512F``
``16/32/64-bit``
"""
ADDSS_XMM_XMMM32: int = 1348
"""
``ADDSS xmm1, xmm2/m32``
``F3 0F 58 /r``
``SSE``
``16/32/64-bit``
"""
VEX_VADDSS_XMM_XMM_XMMM32: int = 1349
"""
``VADDSS xmm1, xmm2, xmm3/m32``
``VEX.LIG.F3.0F.WIG 58 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VADDSS_XMM_K1Z_XMM_XMMM32_ER: int = 1350
"""
``VADDSS xmm1 {k1}{z}, xmm2, xmm3/m32{er}``
``EVEX.LIG.F3.0F.W0 58 /r``
``AVX512F``
``16/32/64-bit``
"""
ADDSD_XMM_XMMM64: int = 1351
"""
``ADDSD xmm1, xmm2/m64``
``F2 0F 58 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VADDSD_XMM_XMM_XMMM64: int = 1352
"""
``VADDSD xmm1, xmm2, xmm3/m64``
``VEX.LIG.F2.0F.WIG 58 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VADDSD_XMM_K1Z_XMM_XMMM64_ER: int = 1353
"""
``VADDSD xmm1 {k1}{z}, xmm2, xmm3/m64{er}``
``EVEX.LIG.F2.0F.W1 58 /r``
``AVX512F``
``16/32/64-bit``
"""
MULPS_XMM_XMMM128: int = 1354
"""
``MULPS xmm1, xmm2/m128``
``NP 0F 59 /r``
``SSE``
``16/32/64-bit``
"""
VEX_VMULPS_XMM_XMM_XMMM128: int = 1355
"""
``VMULPS xmm1, xmm2, xmm3/m128``
``VEX.128.0F.WIG 59 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VMULPS_YMM_YMM_YMMM256: int = 1356
"""
``VMULPS ymm1, ymm2, ymm3/m256``
``VEX.256.0F.WIG 59 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMULPS_XMM_K1Z_XMM_XMMM128B32: int = 1357
"""
``VMULPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.0F.W0 59 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMULPS_YMM_K1Z_YMM_YMMM256B32: int = 1358
"""
``VMULPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.0F.W0 59 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMULPS_ZMM_K1Z_ZMM_ZMMM512B32_ER: int = 1359
"""
``VMULPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}``
``EVEX.512.0F.W0 59 /r``
``AVX512F``
``16/32/64-bit``
"""
MULPD_XMM_XMMM128: int = 1360
"""
``MULPD xmm1, xmm2/m128``
``66 0F 59 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VMULPD_XMM_XMM_XMMM128: int = 1361
"""
``VMULPD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG 59 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VMULPD_YMM_YMM_YMMM256: int = 1362
"""
``VMULPD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG 59 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMULPD_XMM_K1Z_XMM_XMMM128B64: int = 1363
"""
``VMULPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F.W1 59 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMULPD_YMM_K1Z_YMM_YMMM256B64: int = 1364
"""
``VMULPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F.W1 59 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMULPD_ZMM_K1Z_ZMM_ZMMM512B64_ER: int = 1365
"""
``VMULPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}``
``EVEX.512.66.0F.W1 59 /r``
``AVX512F``
``16/32/64-bit``
"""
MULSS_XMM_XMMM32: int = 1366
"""
``MULSS xmm1, xmm2/m32``
``F3 0F 59 /r``
``SSE``
``16/32/64-bit``
"""
VEX_VMULSS_XMM_XMM_XMMM32: int = 1367
"""
``VMULSS xmm1, xmm2, xmm3/m32``
``VEX.LIG.F3.0F.WIG 59 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMULSS_XMM_K1Z_XMM_XMMM32_ER: int = 1368
"""
``VMULSS xmm1 {k1}{z}, xmm2, xmm3/m32{er}``
``EVEX.LIG.F3.0F.W0 59 /r``
``AVX512F``
``16/32/64-bit``
"""
MULSD_XMM_XMMM64: int = 1369
"""
``MULSD xmm1, xmm2/m64``
``F2 0F 59 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VMULSD_XMM_XMM_XMMM64: int = 1370
"""
``VMULSD xmm1, xmm2, xmm3/m64``
``VEX.LIG.F2.0F.WIG 59 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMULSD_XMM_K1Z_XMM_XMMM64_ER: int = 1371
"""
``VMULSD xmm1 {k1}{z}, xmm2, xmm3/m64{er}``
``EVEX.LIG.F2.0F.W1 59 /r``
``AVX512F``
``16/32/64-bit``
"""
CVTPS2PD_XMM_XMMM64: int = 1372
"""
``CVTPS2PD xmm1, xmm2/m64``
``NP 0F 5A /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VCVTPS2PD_XMM_XMMM64: int = 1373
"""
``VCVTPS2PD xmm1, xmm2/m64``
``VEX.128.0F.WIG 5A /r``
``AVX``
``16/32/64-bit``
"""
VEX_VCVTPS2PD_YMM_XMMM128: int = 1374
"""
``VCVTPS2PD ymm1, xmm2/m128``
``VEX.256.0F.WIG 5A /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VCVTPS2PD_XMM_K1Z_XMMM64B32: int = 1375
"""
``VCVTPS2PD xmm1 {k1}{z}, xmm2/m64/m32bcst``
``EVEX.128.0F.W0 5A /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTPS2PD_YMM_K1Z_XMMM128B32: int = 1376
"""
``VCVTPS2PD ymm1 {k1}{z}, xmm2/m128/m32bcst``
``EVEX.256.0F.W0 5A /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTPS2PD_ZMM_K1Z_YMMM256B32_SAE: int = 1377
"""
``VCVTPS2PD zmm1 {k1}{z}, ymm2/m256/m32bcst{sae}``
``EVEX.512.0F.W0 5A /r``
``AVX512F``
``16/32/64-bit``
"""
CVTPD2PS_XMM_XMMM128: int = 1378
"""
``CVTPD2PS xmm1, xmm2/m128``
``66 0F 5A /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VCVTPD2PS_XMM_XMMM128: int = 1379
"""
``VCVTPD2PS xmm1, xmm2/m128``
``VEX.128.66.0F.WIG 5A /r``
``AVX``
``16/32/64-bit``
"""
VEX_VCVTPD2PS_XMM_YMMM256: int = 1380
"""
``VCVTPD2PS xmm1, ymm2/m256``
``VEX.256.66.0F.WIG 5A /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VCVTPD2PS_XMM_K1Z_XMMM128B64: int = 1381
"""
``VCVTPD2PS xmm1 {k1}{z}, xmm2/m128/m64bcst``
``EVEX.128.66.0F.W1 5A /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTPD2PS_XMM_K1Z_YMMM256B64: int = 1382
"""
``VCVTPD2PS xmm1 {k1}{z}, ymm2/m256/m64bcst``
``EVEX.256.66.0F.W1 5A /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTPD2PS_YMM_K1Z_ZMMM512B64_ER: int = 1383
"""
``VCVTPD2PS ymm1 {k1}{z}, zmm2/m512/m64bcst{er}``
``EVEX.512.66.0F.W1 5A /r``
``AVX512F``
``16/32/64-bit``
"""
CVTSS2SD_XMM_XMMM32: int = 1384
"""
``CVTSS2SD xmm1, xmm2/m32``
``F3 0F 5A /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VCVTSS2SD_XMM_XMM_XMMM32: int = 1385
"""
``VCVTSS2SD xmm1, xmm2, xmm3/m32``
``VEX.LIG.F3.0F.WIG 5A /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VCVTSS2SD_XMM_K1Z_XMM_XMMM32_SAE: int = 1386
"""
``VCVTSS2SD xmm1 {k1}{z}, xmm2, xmm3/m32{sae}``
``EVEX.LIG.F3.0F.W0 5A /r``
``AVX512F``
``16/32/64-bit``
"""
CVTSD2SS_XMM_XMMM64: int = 1387
"""
``CVTSD2SS xmm1, xmm2/m64``
``F2 0F 5A /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VCVTSD2SS_XMM_XMM_XMMM64: int = 1388
"""
``VCVTSD2SS xmm1, xmm2, xmm3/m64``
``VEX.LIG.F2.0F.WIG 5A /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VCVTSD2SS_XMM_K1Z_XMM_XMMM64_ER: int = 1389
"""
``VCVTSD2SS xmm1 {k1}{z}, xmm2, xmm3/m64{er}``
``EVEX.LIG.F2.0F.W1 5A /r``
``AVX512F``
``16/32/64-bit``
"""
CVTDQ2PS_XMM_XMMM128: int = 1390
"""
``CVTDQ2PS xmm1, xmm2/m128``
``NP 0F 5B /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VCVTDQ2PS_XMM_XMMM128: int = 1391
"""
``VCVTDQ2PS xmm1, xmm2/m128``
``VEX.128.0F.WIG 5B /r``
``AVX``
``16/32/64-bit``
"""
VEX_VCVTDQ2PS_YMM_YMMM256: int = 1392
"""
``VCVTDQ2PS ymm1, ymm2/m256``
``VEX.256.0F.WIG 5B /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VCVTDQ2PS_XMM_K1Z_XMMM128B32: int = 1393
"""
``VCVTDQ2PS xmm1 {k1}{z}, xmm2/m128/m32bcst``
``EVEX.128.0F.W0 5B /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTDQ2PS_YMM_K1Z_YMMM256B32: int = 1394
"""
``VCVTDQ2PS ymm1 {k1}{z}, ymm2/m256/m32bcst``
``EVEX.256.0F.W0 5B /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTDQ2PS_ZMM_K1Z_ZMMM512B32_ER: int = 1395
"""
``VCVTDQ2PS zmm1 {k1}{z}, zmm2/m512/m32bcst{er}``
``EVEX.512.0F.W0 5B /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTQQ2PS_XMM_K1Z_XMMM128B64: int = 1396
"""
``VCVTQQ2PS xmm1 {k1}{z}, xmm2/m128/m64bcst``
``EVEX.128.0F.W1 5B /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VCVTQQ2PS_XMM_K1Z_YMMM256B64: int = 1397
"""
``VCVTQQ2PS xmm1 {k1}{z}, ymm2/m256/m64bcst``
``EVEX.256.0F.W1 5B /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VCVTQQ2PS_YMM_K1Z_ZMMM512B64_ER: int = 1398
"""
``VCVTQQ2PS ymm1 {k1}{z}, zmm2/m512/m64bcst{er}``
``EVEX.512.0F.W1 5B /r``
``AVX512DQ``
``16/32/64-bit``
"""
CVTPS2DQ_XMM_XMMM128: int = 1399
"""
``CVTPS2DQ xmm1, xmm2/m128``
``66 0F 5B /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VCVTPS2DQ_XMM_XMMM128: int = 1400
"""
``VCVTPS2DQ xmm1, xmm2/m128``
``VEX.128.66.0F.WIG 5B /r``
``AVX``
``16/32/64-bit``
"""
VEX_VCVTPS2DQ_YMM_YMMM256: int = 1401
"""
``VCVTPS2DQ ymm1, ymm2/m256``
``VEX.256.66.0F.WIG 5B /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VCVTPS2DQ_XMM_K1Z_XMMM128B32: int = 1402
"""
``VCVTPS2DQ xmm1 {k1}{z}, xmm2/m128/m32bcst``
``EVEX.128.66.0F.W0 5B /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTPS2DQ_YMM_K1Z_YMMM256B32: int = 1403
"""
``VCVTPS2DQ ymm1 {k1}{z}, ymm2/m256/m32bcst``
``EVEX.256.66.0F.W0 5B /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTPS2DQ_ZMM_K1Z_ZMMM512B32_ER: int = 1404
"""
``VCVTPS2DQ zmm1 {k1}{z}, zmm2/m512/m32bcst{er}``
``EVEX.512.66.0F.W0 5B /r``
``AVX512F``
``16/32/64-bit``
"""
CVTTPS2DQ_XMM_XMMM128: int = 1405
"""
``CVTTPS2DQ xmm1, xmm2/m128``
``F3 0F 5B /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VCVTTPS2DQ_XMM_XMMM128: int = 1406
"""
``VCVTTPS2DQ xmm1, xmm2/m128``
``VEX.128.F3.0F.WIG 5B /r``
``AVX``
``16/32/64-bit``
"""
VEX_VCVTTPS2DQ_YMM_YMMM256: int = 1407
"""
``VCVTTPS2DQ ymm1, ymm2/m256``
``VEX.256.F3.0F.WIG 5B /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VCVTTPS2DQ_XMM_K1Z_XMMM128B32: int = 1408
"""
``VCVTTPS2DQ xmm1 {k1}{z}, xmm2/m128/m32bcst``
``EVEX.128.F3.0F.W0 5B /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTTPS2DQ_YMM_K1Z_YMMM256B32: int = 1409
"""
``VCVTTPS2DQ ymm1 {k1}{z}, ymm2/m256/m32bcst``
``EVEX.256.F3.0F.W0 5B /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTTPS2DQ_ZMM_K1Z_ZMMM512B32_SAE: int = 1410
"""
``VCVTTPS2DQ zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}``
``EVEX.512.F3.0F.W0 5B /r``
``AVX512F``
``16/32/64-bit``
"""
SUBPS_XMM_XMMM128: int = 1411
"""
``SUBPS xmm1, xmm2/m128``
``NP 0F 5C /r``
``SSE``
``16/32/64-bit``
"""
VEX_VSUBPS_XMM_XMM_XMMM128: int = 1412
"""
``VSUBPS xmm1, xmm2, xmm3/m128``
``VEX.128.0F.WIG 5C /r``
``AVX``
``16/32/64-bit``
"""
VEX_VSUBPS_YMM_YMM_YMMM256: int = 1413
"""
``VSUBPS ymm1, ymm2, ymm3/m256``
``VEX.256.0F.WIG 5C /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VSUBPS_XMM_K1Z_XMM_XMMM128B32: int = 1414
"""
``VSUBPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.0F.W0 5C /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VSUBPS_YMM_K1Z_YMM_YMMM256B32: int = 1415
"""
``VSUBPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.0F.W0 5C /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VSUBPS_ZMM_K1Z_ZMM_ZMMM512B32_ER: int = 1416
"""
``VSUBPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}``
``EVEX.512.0F.W0 5C /r``
``AVX512F``
``16/32/64-bit``
"""
SUBPD_XMM_XMMM128: int = 1417
"""
``SUBPD xmm1, xmm2/m128``
``66 0F 5C /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VSUBPD_XMM_XMM_XMMM128: int = 1418
"""
``VSUBPD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG 5C /r``
``AVX``
``16/32/64-bit``
"""
VEX_VSUBPD_YMM_YMM_YMMM256: int = 1419
"""
``VSUBPD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG 5C /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VSUBPD_XMM_K1Z_XMM_XMMM128B64: int = 1420
"""
``VSUBPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F.W1 5C /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VSUBPD_YMM_K1Z_YMM_YMMM256B64: int = 1421
"""
``VSUBPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F.W1 5C /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VSUBPD_ZMM_K1Z_ZMM_ZMMM512B64_ER: int = 1422
"""
``VSUBPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}``
``EVEX.512.66.0F.W1 5C /r``
``AVX512F``
``16/32/64-bit``
"""
SUBSS_XMM_XMMM32: int = 1423
"""
``SUBSS xmm1, xmm2/m32``
``F3 0F 5C /r``
``SSE``
``16/32/64-bit``
"""
VEX_VSUBSS_XMM_XMM_XMMM32: int = 1424
"""
``VSUBSS xmm1, xmm2, xmm3/m32``
``VEX.LIG.F3.0F.WIG 5C /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VSUBSS_XMM_K1Z_XMM_XMMM32_ER: int = 1425
"""
``VSUBSS xmm1 {k1}{z}, xmm2, xmm3/m32{er}``
``EVEX.LIG.F3.0F.W0 5C /r``
``AVX512F``
``16/32/64-bit``
"""
SUBSD_XMM_XMMM64: int = 1426
"""
``SUBSD xmm1, xmm2/m64``
``F2 0F 5C /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VSUBSD_XMM_XMM_XMMM64: int = 1427
"""
``VSUBSD xmm1, xmm2, xmm3/m64``
``VEX.LIG.F2.0F.WIG 5C /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VSUBSD_XMM_K1Z_XMM_XMMM64_ER: int = 1428
"""
``VSUBSD xmm1 {k1}{z}, xmm2, xmm3/m64{er}``
``EVEX.LIG.F2.0F.W1 5C /r``
``AVX512F``
``16/32/64-bit``
"""
MINPS_XMM_XMMM128: int = 1429
"""
``MINPS xmm1, xmm2/m128``
``NP 0F 5D /r``
``SSE``
``16/32/64-bit``
"""
VEX_VMINPS_XMM_XMM_XMMM128: int = 1430
"""
``VMINPS xmm1, xmm2, xmm3/m128``
``VEX.128.0F.WIG 5D /r``
``AVX``
``16/32/64-bit``
"""
VEX_VMINPS_YMM_YMM_YMMM256: int = 1431
"""
``VMINPS ymm1, ymm2, ymm3/m256``
``VEX.256.0F.WIG 5D /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMINPS_XMM_K1Z_XMM_XMMM128B32: int = 1432
"""
``VMINPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.0F.W0 5D /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMINPS_YMM_K1Z_YMM_YMMM256B32: int = 1433
"""
``VMINPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.0F.W0 5D /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMINPS_ZMM_K1Z_ZMM_ZMMM512B32_SAE: int = 1434
"""
``VMINPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{sae}``
``EVEX.512.0F.W0 5D /r``
``AVX512F``
``16/32/64-bit``
"""
MINPD_XMM_XMMM128: int = 1435
"""
``MINPD xmm1, xmm2/m128``
``66 0F 5D /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VMINPD_XMM_XMM_XMMM128: int = 1436
"""
``VMINPD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG 5D /r``
``AVX``
``16/32/64-bit``
"""
VEX_VMINPD_YMM_YMM_YMMM256: int = 1437
"""
``VMINPD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG 5D /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMINPD_XMM_K1Z_XMM_XMMM128B64: int = 1438
"""
``VMINPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F.W1 5D /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMINPD_YMM_K1Z_YMM_YMMM256B64: int = 1439
"""
``VMINPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F.W1 5D /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMINPD_ZMM_K1Z_ZMM_ZMMM512B64_SAE: int = 1440
"""
``VMINPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{sae}``
``EVEX.512.66.0F.W1 5D /r``
``AVX512F``
``16/32/64-bit``
"""
MINSS_XMM_XMMM32: int = 1441
"""
``MINSS xmm1, xmm2/m32``
``F3 0F 5D /r``
``SSE``
``16/32/64-bit``
"""
VEX_VMINSS_XMM_XMM_XMMM32: int = 1442
"""
``VMINSS xmm1, xmm2, xmm3/m32``
``VEX.LIG.F3.0F.WIG 5D /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMINSS_XMM_K1Z_XMM_XMMM32_SAE: int = 1443
"""
``VMINSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}``
``EVEX.LIG.F3.0F.W0 5D /r``
``AVX512F``
``16/32/64-bit``
"""
MINSD_XMM_XMMM64: int = 1444
"""
``MINSD xmm1, xmm2/m64``
``F2 0F 5D /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VMINSD_XMM_XMM_XMMM64: int = 1445
"""
``VMINSD xmm1, xmm2, xmm3/m64``
``VEX.LIG.F2.0F.WIG 5D /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMINSD_XMM_K1Z_XMM_XMMM64_SAE: int = 1446
"""
``VMINSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}``
``EVEX.LIG.F2.0F.W1 5D /r``
``AVX512F``
``16/32/64-bit``
"""
DIVPS_XMM_XMMM128: int = 1447
"""
``DIVPS xmm1, xmm2/m128``
``NP 0F 5E /r``
``SSE``
``16/32/64-bit``
"""
VEX_VDIVPS_XMM_XMM_XMMM128: int = 1448
"""
``VDIVPS xmm1, xmm2, xmm3/m128``
``VEX.128.0F.WIG 5E /r``
``AVX``
``16/32/64-bit``
"""
VEX_VDIVPS_YMM_YMM_YMMM256: int = 1449
"""
``VDIVPS ymm1, ymm2, ymm3/m256``
``VEX.256.0F.WIG 5E /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VDIVPS_XMM_K1Z_XMM_XMMM128B32: int = 1450
"""
``VDIVPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.0F.W0 5E /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VDIVPS_YMM_K1Z_YMM_YMMM256B32: int = 1451
"""
``VDIVPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.0F.W0 5E /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VDIVPS_ZMM_K1Z_ZMM_ZMMM512B32_ER: int = 1452
"""
``VDIVPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}``
``EVEX.512.0F.W0 5E /r``
``AVX512F``
``16/32/64-bit``
"""
DIVPD_XMM_XMMM128: int = 1453
"""
``DIVPD xmm1, xmm2/m128``
``66 0F 5E /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VDIVPD_XMM_XMM_XMMM128: int = 1454
"""
``VDIVPD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG 5E /r``
``AVX``
``16/32/64-bit``
"""
VEX_VDIVPD_YMM_YMM_YMMM256: int = 1455
"""
``VDIVPD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG 5E /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VDIVPD_XMM_K1Z_XMM_XMMM128B64: int = 1456
"""
``VDIVPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F.W1 5E /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VDIVPD_YMM_K1Z_YMM_YMMM256B64: int = 1457
"""
``VDIVPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F.W1 5E /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VDIVPD_ZMM_K1Z_ZMM_ZMMM512B64_ER: int = 1458
"""
``VDIVPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}``
``EVEX.512.66.0F.W1 5E /r``
``AVX512F``
``16/32/64-bit``
"""
DIVSS_XMM_XMMM32: int = 1459
"""
``DIVSS xmm1, xmm2/m32``
``F3 0F 5E /r``
``SSE``
``16/32/64-bit``
"""
VEX_VDIVSS_XMM_XMM_XMMM32: int = 1460
"""
``VDIVSS xmm1, xmm2, xmm3/m32``
``VEX.LIG.F3.0F.WIG 5E /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VDIVSS_XMM_K1Z_XMM_XMMM32_ER: int = 1461
"""
``VDIVSS xmm1 {k1}{z}, xmm2, xmm3/m32{er}``
``EVEX.LIG.F3.0F.W0 5E /r``
``AVX512F``
``16/32/64-bit``
"""
DIVSD_XMM_XMMM64: int = 1462
"""
``DIVSD xmm1, xmm2/m64``
``F2 0F 5E /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VDIVSD_XMM_XMM_XMMM64: int = 1463
"""
``VDIVSD xmm1, xmm2, xmm3/m64``
``VEX.LIG.F2.0F.WIG 5E /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VDIVSD_XMM_K1Z_XMM_XMMM64_ER: int = 1464
"""
``VDIVSD xmm1 {k1}{z}, xmm2, xmm3/m64{er}``
``EVEX.LIG.F2.0F.W1 5E /r``
``AVX512F``
``16/32/64-bit``
"""
MAXPS_XMM_XMMM128: int = 1465
"""
``MAXPS xmm1, xmm2/m128``
``NP 0F 5F /r``
``SSE``
``16/32/64-bit``
"""
VEX_VMAXPS_XMM_XMM_XMMM128: int = 1466
"""
``VMAXPS xmm1, xmm2, xmm3/m128``
``VEX.128.0F.WIG 5F /r``
``AVX``
``16/32/64-bit``
"""
VEX_VMAXPS_YMM_YMM_YMMM256: int = 1467
"""
``VMAXPS ymm1, ymm2, ymm3/m256``
``VEX.256.0F.WIG 5F /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMAXPS_XMM_K1Z_XMM_XMMM128B32: int = 1468
"""
``VMAXPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.0F.W0 5F /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMAXPS_YMM_K1Z_YMM_YMMM256B32: int = 1469
"""
``VMAXPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.0F.W0 5F /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMAXPS_ZMM_K1Z_ZMM_ZMMM512B32_SAE: int = 1470
"""
``VMAXPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{sae}``
``EVEX.512.0F.W0 5F /r``
``AVX512F``
``16/32/64-bit``
"""
MAXPD_XMM_XMMM128: int = 1471
"""
``MAXPD xmm1, xmm2/m128``
``66 0F 5F /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VMAXPD_XMM_XMM_XMMM128: int = 1472
"""
``VMAXPD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG 5F /r``
``AVX``
``16/32/64-bit``
"""
VEX_VMAXPD_YMM_YMM_YMMM256: int = 1473
"""
``VMAXPD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG 5F /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMAXPD_XMM_K1Z_XMM_XMMM128B64: int = 1474
"""
``VMAXPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F.W1 5F /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMAXPD_YMM_K1Z_YMM_YMMM256B64: int = 1475
"""
``VMAXPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F.W1 5F /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMAXPD_ZMM_K1Z_ZMM_ZMMM512B64_SAE: int = 1476
"""
``VMAXPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{sae}``
``EVEX.512.66.0F.W1 5F /r``
``AVX512F``
``16/32/64-bit``
"""
MAXSS_XMM_XMMM32: int = 1477
"""
``MAXSS xmm1, xmm2/m32``
``F3 0F 5F /r``
``SSE``
``16/32/64-bit``
"""
VEX_VMAXSS_XMM_XMM_XMMM32: int = 1478
"""
``VMAXSS xmm1, xmm2, xmm3/m32``
``VEX.LIG.F3.0F.WIG 5F /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMAXSS_XMM_K1Z_XMM_XMMM32_SAE: int = 1479
"""
``VMAXSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}``
``EVEX.LIG.F3.0F.W0 5F /r``
``AVX512F``
``16/32/64-bit``
"""
MAXSD_XMM_XMMM64: int = 1480
"""
``MAXSD xmm1, xmm2/m64``
``F2 0F 5F /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VMAXSD_XMM_XMM_XMMM64: int = 1481
"""
``VMAXSD xmm1, xmm2, xmm3/m64``
``VEX.LIG.F2.0F.WIG 5F /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMAXSD_XMM_K1Z_XMM_XMMM64_SAE: int = 1482
"""
``VMAXSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}``
``EVEX.LIG.F2.0F.W1 5F /r``
``AVX512F``
``16/32/64-bit``
"""
PUNPCKLBW_MM_MMM32: int = 1483
"""
``PUNPCKLBW mm, mm/m32``
``NP 0F 60 /r``
``MMX``
``16/32/64-bit``
"""
PUNPCKLBW_XMM_XMMM128: int = 1484
"""
``PUNPCKLBW xmm1, xmm2/m128``
``66 0F 60 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPUNPCKLBW_XMM_XMM_XMMM128: int = 1485
"""
``VPUNPCKLBW xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG 60 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPUNPCKLBW_YMM_YMM_YMMM256: int = 1486
"""
``VPUNPCKLBW ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG 60 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPUNPCKLBW_XMM_K1Z_XMM_XMMM128: int = 1487
"""
``VPUNPCKLBW xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F.WIG 60 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPUNPCKLBW_YMM_K1Z_YMM_YMMM256: int = 1488
"""
``VPUNPCKLBW ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F.WIG 60 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPUNPCKLBW_ZMM_K1Z_ZMM_ZMMM512: int = 1489
"""
``VPUNPCKLBW zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F.WIG 60 /r``
``AVX512BW``
``16/32/64-bit``
"""
PUNPCKLWD_MM_MMM32: int = 1490
"""
``PUNPCKLWD mm, mm/m32``
``NP 0F 61 /r``
``MMX``
``16/32/64-bit``
"""
PUNPCKLWD_XMM_XMMM128: int = 1491
"""
``PUNPCKLWD xmm1, xmm2/m128``
``66 0F 61 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPUNPCKLWD_XMM_XMM_XMMM128: int = 1492
"""
``VPUNPCKLWD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG 61 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPUNPCKLWD_YMM_YMM_YMMM256: int = 1493
"""
``VPUNPCKLWD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG 61 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPUNPCKLWD_XMM_K1Z_XMM_XMMM128: int = 1494
"""
``VPUNPCKLWD xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F.WIG 61 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPUNPCKLWD_YMM_K1Z_YMM_YMMM256: int = 1495
"""
``VPUNPCKLWD ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F.WIG 61 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPUNPCKLWD_ZMM_K1Z_ZMM_ZMMM512: int = 1496
"""
``VPUNPCKLWD zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F.WIG 61 /r``
``AVX512BW``
``16/32/64-bit``
"""
PUNPCKLDQ_MM_MMM32: int = 1497
"""
``PUNPCKLDQ mm, mm/m32``
``NP 0F 62 /r``
``MMX``
``16/32/64-bit``
"""
PUNPCKLDQ_XMM_XMMM128: int = 1498
"""
``PUNPCKLDQ xmm1, xmm2/m128``
``66 0F 62 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPUNPCKLDQ_XMM_XMM_XMMM128: int = 1499
"""
``VPUNPCKLDQ xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG 62 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPUNPCKLDQ_YMM_YMM_YMMM256: int = 1500
"""
``VPUNPCKLDQ ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG 62 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPUNPCKLDQ_XMM_K1Z_XMM_XMMM128B32: int = 1501
"""
``VPUNPCKLDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F.W0 62 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPUNPCKLDQ_YMM_K1Z_YMM_YMMM256B32: int = 1502
"""
``VPUNPCKLDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F.W0 62 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPUNPCKLDQ_ZMM_K1Z_ZMM_ZMMM512B32: int = 1503
"""
``VPUNPCKLDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.66.0F.W0 62 /r``
``AVX512F``
``16/32/64-bit``
"""
PACKSSWB_MM_MMM64: int = 1504
"""
``PACKSSWB mm1, mm2/m64``
``NP 0F 63 /r``
``MMX``
``16/32/64-bit``
"""
PACKSSWB_XMM_XMMM128: int = 1505
"""
``PACKSSWB xmm1, xmm2/m128``
``66 0F 63 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPACKSSWB_XMM_XMM_XMMM128: int = 1506
"""
``VPACKSSWB xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG 63 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPACKSSWB_YMM_YMM_YMMM256: int = 1507
"""
``VPACKSSWB ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG 63 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPACKSSWB_XMM_K1Z_XMM_XMMM128: int = 1508
"""
``VPACKSSWB xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F.WIG 63 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPACKSSWB_YMM_K1Z_YMM_YMMM256: int = 1509
"""
``VPACKSSWB ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F.WIG 63 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPACKSSWB_ZMM_K1Z_ZMM_ZMMM512: int = 1510
"""
``VPACKSSWB zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F.WIG 63 /r``
``AVX512BW``
``16/32/64-bit``
"""
PCMPGTB_MM_MMM64: int = 1511
"""
``PCMPGTB mm, mm/m64``
``NP 0F 64 /r``
``MMX``
``16/32/64-bit``
"""
PCMPGTB_XMM_XMMM128: int = 1512
"""
``PCMPGTB xmm1, xmm2/m128``
``66 0F 64 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPCMPGTB_XMM_XMM_XMMM128: int = 1513
"""
``VPCMPGTB xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG 64 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPCMPGTB_YMM_YMM_YMMM256: int = 1514
"""
``VPCMPGTB ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG 64 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPCMPGTB_KR_K1_XMM_XMMM128: int = 1515
"""
``VPCMPGTB k1 {k2}, xmm2, xmm3/m128``
``EVEX.128.66.0F.WIG 64 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPCMPGTB_KR_K1_YMM_YMMM256: int = 1516
"""
``VPCMPGTB k1 {k2}, ymm2, ymm3/m256``
``EVEX.256.66.0F.WIG 64 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPCMPGTB_KR_K1_ZMM_ZMMM512: int = 1517
"""
``VPCMPGTB k1 {k2}, zmm2, zmm3/m512``
``EVEX.512.66.0F.WIG 64 /r``
``AVX512BW``
``16/32/64-bit``
"""
PCMPGTW_MM_MMM64: int = 1518
"""
``PCMPGTW mm, mm/m64``
``NP 0F 65 /r``
``MMX``
``16/32/64-bit``
"""
PCMPGTW_XMM_XMMM128: int = 1519
"""
``PCMPGTW xmm1, xmm2/m128``
``66 0F 65 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPCMPGTW_XMM_XMM_XMMM128: int = 1520
"""
``VPCMPGTW xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG 65 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPCMPGTW_YMM_YMM_YMMM256: int = 1521
"""
``VPCMPGTW ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG 65 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPCMPGTW_KR_K1_XMM_XMMM128: int = 1522
"""
``VPCMPGTW k1 {k2}, xmm2, xmm3/m128``
``EVEX.128.66.0F.WIG 65 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPCMPGTW_KR_K1_YMM_YMMM256: int = 1523
"""
``VPCMPGTW k1 {k2}, ymm2, ymm3/m256``
``EVEX.256.66.0F.WIG 65 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPCMPGTW_KR_K1_ZMM_ZMMM512: int = 1524
"""
``VPCMPGTW k1 {k2}, zmm2, zmm3/m512``
``EVEX.512.66.0F.WIG 65 /r``
``AVX512BW``
``16/32/64-bit``
"""
PCMPGTD_MM_MMM64: int = 1525
"""
``PCMPGTD mm, mm/m64``
``NP 0F 66 /r``
``MMX``
``16/32/64-bit``
"""
PCMPGTD_XMM_XMMM128: int = 1526
"""
``PCMPGTD xmm1, xmm2/m128``
``66 0F 66 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPCMPGTD_XMM_XMM_XMMM128: int = 1527
"""
``VPCMPGTD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG 66 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPCMPGTD_YMM_YMM_YMMM256: int = 1528
"""
``VPCMPGTD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG 66 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPCMPGTD_KR_K1_XMM_XMMM128B32: int = 1529
"""
``VPCMPGTD k1 {k2}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F.W0 66 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPCMPGTD_KR_K1_YMM_YMMM256B32: int = 1530
"""
``VPCMPGTD k1 {k2}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F.W0 66 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPCMPGTD_KR_K1_ZMM_ZMMM512B32: int = 1531
"""
``VPCMPGTD k1 {k2}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.66.0F.W0 66 /r``
``AVX512F``
``16/32/64-bit``
"""
PACKUSWB_MM_MMM64: int = 1532
"""
``PACKUSWB mm, mm/m64``
``NP 0F 67 /r``
``MMX``
``16/32/64-bit``
"""
PACKUSWB_XMM_XMMM128: int = 1533
"""
``PACKUSWB xmm1, xmm2/m128``
``66 0F 67 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPACKUSWB_XMM_XMM_XMMM128: int = 1534
"""
``VPACKUSWB xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG 67 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPACKUSWB_YMM_YMM_YMMM256: int = 1535
"""
``VPACKUSWB ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG 67 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPACKUSWB_XMM_K1Z_XMM_XMMM128: int = 1536
"""
``VPACKUSWB xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F.WIG 67 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPACKUSWB_YMM_K1Z_YMM_YMMM256: int = 1537
"""
``VPACKUSWB ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F.WIG 67 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPACKUSWB_ZMM_K1Z_ZMM_ZMMM512: int = 1538
"""
``VPACKUSWB zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F.WIG 67 /r``
``AVX512BW``
``16/32/64-bit``
"""
PUNPCKHBW_MM_MMM64: int = 1539
"""
``PUNPCKHBW mm, mm/m64``
``NP 0F 68 /r``
``MMX``
``16/32/64-bit``
"""
PUNPCKHBW_XMM_XMMM128: int = 1540
"""
``PUNPCKHBW xmm1, xmm2/m128``
``66 0F 68 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPUNPCKHBW_XMM_XMM_XMMM128: int = 1541
"""
``VPUNPCKHBW xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG 68 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPUNPCKHBW_YMM_YMM_YMMM256: int = 1542
"""
``VPUNPCKHBW ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG 68 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPUNPCKHBW_XMM_K1Z_XMM_XMMM128: int = 1543
"""
``VPUNPCKHBW xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F.WIG 68 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPUNPCKHBW_YMM_K1Z_YMM_YMMM256: int = 1544
"""
``VPUNPCKHBW ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F.WIG 68 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPUNPCKHBW_ZMM_K1Z_ZMM_ZMMM512: int = 1545
"""
``VPUNPCKHBW zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F.WIG 68 /r``
``AVX512BW``
``16/32/64-bit``
"""
PUNPCKHWD_MM_MMM64: int = 1546
"""
``PUNPCKHWD mm, mm/m64``
``NP 0F 69 /r``
``MMX``
``16/32/64-bit``
"""
PUNPCKHWD_XMM_XMMM128: int = 1547
"""
``PUNPCKHWD xmm1, xmm2/m128``
``66 0F 69 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPUNPCKHWD_XMM_XMM_XMMM128: int = 1548
"""
``VPUNPCKHWD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG 69 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPUNPCKHWD_YMM_YMM_YMMM256: int = 1549
"""
``VPUNPCKHWD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG 69 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPUNPCKHWD_XMM_K1Z_XMM_XMMM128: int = 1550
"""
``VPUNPCKHWD xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F.WIG 69 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPUNPCKHWD_YMM_K1Z_YMM_YMMM256: int = 1551
"""
``VPUNPCKHWD ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F.WIG 69 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPUNPCKHWD_ZMM_K1Z_ZMM_ZMMM512: int = 1552
"""
``VPUNPCKHWD zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F.WIG 69 /r``
``AVX512BW``
``16/32/64-bit``
"""
PUNPCKHDQ_MM_MMM64: int = 1553
"""
``PUNPCKHDQ mm, mm/m64``
``NP 0F 6A /r``
``MMX``
``16/32/64-bit``
"""
PUNPCKHDQ_XMM_XMMM128: int = 1554
"""
``PUNPCKHDQ xmm1, xmm2/m128``
``66 0F 6A /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPUNPCKHDQ_XMM_XMM_XMMM128: int = 1555
"""
``VPUNPCKHDQ xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG 6A /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPUNPCKHDQ_YMM_YMM_YMMM256: int = 1556
"""
``VPUNPCKHDQ ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG 6A /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPUNPCKHDQ_XMM_K1Z_XMM_XMMM128B32: int = 1557
"""
``VPUNPCKHDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F.W0 6A /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPUNPCKHDQ_YMM_K1Z_YMM_YMMM256B32: int = 1558
"""
``VPUNPCKHDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F.W0 6A /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPUNPCKHDQ_ZMM_K1Z_ZMM_ZMMM512B32: int = 1559
"""
``VPUNPCKHDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.66.0F.W0 6A /r``
``AVX512F``
``16/32/64-bit``
"""
PACKSSDW_MM_MMM64: int = 1560
"""
``PACKSSDW mm1, mm2/m64``
``NP 0F 6B /r``
``MMX``
``16/32/64-bit``
"""
PACKSSDW_XMM_XMMM128: int = 1561
"""
``PACKSSDW xmm1, xmm2/m128``
``66 0F 6B /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPACKSSDW_XMM_XMM_XMMM128: int = 1562
"""
``VPACKSSDW xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG 6B /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPACKSSDW_YMM_YMM_YMMM256: int = 1563
"""
``VPACKSSDW ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG 6B /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPACKSSDW_XMM_K1Z_XMM_XMMM128B32: int = 1564
"""
``VPACKSSDW xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F.W0 6B /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPACKSSDW_YMM_K1Z_YMM_YMMM256B32: int = 1565
"""
``VPACKSSDW ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F.W0 6B /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPACKSSDW_ZMM_K1Z_ZMM_ZMMM512B32: int = 1566
"""
``VPACKSSDW zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.66.0F.W0 6B /r``
``AVX512BW``
``16/32/64-bit``
"""
PUNPCKLQDQ_XMM_XMMM128: int = 1567
"""
``PUNPCKLQDQ xmm1, xmm2/m128``
``66 0F 6C /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPUNPCKLQDQ_XMM_XMM_XMMM128: int = 1568
"""
``VPUNPCKLQDQ xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG 6C /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPUNPCKLQDQ_YMM_YMM_YMMM256: int = 1569
"""
``VPUNPCKLQDQ ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG 6C /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPUNPCKLQDQ_XMM_K1Z_XMM_XMMM128B64: int = 1570
"""
``VPUNPCKLQDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F.W1 6C /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPUNPCKLQDQ_YMM_K1Z_YMM_YMMM256B64: int = 1571
"""
``VPUNPCKLQDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F.W1 6C /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPUNPCKLQDQ_ZMM_K1Z_ZMM_ZMMM512B64: int = 1572
"""
``VPUNPCKLQDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F.W1 6C /r``
``AVX512F``
``16/32/64-bit``
"""
PUNPCKHQDQ_XMM_XMMM128: int = 1573
"""
``PUNPCKHQDQ xmm1, xmm2/m128``
``66 0F 6D /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPUNPCKHQDQ_XMM_XMM_XMMM128: int = 1574
"""
``VPUNPCKHQDQ xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG 6D /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPUNPCKHQDQ_YMM_YMM_YMMM256: int = 1575
"""
``VPUNPCKHQDQ ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG 6D /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPUNPCKHQDQ_XMM_K1Z_XMM_XMMM128B64: int = 1576
"""
``VPUNPCKHQDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F.W1 6D /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPUNPCKHQDQ_YMM_K1Z_YMM_YMMM256B64: int = 1577
"""
``VPUNPCKHQDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F.W1 6D /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPUNPCKHQDQ_ZMM_K1Z_ZMM_ZMMM512B64: int = 1578
"""
``VPUNPCKHQDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F.W1 6D /r``
``AVX512F``
``16/32/64-bit``
"""
MOVD_MM_RM32: int = 1579
"""
``MOVD mm, r/m32``
``NP 0F 6E /r``
``MMX``
``16/32/64-bit``
"""
MOVQ_MM_RM64: int = 1580
"""
``MOVQ mm, r/m64``
``NP o64 0F 6E /r``
``MMX``
``64-bit``
"""
MOVD_XMM_RM32: int = 1581
"""
``MOVD xmm, r/m32``
``66 0F 6E /r``
``SSE2``
``16/32/64-bit``
"""
MOVQ_XMM_RM64: int = 1582
"""
``MOVQ xmm, r/m64``
``66 o64 0F 6E /r``
``SSE2``
``64-bit``
"""
VEX_VMOVD_XMM_RM32: int = 1583
"""
``VMOVD xmm1, r/m32``
``VEX.128.66.0F.W0 6E /r``
``AVX``
``16/32/64-bit``
"""
VEX_VMOVQ_XMM_RM64: int = 1584
"""
``VMOVQ xmm1, r/m64``
``VEX.128.66.0F.W1 6E /r``
``AVX``
``64-bit``
"""
EVEX_VMOVD_XMM_RM32: int = 1585
"""
``VMOVD xmm1, r/m32``
``EVEX.128.66.0F.W0 6E /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVQ_XMM_RM64: int = 1586
"""
``VMOVQ xmm1, r/m64``
``EVEX.128.66.0F.W1 6E /r``
``AVX512F``
``64-bit``
"""
MOVQ_MM_MMM64: int = 1587
"""
``MOVQ mm, mm/m64``
``NP 0F 6F /r``
``MMX``
``16/32/64-bit``
"""
MOVDQA_XMM_XMMM128: int = 1588
"""
``MOVDQA xmm1, xmm2/m128``
``66 0F 6F /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VMOVDQA_XMM_XMMM128: int = 1589
"""
``VMOVDQA xmm1, xmm2/m128``
``VEX.128.66.0F.WIG 6F /r``
``AVX``
``16/32/64-bit``
"""
VEX_VMOVDQA_YMM_YMMM256: int = 1590
"""
``VMOVDQA ymm1, ymm2/m256``
``VEX.256.66.0F.WIG 6F /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMOVDQA32_XMM_K1Z_XMMM128: int = 1591
"""
``VMOVDQA32 xmm1 {k1}{z}, xmm2/m128``
``EVEX.128.66.0F.W0 6F /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVDQA32_YMM_K1Z_YMMM256: int = 1592
"""
``VMOVDQA32 ymm1 {k1}{z}, ymm2/m256``
``EVEX.256.66.0F.W0 6F /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVDQA32_ZMM_K1Z_ZMMM512: int = 1593
"""
``VMOVDQA32 zmm1 {k1}{z}, zmm2/m512``
``EVEX.512.66.0F.W0 6F /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVDQA64_XMM_K1Z_XMMM128: int = 1594
"""
``VMOVDQA64 xmm1 {k1}{z}, xmm2/m128``
``EVEX.128.66.0F.W1 6F /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVDQA64_YMM_K1Z_YMMM256: int = 1595
"""
``VMOVDQA64 ymm1 {k1}{z}, ymm2/m256``
``EVEX.256.66.0F.W1 6F /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVDQA64_ZMM_K1Z_ZMMM512: int = 1596
"""
``VMOVDQA64 zmm1 {k1}{z}, zmm2/m512``
``EVEX.512.66.0F.W1 6F /r``
``AVX512F``
``16/32/64-bit``
"""
MOVDQU_XMM_XMMM128: int = 1597
"""
``MOVDQU xmm1, xmm2/m128``
``F3 0F 6F /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VMOVDQU_XMM_XMMM128: int = 1598
"""
``VMOVDQU xmm1, xmm2/m128``
``VEX.128.F3.0F.WIG 6F /r``
``AVX``
``16/32/64-bit``
"""
VEX_VMOVDQU_YMM_YMMM256: int = 1599
"""
``VMOVDQU ymm1, ymm2/m256``
``VEX.256.F3.0F.WIG 6F /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMOVDQU32_XMM_K1Z_XMMM128: int = 1600
"""
``VMOVDQU32 xmm1 {k1}{z}, xmm2/m128``
``EVEX.128.F3.0F.W0 6F /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVDQU32_YMM_K1Z_YMMM256: int = 1601
"""
``VMOVDQU32 ymm1 {k1}{z}, ymm2/m256``
``EVEX.256.F3.0F.W0 6F /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVDQU32_ZMM_K1Z_ZMMM512: int = 1602
"""
``VMOVDQU32 zmm1 {k1}{z}, zmm2/m512``
``EVEX.512.F3.0F.W0 6F /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVDQU64_XMM_K1Z_XMMM128: int = 1603
"""
``VMOVDQU64 xmm1 {k1}{z}, xmm2/m128``
``EVEX.128.F3.0F.W1 6F /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVDQU64_YMM_K1Z_YMMM256: int = 1604
"""
``VMOVDQU64 ymm1 {k1}{z}, ymm2/m256``
``EVEX.256.F3.0F.W1 6F /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVDQU64_ZMM_K1Z_ZMMM512: int = 1605
"""
``VMOVDQU64 zmm1 {k1}{z}, zmm2/m512``
``EVEX.512.F3.0F.W1 6F /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVDQU8_XMM_K1Z_XMMM128: int = 1606
"""
``VMOVDQU8 xmm1 {k1}{z}, xmm2/m128``
``EVEX.128.F2.0F.W0 6F /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VMOVDQU8_YMM_K1Z_YMMM256: int = 1607
"""
``VMOVDQU8 ymm1 {k1}{z}, ymm2/m256``
``EVEX.256.F2.0F.W0 6F /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VMOVDQU8_ZMM_K1Z_ZMMM512: int = 1608
"""
``VMOVDQU8 zmm1 {k1}{z}, zmm2/m512``
``EVEX.512.F2.0F.W0 6F /r``
``AVX512BW``
``16/32/64-bit``
"""
EVEX_VMOVDQU16_XMM_K1Z_XMMM128: int = 1609
"""
``VMOVDQU16 xmm1 {k1}{z}, xmm2/m128``
``EVEX.128.F2.0F.W1 6F /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VMOVDQU16_YMM_K1Z_YMMM256: int = 1610
"""
``VMOVDQU16 ymm1 {k1}{z}, ymm2/m256``
``EVEX.256.F2.0F.W1 6F /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VMOVDQU16_ZMM_K1Z_ZMMM512: int = 1611
"""
``VMOVDQU16 zmm1 {k1}{z}, zmm2/m512``
``EVEX.512.F2.0F.W1 6F /r``
``AVX512BW``
``16/32/64-bit``
"""
PSHUFW_MM_MMM64_IMM8: int = 1612
"""
``PSHUFW mm1, mm2/m64, imm8``
``NP 0F 70 /r ib``
``SSE``
``16/32/64-bit``
"""
PSHUFD_XMM_XMMM128_IMM8: int = 1613
"""
``PSHUFD xmm1, xmm2/m128, imm8``
``66 0F 70 /r ib``
``SSE2``
``16/32/64-bit``
"""
VEX_VPSHUFD_XMM_XMMM128_IMM8: int = 1614
"""
``VPSHUFD xmm1, xmm2/m128, imm8``
``VEX.128.66.0F.WIG 70 /r ib``
``AVX``
``16/32/64-bit``
"""
VEX_VPSHUFD_YMM_YMMM256_IMM8: int = 1615
"""
``VPSHUFD ymm1, ymm2/m256, imm8``
``VEX.256.66.0F.WIG 70 /r ib``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPSHUFD_XMM_K1Z_XMMM128B32_IMM8: int = 1616
"""
``VPSHUFD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8``
``EVEX.128.66.0F.W0 70 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSHUFD_YMM_K1Z_YMMM256B32_IMM8: int = 1617
"""
``VPSHUFD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8``
``EVEX.256.66.0F.W0 70 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSHUFD_ZMM_K1Z_ZMMM512B32_IMM8: int = 1618
"""
``VPSHUFD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8``
``EVEX.512.66.0F.W0 70 /r ib``
``AVX512F``
``16/32/64-bit``
"""
PSHUFHW_XMM_XMMM128_IMM8: int = 1619
"""
``PSHUFHW xmm1, xmm2/m128, imm8``
``F3 0F 70 /r ib``
``SSE2``
``16/32/64-bit``
"""
VEX_VPSHUFHW_XMM_XMMM128_IMM8: int = 1620
"""
``VPSHUFHW xmm1, xmm2/m128, imm8``
``VEX.128.F3.0F.WIG 70 /r ib``
``AVX``
``16/32/64-bit``
"""
VEX_VPSHUFHW_YMM_YMMM256_IMM8: int = 1621
"""
``VPSHUFHW ymm1, ymm2/m256, imm8``
``VEX.256.F3.0F.WIG 70 /r ib``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPSHUFHW_XMM_K1Z_XMMM128_IMM8: int = 1622
"""
``VPSHUFHW xmm1 {k1}{z}, xmm2/m128, imm8``
``EVEX.128.F3.0F.WIG 70 /r ib``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSHUFHW_YMM_K1Z_YMMM256_IMM8: int = 1623
"""
``VPSHUFHW ymm1 {k1}{z}, ymm2/m256, imm8``
``EVEX.256.F3.0F.WIG 70 /r ib``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSHUFHW_ZMM_K1Z_ZMMM512_IMM8: int = 1624
"""
``VPSHUFHW zmm1 {k1}{z}, zmm2/m512, imm8``
``EVEX.512.F3.0F.WIG 70 /r ib``
``AVX512BW``
``16/32/64-bit``
"""
PSHUFLW_XMM_XMMM128_IMM8: int = 1625
"""
``PSHUFLW xmm1, xmm2/m128, imm8``
``F2 0F 70 /r ib``
``SSE2``
``16/32/64-bit``
"""
VEX_VPSHUFLW_XMM_XMMM128_IMM8: int = 1626
"""
``VPSHUFLW xmm1, xmm2/m128, imm8``
``VEX.128.F2.0F.WIG 70 /r ib``
``AVX``
``16/32/64-bit``
"""
VEX_VPSHUFLW_YMM_YMMM256_IMM8: int = 1627
"""
``VPSHUFLW ymm1, ymm2/m256, imm8``
``VEX.256.F2.0F.WIG 70 /r ib``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPSHUFLW_XMM_K1Z_XMMM128_IMM8: int = 1628
"""
``VPSHUFLW xmm1 {k1}{z}, xmm2/m128, imm8``
``EVEX.128.F2.0F.WIG 70 /r ib``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSHUFLW_YMM_K1Z_YMMM256_IMM8: int = 1629
"""
``VPSHUFLW ymm1 {k1}{z}, ymm2/m256, imm8``
``EVEX.256.F2.0F.WIG 70 /r ib``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSHUFLW_ZMM_K1Z_ZMMM512_IMM8: int = 1630
"""
``VPSHUFLW zmm1 {k1}{z}, zmm2/m512, imm8``
``EVEX.512.F2.0F.WIG 70 /r ib``
``AVX512BW``
``16/32/64-bit``
"""
PSRLW_MM_IMM8: int = 1631
"""
``PSRLW mm, imm8``
``NP 0F 71 /2 ib``
``MMX``
``16/32/64-bit``
"""
PSRLW_XMM_IMM8: int = 1632
"""
``PSRLW xmm1, imm8``
``66 0F 71 /2 ib``
``SSE2``
``16/32/64-bit``
"""
VEX_VPSRLW_XMM_XMM_IMM8: int = 1633
"""
``VPSRLW xmm1, xmm2, imm8``
``VEX.128.66.0F.WIG 71 /2 ib``
``AVX``
``16/32/64-bit``
"""
VEX_VPSRLW_YMM_YMM_IMM8: int = 1634
"""
``VPSRLW ymm1, ymm2, imm8``
``VEX.256.66.0F.WIG 71 /2 ib``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPSRLW_XMM_K1Z_XMMM128_IMM8: int = 1635
"""
``VPSRLW xmm1 {k1}{z}, xmm2/m128, imm8``
``EVEX.128.66.0F.WIG 71 /2 ib``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSRLW_YMM_K1Z_YMMM256_IMM8: int = 1636
"""
``VPSRLW ymm1 {k1}{z}, ymm2/m256, imm8``
``EVEX.256.66.0F.WIG 71 /2 ib``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSRLW_ZMM_K1Z_ZMMM512_IMM8: int = 1637
"""
``VPSRLW zmm1 {k1}{z}, zmm2/m512, imm8``
``EVEX.512.66.0F.WIG 71 /2 ib``
``AVX512BW``
``16/32/64-bit``
"""
PSRAW_MM_IMM8: int = 1638
"""
``PSRAW mm, imm8``
``NP 0F 71 /4 ib``
``MMX``
``16/32/64-bit``
"""
PSRAW_XMM_IMM8: int = 1639
"""
``PSRAW xmm1, imm8``
``66 0F 71 /4 ib``
``SSE2``
``16/32/64-bit``
"""
VEX_VPSRAW_XMM_XMM_IMM8: int = 1640
"""
``VPSRAW xmm1, xmm2, imm8``
``VEX.128.66.0F.WIG 71 /4 ib``
``AVX``
``16/32/64-bit``
"""
VEX_VPSRAW_YMM_YMM_IMM8: int = 1641
"""
``VPSRAW ymm1, ymm2, imm8``
``VEX.256.66.0F.WIG 71 /4 ib``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPSRAW_XMM_K1Z_XMMM128_IMM8: int = 1642
"""
``VPSRAW xmm1 {k1}{z}, xmm2/m128, imm8``
``EVEX.128.66.0F.WIG 71 /4 ib``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSRAW_YMM_K1Z_YMMM256_IMM8: int = 1643
"""
``VPSRAW ymm1 {k1}{z}, ymm2/m256, imm8``
``EVEX.256.66.0F.WIG 71 /4 ib``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSRAW_ZMM_K1Z_ZMMM512_IMM8: int = 1644
"""
``VPSRAW zmm1 {k1}{z}, zmm2/m512, imm8``
``EVEX.512.66.0F.WIG 71 /4 ib``
``AVX512BW``
``16/32/64-bit``
"""
PSLLW_MM_IMM8: int = 1645
"""
``PSLLW mm1, imm8``
``NP 0F 71 /6 ib``
``MMX``
``16/32/64-bit``
"""
PSLLW_XMM_IMM8: int = 1646
"""
``PSLLW xmm1, imm8``
``66 0F 71 /6 ib``
``SSE2``
``16/32/64-bit``
"""
VEX_VPSLLW_XMM_XMM_IMM8: int = 1647
"""
``VPSLLW xmm1, xmm2, imm8``
``VEX.128.66.0F.WIG 71 /6 ib``
``AVX``
``16/32/64-bit``
"""
VEX_VPSLLW_YMM_YMM_IMM8: int = 1648
"""
``VPSLLW ymm1, ymm2, imm8``
``VEX.256.66.0F.WIG 71 /6 ib``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPSLLW_XMM_K1Z_XMMM128_IMM8: int = 1649
"""
``VPSLLW xmm1 {k1}{z}, xmm2/m128, imm8``
``EVEX.128.66.0F.WIG 71 /6 ib``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSLLW_YMM_K1Z_YMMM256_IMM8: int = 1650
"""
``VPSLLW ymm1 {k1}{z}, ymm2/m256, imm8``
``EVEX.256.66.0F.WIG 71 /6 ib``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSLLW_ZMM_K1Z_ZMMM512_IMM8: int = 1651
"""
``VPSLLW zmm1 {k1}{z}, zmm2/m512, imm8``
``EVEX.512.66.0F.WIG 71 /6 ib``
``AVX512BW``
``16/32/64-bit``
"""
EVEX_VPRORD_XMM_K1Z_XMMM128B32_IMM8: int = 1652
"""
``VPRORD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8``
``EVEX.128.66.0F.W0 72 /0 ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPRORD_YMM_K1Z_YMMM256B32_IMM8: int = 1653
"""
``VPRORD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8``
``EVEX.256.66.0F.W0 72 /0 ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPRORD_ZMM_K1Z_ZMMM512B32_IMM8: int = 1654
"""
``VPRORD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8``
``EVEX.512.66.0F.W0 72 /0 ib``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPRORQ_XMM_K1Z_XMMM128B64_IMM8: int = 1655
"""
``VPRORQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8``
``EVEX.128.66.0F.W1 72 /0 ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPRORQ_YMM_K1Z_YMMM256B64_IMM8: int = 1656
"""
``VPRORQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8``
``EVEX.256.66.0F.W1 72 /0 ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPRORQ_ZMM_K1Z_ZMMM512B64_IMM8: int = 1657
"""
``VPRORQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8``
``EVEX.512.66.0F.W1 72 /0 ib``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPROLD_XMM_K1Z_XMMM128B32_IMM8: int = 1658
"""
``VPROLD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8``
``EVEX.128.66.0F.W0 72 /1 ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPROLD_YMM_K1Z_YMMM256B32_IMM8: int = 1659
"""
``VPROLD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8``
``EVEX.256.66.0F.W0 72 /1 ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPROLD_ZMM_K1Z_ZMMM512B32_IMM8: int = 1660
"""
``VPROLD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8``
``EVEX.512.66.0F.W0 72 /1 ib``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPROLQ_XMM_K1Z_XMMM128B64_IMM8: int = 1661
"""
``VPROLQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8``
``EVEX.128.66.0F.W1 72 /1 ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPROLQ_YMM_K1Z_YMMM256B64_IMM8: int = 1662
"""
``VPROLQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8``
``EVEX.256.66.0F.W1 72 /1 ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPROLQ_ZMM_K1Z_ZMMM512B64_IMM8: int = 1663
"""
``VPROLQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8``
``EVEX.512.66.0F.W1 72 /1 ib``
``AVX512F``
``16/32/64-bit``
"""
PSRLD_MM_IMM8: int = 1664
"""
``PSRLD mm, imm8``
``NP 0F 72 /2 ib``
``MMX``
``16/32/64-bit``
"""
PSRLD_XMM_IMM8: int = 1665
"""
``PSRLD xmm1, imm8``
``66 0F 72 /2 ib``
``SSE2``
``16/32/64-bit``
"""
VEX_VPSRLD_XMM_XMM_IMM8: int = 1666
"""
``VPSRLD xmm1, xmm2, imm8``
``VEX.128.66.0F.WIG 72 /2 ib``
``AVX``
``16/32/64-bit``
"""
VEX_VPSRLD_YMM_YMM_IMM8: int = 1667
"""
``VPSRLD ymm1, ymm2, imm8``
``VEX.256.66.0F.WIG 72 /2 ib``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPSRLD_XMM_K1Z_XMMM128B32_IMM8: int = 1668
"""
``VPSRLD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8``
``EVEX.128.66.0F.W0 72 /2 ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSRLD_YMM_K1Z_YMMM256B32_IMM8: int = 1669
"""
``VPSRLD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8``
``EVEX.256.66.0F.W0 72 /2 ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSRLD_ZMM_K1Z_ZMMM512B32_IMM8: int = 1670
"""
``VPSRLD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8``
``EVEX.512.66.0F.W0 72 /2 ib``
``AVX512F``
``16/32/64-bit``
"""
PSRAD_MM_IMM8: int = 1671
"""
``PSRAD mm, imm8``
``NP 0F 72 /4 ib``
``MMX``
``16/32/64-bit``
"""
PSRAD_XMM_IMM8: int = 1672
"""
``PSRAD xmm1, imm8``
``66 0F 72 /4 ib``
``SSE2``
``16/32/64-bit``
"""
VEX_VPSRAD_XMM_XMM_IMM8: int = 1673
"""
``VPSRAD xmm1, xmm2, imm8``
``VEX.128.66.0F.WIG 72 /4 ib``
``AVX``
``16/32/64-bit``
"""
VEX_VPSRAD_YMM_YMM_IMM8: int = 1674
"""
``VPSRAD ymm1, ymm2, imm8``
``VEX.256.66.0F.WIG 72 /4 ib``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPSRAD_XMM_K1Z_XMMM128B32_IMM8: int = 1675
"""
``VPSRAD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8``
``EVEX.128.66.0F.W0 72 /4 ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSRAD_YMM_K1Z_YMMM256B32_IMM8: int = 1676
"""
``VPSRAD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8``
``EVEX.256.66.0F.W0 72 /4 ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSRAD_ZMM_K1Z_ZMMM512B32_IMM8: int = 1677
"""
``VPSRAD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8``
``EVEX.512.66.0F.W0 72 /4 ib``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPSRAQ_XMM_K1Z_XMMM128B64_IMM8: int = 1678
"""
``VPSRAQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8``
``EVEX.128.66.0F.W1 72 /4 ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSRAQ_YMM_K1Z_YMMM256B64_IMM8: int = 1679
"""
``VPSRAQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8``
``EVEX.256.66.0F.W1 72 /4 ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSRAQ_ZMM_K1Z_ZMMM512B64_IMM8: int = 1680
"""
``VPSRAQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8``
``EVEX.512.66.0F.W1 72 /4 ib``
``AVX512F``
``16/32/64-bit``
"""
PSLLD_MM_IMM8: int = 1681
"""
``PSLLD mm, imm8``
``NP 0F 72 /6 ib``
``MMX``
``16/32/64-bit``
"""
PSLLD_XMM_IMM8: int = 1682
"""
``PSLLD xmm1, imm8``
``66 0F 72 /6 ib``
``SSE2``
``16/32/64-bit``
"""
VEX_VPSLLD_XMM_XMM_IMM8: int = 1683
"""
``VPSLLD xmm1, xmm2, imm8``
``VEX.128.66.0F.WIG 72 /6 ib``
``AVX``
``16/32/64-bit``
"""
VEX_VPSLLD_YMM_YMM_IMM8: int = 1684
"""
``VPSLLD ymm1, ymm2, imm8``
``VEX.256.66.0F.WIG 72 /6 ib``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPSLLD_XMM_K1Z_XMMM128B32_IMM8: int = 1685
"""
``VPSLLD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8``
``EVEX.128.66.0F.W0 72 /6 ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSLLD_YMM_K1Z_YMMM256B32_IMM8: int = 1686
"""
``VPSLLD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8``
``EVEX.256.66.0F.W0 72 /6 ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSLLD_ZMM_K1Z_ZMMM512B32_IMM8: int = 1687
"""
``VPSLLD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8``
``EVEX.512.66.0F.W0 72 /6 ib``
``AVX512F``
``16/32/64-bit``
"""
PSRLQ_MM_IMM8: int = 1688
"""
``PSRLQ mm, imm8``
``NP 0F 73 /2 ib``
``MMX``
``16/32/64-bit``
"""
PSRLQ_XMM_IMM8: int = 1689
"""
``PSRLQ xmm1, imm8``
``66 0F 73 /2 ib``
``SSE2``
``16/32/64-bit``
"""
VEX_VPSRLQ_XMM_XMM_IMM8: int = 1690
"""
``VPSRLQ xmm1, xmm2, imm8``
``VEX.128.66.0F.WIG 73 /2 ib``
``AVX``
``16/32/64-bit``
"""
VEX_VPSRLQ_YMM_YMM_IMM8: int = 1691
"""
``VPSRLQ ymm1, ymm2, imm8``
``VEX.256.66.0F.WIG 73 /2 ib``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPSRLQ_XMM_K1Z_XMMM128B64_IMM8: int = 1692
"""
``VPSRLQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8``
``EVEX.128.66.0F.W1 73 /2 ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSRLQ_YMM_K1Z_YMMM256B64_IMM8: int = 1693
"""
``VPSRLQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8``
``EVEX.256.66.0F.W1 73 /2 ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSRLQ_ZMM_K1Z_ZMMM512B64_IMM8: int = 1694
"""
``VPSRLQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8``
``EVEX.512.66.0F.W1 73 /2 ib``
``AVX512F``
``16/32/64-bit``
"""
PSRLDQ_XMM_IMM8: int = 1695
"""
``PSRLDQ xmm1, imm8``
``66 0F 73 /3 ib``
``SSE2``
``16/32/64-bit``
"""
VEX_VPSRLDQ_XMM_XMM_IMM8: int = 1696
"""
``VPSRLDQ xmm1, xmm2, imm8``
``VEX.128.66.0F.WIG 73 /3 ib``
``AVX``
``16/32/64-bit``
"""
VEX_VPSRLDQ_YMM_YMM_IMM8: int = 1697
"""
``VPSRLDQ ymm1, ymm2, imm8``
``VEX.256.66.0F.WIG 73 /3 ib``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPSRLDQ_XMM_XMMM128_IMM8: int = 1698
"""
``VPSRLDQ xmm1, xmm2/m128, imm8``
``EVEX.128.66.0F.WIG 73 /3 ib``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSRLDQ_YMM_YMMM256_IMM8: int = 1699
"""
``VPSRLDQ ymm1, ymm2/m256, imm8``
``EVEX.256.66.0F.WIG 73 /3 ib``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSRLDQ_ZMM_ZMMM512_IMM8: int = 1700
"""
``VPSRLDQ zmm1, zmm2/m512, imm8``
``EVEX.512.66.0F.WIG 73 /3 ib``
``AVX512BW``
``16/32/64-bit``
"""
PSLLQ_MM_IMM8: int = 1701
"""
``PSLLQ mm, imm8``
``NP 0F 73 /6 ib``
``MMX``
``16/32/64-bit``
"""
PSLLQ_XMM_IMM8: int = 1702
"""
``PSLLQ xmm1, imm8``
``66 0F 73 /6 ib``
``SSE2``
``16/32/64-bit``
"""
VEX_VPSLLQ_XMM_XMM_IMM8: int = 1703
"""
``VPSLLQ xmm1, xmm2, imm8``
``VEX.128.66.0F.WIG 73 /6 ib``
``AVX``
``16/32/64-bit``
"""
VEX_VPSLLQ_YMM_YMM_IMM8: int = 1704
"""
``VPSLLQ ymm1, ymm2, imm8``
``VEX.256.66.0F.WIG 73 /6 ib``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPSLLQ_XMM_K1Z_XMMM128B64_IMM8: int = 1705
"""
``VPSLLQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8``
``EVEX.128.66.0F.W1 73 /6 ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSLLQ_YMM_K1Z_YMMM256B64_IMM8: int = 1706
"""
``VPSLLQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8``
``EVEX.256.66.0F.W1 73 /6 ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSLLQ_ZMM_K1Z_ZMMM512B64_IMM8: int = 1707
"""
``VPSLLQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8``
``EVEX.512.66.0F.W1 73 /6 ib``
``AVX512F``
``16/32/64-bit``
"""
PSLLDQ_XMM_IMM8: int = 1708
"""
``PSLLDQ xmm1, imm8``
``66 0F 73 /7 ib``
``SSE2``
``16/32/64-bit``
"""
VEX_VPSLLDQ_XMM_XMM_IMM8: int = 1709
"""
``VPSLLDQ xmm1, xmm2, imm8``
``VEX.128.66.0F.WIG 73 /7 ib``
``AVX``
``16/32/64-bit``
"""
VEX_VPSLLDQ_YMM_YMM_IMM8: int = 1710
"""
``VPSLLDQ ymm1, ymm2, imm8``
``VEX.256.66.0F.WIG 73 /7 ib``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPSLLDQ_XMM_XMMM128_IMM8: int = 1711
"""
``VPSLLDQ xmm1, xmm2/m128, imm8``
``EVEX.128.66.0F.WIG 73 /7 ib``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSLLDQ_YMM_YMMM256_IMM8: int = 1712
"""
``VPSLLDQ ymm1, ymm2/m256, imm8``
``EVEX.256.66.0F.WIG 73 /7 ib``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSLLDQ_ZMM_ZMMM512_IMM8: int = 1713
"""
``VPSLLDQ zmm1, zmm2/m512, imm8``
``EVEX.512.66.0F.WIG 73 /7 ib``
``AVX512BW``
``16/32/64-bit``
"""
PCMPEQB_MM_MMM64: int = 1714
"""
``PCMPEQB mm, mm/m64``
``NP 0F 74 /r``
``MMX``
``16/32/64-bit``
"""
PCMPEQB_XMM_XMMM128: int = 1715
"""
``PCMPEQB xmm1, xmm2/m128``
``66 0F 74 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPCMPEQB_XMM_XMM_XMMM128: int = 1716
"""
``VPCMPEQB xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG 74 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPCMPEQB_YMM_YMM_YMMM256: int = 1717
"""
``VPCMPEQB ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG 74 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPCMPEQB_KR_K1_XMM_XMMM128: int = 1718
"""
``VPCMPEQB k1 {k2}, xmm2, xmm3/m128``
``EVEX.128.66.0F.WIG 74 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPCMPEQB_KR_K1_YMM_YMMM256: int = 1719
"""
``VPCMPEQB k1 {k2}, ymm2, ymm3/m256``
``EVEX.256.66.0F.WIG 74 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPCMPEQB_KR_K1_ZMM_ZMMM512: int = 1720
"""
``VPCMPEQB k1 {k2}, zmm2, zmm3/m512``
``EVEX.512.66.0F.WIG 74 /r``
``AVX512BW``
``16/32/64-bit``
"""
PCMPEQW_MM_MMM64: int = 1721
"""
``PCMPEQW mm, mm/m64``
``NP 0F 75 /r``
``MMX``
``16/32/64-bit``
"""
PCMPEQW_XMM_XMMM128: int = 1722
"""
``PCMPEQW xmm1, xmm2/m128``
``66 0F 75 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPCMPEQW_XMM_XMM_XMMM128: int = 1723
"""
``VPCMPEQW xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG 75 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPCMPEQW_YMM_YMM_YMMM256: int = 1724
"""
``VPCMPEQW ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG 75 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPCMPEQW_KR_K1_XMM_XMMM128: int = 1725
"""
``VPCMPEQW k1 {k2}, xmm2, xmm3/m128``
``EVEX.128.66.0F.WIG 75 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPCMPEQW_KR_K1_YMM_YMMM256: int = 1726
"""
``VPCMPEQW k1 {k2}, ymm2, ymm3/m256``
``EVEX.256.66.0F.WIG 75 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPCMPEQW_KR_K1_ZMM_ZMMM512: int = 1727
"""
``VPCMPEQW k1 {k2}, zmm2, zmm3/m512``
``EVEX.512.66.0F.WIG 75 /r``
``AVX512BW``
``16/32/64-bit``
"""
PCMPEQD_MM_MMM64: int = 1728
"""
``PCMPEQD mm, mm/m64``
``NP 0F 76 /r``
``MMX``
``16/32/64-bit``
"""
PCMPEQD_XMM_XMMM128: int = 1729
"""
``PCMPEQD xmm1, xmm2/m128``
``66 0F 76 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPCMPEQD_XMM_XMM_XMMM128: int = 1730
"""
``VPCMPEQD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG 76 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPCMPEQD_YMM_YMM_YMMM256: int = 1731
"""
``VPCMPEQD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG 76 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPCMPEQD_KR_K1_XMM_XMMM128B32: int = 1732
"""
``VPCMPEQD k1 {k2}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F.W0 76 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPCMPEQD_KR_K1_YMM_YMMM256B32: int = 1733
"""
``VPCMPEQD k1 {k2}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F.W0 76 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPCMPEQD_KR_K1_ZMM_ZMMM512B32: int = 1734
"""
``VPCMPEQD k1 {k2}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.66.0F.W0 76 /r``
``AVX512F``
``16/32/64-bit``
"""
EMMS: int = 1735
"""
``EMMS``
``NP 0F 77``
``MMX``
``16/32/64-bit``
"""
VEX_VZEROUPPER: int = 1736
"""
``VZEROUPPER``
``VEX.128.0F.WIG 77``
``AVX``
``16/32/64-bit``
"""
VEX_VZEROALL: int = 1737
"""
``VZEROALL``
``VEX.256.0F.WIG 77``
``AVX``
``16/32/64-bit``
"""
VMREAD_RM32_R32: int = 1738
"""
``VMREAD r/m32, r32``
``NP 0F 78 /r``
``VMX``
``16/32-bit``
"""
VMREAD_RM64_R64: int = 1739
"""
``VMREAD r/m64, r64``
``NP 0F 78 /r``
``VMX``
``64-bit``
"""
EVEX_VCVTTPS2UDQ_XMM_K1Z_XMMM128B32: int = 1740
"""
``VCVTTPS2UDQ xmm1 {k1}{z}, xmm2/m128/m32bcst``
``EVEX.128.0F.W0 78 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTTPS2UDQ_YMM_K1Z_YMMM256B32: int = 1741
"""
``VCVTTPS2UDQ ymm1 {k1}{z}, ymm2/m256/m32bcst``
``EVEX.256.0F.W0 78 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTTPS2UDQ_ZMM_K1Z_ZMMM512B32_SAE: int = 1742
"""
``VCVTTPS2UDQ zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}``
``EVEX.512.0F.W0 78 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTTPD2UDQ_XMM_K1Z_XMMM128B64: int = 1743
"""
``VCVTTPD2UDQ xmm1 {k1}{z}, xmm2/m128/m64bcst``
``EVEX.128.0F.W1 78 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTTPD2UDQ_XMM_K1Z_YMMM256B64: int = 1744
"""
``VCVTTPD2UDQ xmm1 {k1}{z}, ymm2/m256/m64bcst``
``EVEX.256.0F.W1 78 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTTPD2UDQ_YMM_K1Z_ZMMM512B64_SAE: int = 1745
"""
``VCVTTPD2UDQ ymm1 {k1}{z}, zmm2/m512/m64bcst{sae}``
``EVEX.512.0F.W1 78 /r``
``AVX512F``
``16/32/64-bit``
"""
EXTRQ_XMM_IMM8_IMM8: int = 1746
"""
``EXTRQ xmm1, imm8, imm8``
``66 0F 78 /0 ib ib``
``SSE4A``
``16/32/64-bit``
"""
EVEX_VCVTTPS2UQQ_XMM_K1Z_XMMM64B32: int = 1747
"""
``VCVTTPS2UQQ xmm1 {k1}{z}, xmm2/m64/m32bcst``
``EVEX.128.66.0F.W0 78 /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VCVTTPS2UQQ_YMM_K1Z_XMMM128B32: int = 1748
"""
``VCVTTPS2UQQ ymm1 {k1}{z}, xmm2/m128/m32bcst``
``EVEX.256.66.0F.W0 78 /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VCVTTPS2UQQ_ZMM_K1Z_YMMM256B32_SAE: int = 1749
"""
``VCVTTPS2UQQ zmm1 {k1}{z}, ymm2/m256/m32bcst{sae}``
``EVEX.512.66.0F.W0 78 /r``
``AVX512DQ``
``16/32/64-bit``
"""
EVEX_VCVTTPD2UQQ_XMM_K1Z_XMMM128B64: int = 1750
"""
``VCVTTPD2UQQ xmm1 {k1}{z}, xmm2/m128/m64bcst``
``EVEX.128.66.0F.W1 78 /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VCVTTPD2UQQ_YMM_K1Z_YMMM256B64: int = 1751
"""
``VCVTTPD2UQQ ymm1 {k1}{z}, ymm2/m256/m64bcst``
``EVEX.256.66.0F.W1 78 /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VCVTTPD2UQQ_ZMM_K1Z_ZMMM512B64_SAE: int = 1752
"""
``VCVTTPD2UQQ zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}``
``EVEX.512.66.0F.W1 78 /r``
``AVX512DQ``
``16/32/64-bit``
"""
EVEX_VCVTTSS2USI_R32_XMMM32_SAE: int = 1753
"""
``VCVTTSS2USI r32, xmm1/m32{sae}``
``EVEX.LIG.F3.0F.W0 78 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTTSS2USI_R64_XMMM32_SAE: int = 1754
"""
``VCVTTSS2USI r64, xmm1/m32{sae}``
``EVEX.LIG.F3.0F.W1 78 /r``
``AVX512F``
``64-bit``
"""
INSERTQ_XMM_XMM_IMM8_IMM8: int = 1755
"""
``INSERTQ xmm1, xmm2, imm8, imm8``
``F2 0F 78 /r ib ib``
``SSE4A``
``16/32/64-bit``
"""
EVEX_VCVTTSD2USI_R32_XMMM64_SAE: int = 1756
"""
``VCVTTSD2USI r32, xmm1/m64{sae}``
``EVEX.LIG.F2.0F.W0 78 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTTSD2USI_R64_XMMM64_SAE: int = 1757
"""
``VCVTTSD2USI r64, xmm1/m64{sae}``
``EVEX.LIG.F2.0F.W1 78 /r``
``AVX512F``
``64-bit``
"""
VMWRITE_R32_RM32: int = 1758
"""
``VMWRITE r32, r/m32``
``NP 0F 79 /r``
``VMX``
``16/32-bit``
"""
VMWRITE_R64_RM64: int = 1759
"""
``VMWRITE r64, r/m64``
``NP 0F 79 /r``
``VMX``
``64-bit``
"""
EVEX_VCVTPS2UDQ_XMM_K1Z_XMMM128B32: int = 1760
"""
``VCVTPS2UDQ xmm1 {k1}{z}, xmm2/m128/m32bcst``
``EVEX.128.0F.W0 79 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTPS2UDQ_YMM_K1Z_YMMM256B32: int = 1761
"""
``VCVTPS2UDQ ymm1 {k1}{z}, ymm2/m256/m32bcst``
``EVEX.256.0F.W0 79 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTPS2UDQ_ZMM_K1Z_ZMMM512B32_ER: int = 1762
"""
``VCVTPS2UDQ zmm1 {k1}{z}, zmm2/m512/m32bcst{er}``
``EVEX.512.0F.W0 79 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTPD2UDQ_XMM_K1Z_XMMM128B64: int = 1763
"""
``VCVTPD2UDQ xmm1 {k1}{z}, xmm2/m128/m64bcst``
``EVEX.128.0F.W1 79 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTPD2UDQ_XMM_K1Z_YMMM256B64: int = 1764
"""
``VCVTPD2UDQ xmm1 {k1}{z}, ymm2/m256/m64bcst``
``EVEX.256.0F.W1 79 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTPD2UDQ_YMM_K1Z_ZMMM512B64_ER: int = 1765
"""
``VCVTPD2UDQ ymm1 {k1}{z}, zmm2/m512/m64bcst{er}``
``EVEX.512.0F.W1 79 /r``
``AVX512F``
``16/32/64-bit``
"""
EXTRQ_XMM_XMM: int = 1766
"""
``EXTRQ xmm1, xmm2``
``66 0F 79 /r``
``SSE4A``
``16/32/64-bit``
"""
EVEX_VCVTPS2UQQ_XMM_K1Z_XMMM64B32: int = 1767
"""
``VCVTPS2UQQ xmm1 {k1}{z}, xmm2/m64/m32bcst``
``EVEX.128.66.0F.W0 79 /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VCVTPS2UQQ_YMM_K1Z_XMMM128B32: int = 1768
"""
``VCVTPS2UQQ ymm1 {k1}{z}, xmm2/m128/m32bcst``
``EVEX.256.66.0F.W0 79 /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VCVTPS2UQQ_ZMM_K1Z_YMMM256B32_ER: int = 1769
"""
``VCVTPS2UQQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er}``
``EVEX.512.66.0F.W0 79 /r``
``AVX512DQ``
``16/32/64-bit``
"""
EVEX_VCVTPD2UQQ_XMM_K1Z_XMMM128B64: int = 1770
"""
``VCVTPD2UQQ xmm1 {k1}{z}, xmm2/m128/m64bcst``
``EVEX.128.66.0F.W1 79 /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VCVTPD2UQQ_YMM_K1Z_YMMM256B64: int = 1771
"""
``VCVTPD2UQQ ymm1 {k1}{z}, ymm2/m256/m64bcst``
``EVEX.256.66.0F.W1 79 /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VCVTPD2UQQ_ZMM_K1Z_ZMMM512B64_ER: int = 1772
"""
``VCVTPD2UQQ zmm1 {k1}{z}, zmm2/m512/m64bcst{er}``
``EVEX.512.66.0F.W1 79 /r``
``AVX512DQ``
``16/32/64-bit``
"""
EVEX_VCVTSS2USI_R32_XMMM32_ER: int = 1773
"""
``VCVTSS2USI r32, xmm1/m32{er}``
``EVEX.LIG.F3.0F.W0 79 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTSS2USI_R64_XMMM32_ER: int = 1774
"""
``VCVTSS2USI r64, xmm1/m32{er}``
``EVEX.LIG.F3.0F.W1 79 /r``
``AVX512F``
``64-bit``
"""
INSERTQ_XMM_XMM: int = 1775
"""
``INSERTQ xmm1, xmm2``
``F2 0F 79 /r``
``SSE4A``
``16/32/64-bit``
"""
EVEX_VCVTSD2USI_R32_XMMM64_ER: int = 1776
"""
``VCVTSD2USI r32, xmm1/m64{er}``
``EVEX.LIG.F2.0F.W0 79 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTSD2USI_R64_XMMM64_ER: int = 1777
"""
``VCVTSD2USI r64, xmm1/m64{er}``
``EVEX.LIG.F2.0F.W1 79 /r``
``AVX512F``
``64-bit``
"""
EVEX_VCVTTPS2QQ_XMM_K1Z_XMMM64B32: int = 1778
"""
``VCVTTPS2QQ xmm1 {k1}{z}, xmm2/m64/m32bcst``
``EVEX.128.66.0F.W0 7A /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VCVTTPS2QQ_YMM_K1Z_XMMM128B32: int = 1779
"""
``VCVTTPS2QQ ymm1 {k1}{z}, xmm2/m128/m32bcst``
``EVEX.256.66.0F.W0 7A /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VCVTTPS2QQ_ZMM_K1Z_YMMM256B32_SAE: int = 1780
"""
``VCVTTPS2QQ zmm1 {k1}{z}, ymm2/m256/m32bcst{sae}``
``EVEX.512.66.0F.W0 7A /r``
``AVX512DQ``
``16/32/64-bit``
"""
EVEX_VCVTTPD2QQ_XMM_K1Z_XMMM128B64: int = 1781
"""
``VCVTTPD2QQ xmm1 {k1}{z}, xmm2/m128/m64bcst``
``EVEX.128.66.0F.W1 7A /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VCVTTPD2QQ_YMM_K1Z_YMMM256B64: int = 1782
"""
``VCVTTPD2QQ ymm1 {k1}{z}, ymm2/m256/m64bcst``
``EVEX.256.66.0F.W1 7A /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VCVTTPD2QQ_ZMM_K1Z_ZMMM512B64_SAE: int = 1783
"""
``VCVTTPD2QQ zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}``
``EVEX.512.66.0F.W1 7A /r``
``AVX512DQ``
``16/32/64-bit``
"""
EVEX_VCVTUDQ2PD_XMM_K1Z_XMMM64B32: int = 1784
"""
``VCVTUDQ2PD xmm1 {k1}{z}, xmm2/m64/m32bcst``
``EVEX.128.F3.0F.W0 7A /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTUDQ2PD_YMM_K1Z_XMMM128B32: int = 1785
"""
``VCVTUDQ2PD ymm1 {k1}{z}, xmm2/m128/m32bcst``
``EVEX.256.F3.0F.W0 7A /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTUDQ2PD_ZMM_K1Z_YMMM256B32_ER: int = 1786
"""
``VCVTUDQ2PD zmm1 {k1}{z}, ymm2/m256/m32bcst{er}``
``EVEX.512.F3.0F.W0 7A /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTUQQ2PD_XMM_K1Z_XMMM128B64: int = 1787
"""
``VCVTUQQ2PD xmm1 {k1}{z}, xmm2/m128/m64bcst``
``EVEX.128.F3.0F.W1 7A /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VCVTUQQ2PD_YMM_K1Z_YMMM256B64: int = 1788
"""
``VCVTUQQ2PD ymm1 {k1}{z}, ymm2/m256/m64bcst``
``EVEX.256.F3.0F.W1 7A /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VCVTUQQ2PD_ZMM_K1Z_ZMMM512B64_ER: int = 1789
"""
``VCVTUQQ2PD zmm1 {k1}{z}, zmm2/m512/m64bcst{er}``
``EVEX.512.F3.0F.W1 7A /r``
``AVX512DQ``
``16/32/64-bit``
"""
EVEX_VCVTUDQ2PS_XMM_K1Z_XMMM128B32: int = 1790
"""
``VCVTUDQ2PS xmm1 {k1}{z}, xmm2/m128/m32bcst``
``EVEX.128.F2.0F.W0 7A /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTUDQ2PS_YMM_K1Z_YMMM256B32: int = 1791
"""
``VCVTUDQ2PS ymm1 {k1}{z}, ymm2/m256/m32bcst``
``EVEX.256.F2.0F.W0 7A /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTUDQ2PS_ZMM_K1Z_ZMMM512B32_ER: int = 1792
"""
``VCVTUDQ2PS zmm1 {k1}{z}, zmm2/m512/m32bcst{er}``
``EVEX.512.F2.0F.W0 7A /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTUQQ2PS_XMM_K1Z_XMMM128B64: int = 1793
"""
``VCVTUQQ2PS xmm1 {k1}{z}, xmm2/m128/m64bcst``
``EVEX.128.F2.0F.W1 7A /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VCVTUQQ2PS_XMM_K1Z_YMMM256B64: int = 1794
"""
``VCVTUQQ2PS xmm1 {k1}{z}, ymm2/m256/m64bcst``
``EVEX.256.F2.0F.W1 7A /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VCVTUQQ2PS_YMM_K1Z_ZMMM512B64_ER: int = 1795
"""
``VCVTUQQ2PS ymm1 {k1}{z}, zmm2/m512/m64bcst{er}``
``EVEX.512.F2.0F.W1 7A /r``
``AVX512DQ``
``16/32/64-bit``
"""
EVEX_VCVTPS2QQ_XMM_K1Z_XMMM64B32: int = 1796
"""
``VCVTPS2QQ xmm1 {k1}{z}, xmm2/m64/m32bcst``
``EVEX.128.66.0F.W0 7B /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VCVTPS2QQ_YMM_K1Z_XMMM128B32: int = 1797
"""
``VCVTPS2QQ ymm1 {k1}{z}, xmm2/m128/m32bcst``
``EVEX.256.66.0F.W0 7B /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VCVTPS2QQ_ZMM_K1Z_YMMM256B32_ER: int = 1798
"""
``VCVTPS2QQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er}``
``EVEX.512.66.0F.W0 7B /r``
``AVX512DQ``
``16/32/64-bit``
"""
EVEX_VCVTPD2QQ_XMM_K1Z_XMMM128B64: int = 1799
"""
``VCVTPD2QQ xmm1 {k1}{z}, xmm2/m128/m64bcst``
``EVEX.128.66.0F.W1 7B /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VCVTPD2QQ_YMM_K1Z_YMMM256B64: int = 1800
"""
``VCVTPD2QQ ymm1 {k1}{z}, ymm2/m256/m64bcst``
``EVEX.256.66.0F.W1 7B /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VCVTPD2QQ_ZMM_K1Z_ZMMM512B64_ER: int = 1801
"""
``VCVTPD2QQ zmm1 {k1}{z}, zmm2/m512/m64bcst{er}``
``EVEX.512.66.0F.W1 7B /r``
``AVX512DQ``
``16/32/64-bit``
"""
EVEX_VCVTUSI2SS_XMM_XMM_RM32_ER: int = 1802
"""
``VCVTUSI2SS xmm1, xmm2, r/m32{er}``
``EVEX.LIG.F3.0F.W0 7B /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTUSI2SS_XMM_XMM_RM64_ER: int = 1803
"""
``VCVTUSI2SS xmm1, xmm2, r/m64{er}``
``EVEX.LIG.F3.0F.W1 7B /r``
``AVX512F``
``64-bit``
"""
EVEX_VCVTUSI2SD_XMM_XMM_RM32_ER: int = 1804
"""
``VCVTUSI2SD xmm1, xmm2, r/m32{er}``
``EVEX.LIG.F2.0F.W0 7B /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTUSI2SD_XMM_XMM_RM64_ER: int = 1805
"""
``VCVTUSI2SD xmm1, xmm2, r/m64{er}``
``EVEX.LIG.F2.0F.W1 7B /r``
``AVX512F``
``64-bit``
"""
HADDPD_XMM_XMMM128: int = 1806
"""
``HADDPD xmm1, xmm2/m128``
``66 0F 7C /r``
``SSE3``
``16/32/64-bit``
"""
VEX_VHADDPD_XMM_XMM_XMMM128: int = 1807
"""
``VHADDPD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG 7C /r``
``AVX``
``16/32/64-bit``
"""
VEX_VHADDPD_YMM_YMM_YMMM256: int = 1808
"""
``VHADDPD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG 7C /r``
``AVX``
``16/32/64-bit``
"""
HADDPS_XMM_XMMM128: int = 1809
"""
``HADDPS xmm1, xmm2/m128``
``F2 0F 7C /r``
``SSE3``
``16/32/64-bit``
"""
VEX_VHADDPS_XMM_XMM_XMMM128: int = 1810
"""
``VHADDPS xmm1, xmm2, xmm3/m128``
``VEX.128.F2.0F.WIG 7C /r``
``AVX``
``16/32/64-bit``
"""
VEX_VHADDPS_YMM_YMM_YMMM256: int = 1811
"""
``VHADDPS ymm1, ymm2, ymm3/m256``
``VEX.256.F2.0F.WIG 7C /r``
``AVX``
``16/32/64-bit``
"""
HSUBPD_XMM_XMMM128: int = 1812
"""
``HSUBPD xmm1, xmm2/m128``
``66 0F 7D /r``
``SSE3``
``16/32/64-bit``
"""
VEX_VHSUBPD_XMM_XMM_XMMM128: int = 1813
"""
``VHSUBPD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG 7D /r``
``AVX``
``16/32/64-bit``
"""
VEX_VHSUBPD_YMM_YMM_YMMM256: int = 1814
"""
``VHSUBPD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG 7D /r``
``AVX``
``16/32/64-bit``
"""
HSUBPS_XMM_XMMM128: int = 1815
"""
``HSUBPS xmm1, xmm2/m128``
``F2 0F 7D /r``
``SSE3``
``16/32/64-bit``
"""
VEX_VHSUBPS_XMM_XMM_XMMM128: int = 1816
"""
``VHSUBPS xmm1, xmm2, xmm3/m128``
``VEX.128.F2.0F.WIG 7D /r``
``AVX``
``16/32/64-bit``
"""
VEX_VHSUBPS_YMM_YMM_YMMM256: int = 1817
"""
``VHSUBPS ymm1, ymm2, ymm3/m256``
``VEX.256.F2.0F.WIG 7D /r``
``AVX``
``16/32/64-bit``
"""
MOVD_RM32_MM: int = 1818
"""
``MOVD r/m32, mm``
``NP 0F 7E /r``
``MMX``
``16/32/64-bit``
"""
MOVQ_RM64_MM: int = 1819
"""
``MOVQ r/m64, mm``
``NP o64 0F 7E /r``
``MMX``
``64-bit``
"""
MOVD_RM32_XMM: int = 1820
"""
``MOVD r/m32, xmm``
``66 0F 7E /r``
``SSE2``
``16/32/64-bit``
"""
MOVQ_RM64_XMM: int = 1821
"""
``MOVQ r/m64, xmm``
``66 o64 0F 7E /r``
``SSE2``
``64-bit``
"""
VEX_VMOVD_RM32_XMM: int = 1822
"""
``VMOVD r/m32, xmm1``
``VEX.128.66.0F.W0 7E /r``
``AVX``
``16/32/64-bit``
"""
VEX_VMOVQ_RM64_XMM: int = 1823
"""
``VMOVQ r/m64, xmm1``
``VEX.128.66.0F.W1 7E /r``
``AVX``
``64-bit``
"""
EVEX_VMOVD_RM32_XMM: int = 1824
"""
``VMOVD r/m32, xmm1``
``EVEX.128.66.0F.W0 7E /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVQ_RM64_XMM: int = 1825
"""
``VMOVQ r/m64, xmm1``
``EVEX.128.66.0F.W1 7E /r``
``AVX512F``
``64-bit``
"""
MOVQ_XMM_XMMM64: int = 1826
"""
``MOVQ xmm1, xmm2/m64``
``F3 0F 7E /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VMOVQ_XMM_XMMM64: int = 1827
"""
``VMOVQ xmm1, xmm2/m64``
``VEX.128.F3.0F.WIG 7E /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMOVQ_XMM_XMMM64: int = 1828
"""
``VMOVQ xmm1, xmm2/m64``
``EVEX.128.F3.0F.W1 7E /r``
``AVX512F``
``16/32/64-bit``
"""
MOVQ_MMM64_MM: int = 1829
"""
``MOVQ mm/m64, mm``
``NP 0F 7F /r``
``MMX``
``16/32/64-bit``
"""
MOVDQA_XMMM128_XMM: int = 1830
"""
``MOVDQA xmm2/m128, xmm1``
``66 0F 7F /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VMOVDQA_XMMM128_XMM: int = 1831
"""
``VMOVDQA xmm2/m128, xmm1``
``VEX.128.66.0F.WIG 7F /r``
``AVX``
``16/32/64-bit``
"""
VEX_VMOVDQA_YMMM256_YMM: int = 1832
"""
``VMOVDQA ymm2/m256, ymm1``
``VEX.256.66.0F.WIG 7F /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMOVDQA32_XMMM128_K1Z_XMM: int = 1833
"""
``VMOVDQA32 xmm2/m128 {k1}{z}, xmm1``
``EVEX.128.66.0F.W0 7F /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVDQA32_YMMM256_K1Z_YMM: int = 1834
"""
``VMOVDQA32 ymm2/m256 {k1}{z}, ymm1``
``EVEX.256.66.0F.W0 7F /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVDQA32_ZMMM512_K1Z_ZMM: int = 1835
"""
``VMOVDQA32 zmm2/m512 {k1}{z}, zmm1``
``EVEX.512.66.0F.W0 7F /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVDQA64_XMMM128_K1Z_XMM: int = 1836
"""
``VMOVDQA64 xmm2/m128 {k1}{z}, xmm1``
``EVEX.128.66.0F.W1 7F /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVDQA64_YMMM256_K1Z_YMM: int = 1837
"""
``VMOVDQA64 ymm2/m256 {k1}{z}, ymm1``
``EVEX.256.66.0F.W1 7F /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVDQA64_ZMMM512_K1Z_ZMM: int = 1838
"""
``VMOVDQA64 zmm2/m512 {k1}{z}, zmm1``
``EVEX.512.66.0F.W1 7F /r``
``AVX512F``
``16/32/64-bit``
"""
MOVDQU_XMMM128_XMM: int = 1839
"""
``MOVDQU xmm2/m128, xmm1``
``F3 0F 7F /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VMOVDQU_XMMM128_XMM: int = 1840
"""
``VMOVDQU xmm2/m128, xmm1``
``VEX.128.F3.0F.WIG 7F /r``
``AVX``
``16/32/64-bit``
"""
VEX_VMOVDQU_YMMM256_YMM: int = 1841
"""
``VMOVDQU ymm2/m256, ymm1``
``VEX.256.F3.0F.WIG 7F /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMOVDQU32_XMMM128_K1Z_XMM: int = 1842
"""
``VMOVDQU32 xmm2/m128 {k1}{z}, xmm1``
``EVEX.128.F3.0F.W0 7F /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVDQU32_YMMM256_K1Z_YMM: int = 1843
"""
``VMOVDQU32 ymm2/m256 {k1}{z}, ymm1``
``EVEX.256.F3.0F.W0 7F /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVDQU32_ZMMM512_K1Z_ZMM: int = 1844
"""
``VMOVDQU32 zmm2/m512 {k1}{z}, zmm1``
``EVEX.512.F3.0F.W0 7F /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVDQU64_XMMM128_K1Z_XMM: int = 1845
"""
``VMOVDQU64 xmm2/m128 {k1}{z}, xmm1``
``EVEX.128.F3.0F.W1 7F /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVDQU64_YMMM256_K1Z_YMM: int = 1846
"""
``VMOVDQU64 ymm2/m256 {k1}{z}, ymm1``
``EVEX.256.F3.0F.W1 7F /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVDQU64_ZMMM512_K1Z_ZMM: int = 1847
"""
``VMOVDQU64 zmm2/m512 {k1}{z}, zmm1``
``EVEX.512.F3.0F.W1 7F /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVDQU8_XMMM128_K1Z_XMM: int = 1848
"""
``VMOVDQU8 xmm2/m128 {k1}{z}, xmm1``
``EVEX.128.F2.0F.W0 7F /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VMOVDQU8_YMMM256_K1Z_YMM: int = 1849
"""
``VMOVDQU8 ymm2/m256 {k1}{z}, ymm1``
``EVEX.256.F2.0F.W0 7F /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VMOVDQU8_ZMMM512_K1Z_ZMM: int = 1850
"""
``VMOVDQU8 zmm2/m512 {k1}{z}, zmm1``
``EVEX.512.F2.0F.W0 7F /r``
``AVX512BW``
``16/32/64-bit``
"""
EVEX_VMOVDQU16_XMMM128_K1Z_XMM: int = 1851
"""
``VMOVDQU16 xmm2/m128 {k1}{z}, xmm1``
``EVEX.128.F2.0F.W1 7F /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VMOVDQU16_YMMM256_K1Z_YMM: int = 1852
"""
``VMOVDQU16 ymm2/m256 {k1}{z}, ymm1``
``EVEX.256.F2.0F.W1 7F /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VMOVDQU16_ZMMM512_K1Z_ZMM: int = 1853
"""
``VMOVDQU16 zmm2/m512 {k1}{z}, zmm1``
``EVEX.512.F2.0F.W1 7F /r``
``AVX512BW``
``16/32/64-bit``
"""
JO_REL16: int = 1854
"""
``JO rel16``
``o16 0F 80 cw``
``386+``
``16/32/64-bit``
"""
JO_REL32_32: int = 1855
"""
``JO rel32``
``o32 0F 80 cd``
``386+``
``16/32-bit``
"""
JO_REL32_64: int = 1856
"""
``JO rel32``
``o64 0F 80 cd``
``X64``
``64-bit``
"""
JNO_REL16: int = 1857
"""
``JNO rel16``
``o16 0F 81 cw``
``386+``
``16/32/64-bit``
"""
JNO_REL32_32: int = 1858
"""
``JNO rel32``
``o32 0F 81 cd``
``386+``
``16/32-bit``
"""
JNO_REL32_64: int = 1859
"""
``JNO rel32``
``o64 0F 81 cd``
``X64``
``64-bit``
"""
JB_REL16: int = 1860
"""
``JB rel16``
``o16 0F 82 cw``
``386+``
``16/32/64-bit``
"""
JB_REL32_32: int = 1861
"""
``JB rel32``
``o32 0F 82 cd``
``386+``
``16/32-bit``
"""
JB_REL32_64: int = 1862
"""
``JB rel32``
``o64 0F 82 cd``
``X64``
``64-bit``
"""
JAE_REL16: int = 1863
"""
``JAE rel16``
``o16 0F 83 cw``
``386+``
``16/32/64-bit``
"""
JAE_REL32_32: int = 1864
"""
``JAE rel32``
``o32 0F 83 cd``
``386+``
``16/32-bit``
"""
JAE_REL32_64: int = 1865
"""
``JAE rel32``
``o64 0F 83 cd``
``X64``
``64-bit``
"""
JE_REL16: int = 1866
"""
``JE rel16``
``o16 0F 84 cw``
``386+``
``16/32/64-bit``
"""
JE_REL32_32: int = 1867
"""
``JE rel32``
``o32 0F 84 cd``
``386+``
``16/32-bit``
"""
JE_REL32_64: int = 1868
"""
``JE rel32``
``o64 0F 84 cd``
``X64``
``64-bit``
"""
JNE_REL16: int = 1869
"""
``JNE rel16``
``o16 0F 85 cw``
``386+``
``16/32/64-bit``
"""
JNE_REL32_32: int = 1870
"""
``JNE rel32``
``o32 0F 85 cd``
``386+``
``16/32-bit``
"""
JNE_REL32_64: int = 1871
"""
``JNE rel32``
``o64 0F 85 cd``
``X64``
``64-bit``
"""
JBE_REL16: int = 1872
"""
``JBE rel16``
``o16 0F 86 cw``
``386+``
``16/32/64-bit``
"""
JBE_REL32_32: int = 1873
"""
``JBE rel32``
``o32 0F 86 cd``
``386+``
``16/32-bit``
"""
JBE_REL32_64: int = 1874
"""
``JBE rel32``
``o64 0F 86 cd``
``X64``
``64-bit``
"""
JA_REL16: int = 1875
"""
``JA rel16``
``o16 0F 87 cw``
``386+``
``16/32/64-bit``
"""
JA_REL32_32: int = 1876
"""
``JA rel32``
``o32 0F 87 cd``
``386+``
``16/32-bit``
"""
JA_REL32_64: int = 1877
"""
``JA rel32``
``o64 0F 87 cd``
``X64``
``64-bit``
"""
JS_REL16: int = 1878
"""
``JS rel16``
``o16 0F 88 cw``
``386+``
``16/32/64-bit``
"""
JS_REL32_32: int = 1879
"""
``JS rel32``
``o32 0F 88 cd``
``386+``
``16/32-bit``
"""
JS_REL32_64: int = 1880
"""
``JS rel32``
``o64 0F 88 cd``
``X64``
``64-bit``
"""
JNS_REL16: int = 1881
"""
``JNS rel16``
``o16 0F 89 cw``
``386+``
``16/32/64-bit``
"""
JNS_REL32_32: int = 1882
"""
``JNS rel32``
``o32 0F 89 cd``
``386+``
``16/32-bit``
"""
JNS_REL32_64: int = 1883
"""
``JNS rel32``
``o64 0F 89 cd``
``X64``
``64-bit``
"""
JP_REL16: int = 1884
"""
``JP rel16``
``o16 0F 8A cw``
``386+``
``16/32/64-bit``
"""
JP_REL32_32: int = 1885
"""
``JP rel32``
``o32 0F 8A cd``
``386+``
``16/32-bit``
"""
JP_REL32_64: int = 1886
"""
``JP rel32``
``o64 0F 8A cd``
``X64``
``64-bit``
"""
JNP_REL16: int = 1887
"""
``JNP rel16``
``o16 0F 8B cw``
``386+``
``16/32/64-bit``
"""
JNP_REL32_32: int = 1888
"""
``JNP rel32``
``o32 0F 8B cd``
``386+``
``16/32-bit``
"""
JNP_REL32_64: int = 1889
"""
``JNP rel32``
``o64 0F 8B cd``
``X64``
``64-bit``
"""
JL_REL16: int = 1890
"""
``JL rel16``
``o16 0F 8C cw``
``386+``
``16/32/64-bit``
"""
JL_REL32_32: int = 1891
"""
``JL rel32``
``o32 0F 8C cd``
``386+``
``16/32-bit``
"""
JL_REL32_64: int = 1892
"""
``JL rel32``
``o64 0F 8C cd``
``X64``
``64-bit``
"""
JGE_REL16: int = 1893
"""
``JGE rel16``
``o16 0F 8D cw``
``386+``
``16/32/64-bit``
"""
JGE_REL32_32: int = 1894
"""
``JGE rel32``
``o32 0F 8D cd``
``386+``
``16/32-bit``
"""
JGE_REL32_64: int = 1895
"""
``JGE rel32``
``o64 0F 8D cd``
``X64``
``64-bit``
"""
JLE_REL16: int = 1896
"""
``JLE rel16``
``o16 0F 8E cw``
``386+``
``16/32/64-bit``
"""
JLE_REL32_32: int = 1897
"""
``JLE rel32``
``o32 0F 8E cd``
``386+``
``16/32-bit``
"""
JLE_REL32_64: int = 1898
"""
``JLE rel32``
``o64 0F 8E cd``
``X64``
``64-bit``
"""
JG_REL16: int = 1899
"""
``JG rel16``
``o16 0F 8F cw``
``386+``
``16/32/64-bit``
"""
JG_REL32_32: int = 1900
"""
``JG rel32``
``o32 0F 8F cd``
``386+``
``16/32-bit``
"""
JG_REL32_64: int = 1901
"""
``JG rel32``
``o64 0F 8F cd``
``X64``
``64-bit``
"""
SETO_RM8: int = 1902
"""
``SETO r/m8``
``0F 90 /r``
``386+``
``16/32/64-bit``
"""
SETNO_RM8: int = 1903
"""
``SETNO r/m8``
``0F 91 /r``
``386+``
``16/32/64-bit``
"""
SETB_RM8: int = 1904
"""
``SETB r/m8``
``0F 92 /r``
``386+``
``16/32/64-bit``
"""
SETAE_RM8: int = 1905
"""
``SETAE r/m8``
``0F 93 /r``
``386+``
``16/32/64-bit``
"""
SETE_RM8: int = 1906
"""
``SETE r/m8``
``0F 94 /r``
``386+``
``16/32/64-bit``
"""
SETNE_RM8: int = 1907
"""
``SETNE r/m8``
``0F 95 /r``
``386+``
``16/32/64-bit``
"""
SETBE_RM8: int = 1908
"""
``SETBE r/m8``
``0F 96 /r``
``386+``
``16/32/64-bit``
"""
SETA_RM8: int = 1909
"""
``SETA r/m8``
``0F 97 /r``
``386+``
``16/32/64-bit``
"""
SETS_RM8: int = 1910
"""
``SETS r/m8``
``0F 98 /r``
``386+``
``16/32/64-bit``
"""
SETNS_RM8: int = 1911
"""
``SETNS r/m8``
``0F 99 /r``
``386+``
``16/32/64-bit``
"""
SETP_RM8: int = 1912
"""
``SETP r/m8``
``0F 9A /r``
``386+``
``16/32/64-bit``
"""
SETNP_RM8: int = 1913
"""
``SETNP r/m8``
``0F 9B /r``
``386+``
``16/32/64-bit``
"""
SETL_RM8: int = 1914
"""
``SETL r/m8``
``0F 9C /r``
``386+``
``16/32/64-bit``
"""
SETGE_RM8: int = 1915
"""
``SETGE r/m8``
``0F 9D /r``
``386+``
``16/32/64-bit``
"""
SETLE_RM8: int = 1916
"""
``SETLE r/m8``
``0F 9E /r``
``386+``
``16/32/64-bit``
"""
SETG_RM8: int = 1917
"""
``SETG r/m8``
``0F 9F /r``
``386+``
``16/32/64-bit``
"""
VEX_KMOVW_KR_KM16: int = 1918
"""
``KMOVW k1, k2/m16``
``VEX.L0.0F.W0 90 /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_KMOVQ_KR_KM64: int = 1919
"""
``KMOVQ k1, k2/m64``
``VEX.L0.0F.W1 90 /r``
``AVX512BW``
``16/32/64-bit``
"""
VEX_KMOVB_KR_KM8: int = 1920
"""
``KMOVB k1, k2/m8``
``VEX.L0.66.0F.W0 90 /r``
``AVX512DQ``
``16/32/64-bit``
"""
VEX_KMOVD_KR_KM32: int = 1921
"""
``KMOVD k1, k2/m32``
``VEX.L0.66.0F.W1 90 /r``
``AVX512BW``
``16/32/64-bit``
"""
VEX_KMOVW_M16_KR: int = 1922
"""
``KMOVW m16, k1``
``VEX.L0.0F.W0 91 /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_KMOVQ_M64_KR: int = 1923
"""
``KMOVQ m64, k1``
``VEX.L0.0F.W1 91 /r``
``AVX512BW``
``16/32/64-bit``
"""
VEX_KMOVB_M8_KR: int = 1924
"""
``KMOVB m8, k1``
``VEX.L0.66.0F.W0 91 /r``
``AVX512DQ``
``16/32/64-bit``
"""
VEX_KMOVD_M32_KR: int = 1925
"""
``KMOVD m32, k1``
``VEX.L0.66.0F.W1 91 /r``
``AVX512BW``
``16/32/64-bit``
"""
VEX_KMOVW_KR_R32: int = 1926
"""
``KMOVW k1, r32``
``VEX.L0.0F.W0 92 /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_KMOVB_KR_R32: int = 1927
"""
``KMOVB k1, r32``
``VEX.L0.66.0F.W0 92 /r``
``AVX512DQ``
``16/32/64-bit``
"""
VEX_KMOVD_KR_R32: int = 1928
"""
``KMOVD k1, r32``
``VEX.L0.F2.0F.W0 92 /r``
``AVX512BW``
``16/32/64-bit``
"""
VEX_KMOVQ_KR_R64: int = 1929
"""
``KMOVQ k1, r64``
``VEX.L0.F2.0F.W1 92 /r``
``AVX512BW``
``64-bit``
"""
VEX_KMOVW_R32_KR: int = 1930
"""
``KMOVW r32, k1``
``VEX.L0.0F.W0 93 /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_KMOVB_R32_KR: int = 1931
"""
``KMOVB r32, k1``
``VEX.L0.66.0F.W0 93 /r``
``AVX512DQ``
``16/32/64-bit``
"""
VEX_KMOVD_R32_KR: int = 1932
"""
``KMOVD r32, k1``
``VEX.L0.F2.0F.W0 93 /r``
``AVX512BW``
``16/32/64-bit``
"""
VEX_KMOVQ_R64_KR: int = 1933
"""
``KMOVQ r64, k1``
``VEX.L0.F2.0F.W1 93 /r``
``AVX512BW``
``64-bit``
"""
VEX_KORTESTW_KR_KR: int = 1934
"""
``KORTESTW k1, k2``
``VEX.L0.0F.W0 98 /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_KORTESTQ_KR_KR: int = 1935
"""
``KORTESTQ k1, k2``
``VEX.L0.0F.W1 98 /r``
``AVX512BW``
``16/32/64-bit``
"""
VEX_KORTESTB_KR_KR: int = 1936
"""
``KORTESTB k1, k2``
``VEX.L0.66.0F.W0 98 /r``
``AVX512DQ``
``16/32/64-bit``
"""
VEX_KORTESTD_KR_KR: int = 1937
"""
``KORTESTD k1, k2``
``VEX.L0.66.0F.W1 98 /r``
``AVX512BW``
``16/32/64-bit``
"""
VEX_KTESTW_KR_KR: int = 1938
"""
``KTESTW k1, k2``
``VEX.L0.0F.W0 99 /r``
``AVX512DQ``
``16/32/64-bit``
"""
VEX_KTESTQ_KR_KR: int = 1939
"""
``KTESTQ k1, k2``
``VEX.L0.0F.W1 99 /r``
``AVX512BW``
``16/32/64-bit``
"""
VEX_KTESTB_KR_KR: int = 1940
"""
``KTESTB k1, k2``
``VEX.L0.66.0F.W0 99 /r``
``AVX512DQ``
``16/32/64-bit``
"""
VEX_KTESTD_KR_KR: int = 1941
"""
``KTESTD k1, k2``
``VEX.L0.66.0F.W1 99 /r``
``AVX512BW``
``16/32/64-bit``
"""
PUSHW_FS: int = 1942
"""
``PUSH FS``
``o16 0F A0``
``386+``
``16/32/64-bit``
"""
PUSHD_FS: int = 1943
"""
``PUSH FS``
``o32 0F A0``
``386+``
``16/32-bit``
"""
PUSHQ_FS: int = 1944
"""
``PUSH FS``
``o64 0F A0``
``X64``
``64-bit``
"""
POPW_FS: int = 1945
"""
``POP FS``
``o16 0F A1``
``386+``
``16/32/64-bit``
"""
POPD_FS: int = 1946
"""
``POP FS``
``o32 0F A1``
``386+``
``16/32-bit``
"""
POPQ_FS: int = 1947
"""
``POP FS``
``o64 0F A1``
``X64``
``64-bit``
"""
CPUID: int = 1948
"""
``CPUID``
``0F A2``
``CPUID``
``16/32/64-bit``
"""
BT_RM16_R16: int = 1949
"""
``BT r/m16, r16``
``o16 0F A3 /r``
``386+``
``16/32/64-bit``
"""
BT_RM32_R32: int = 1950
"""
``BT r/m32, r32``
``o32 0F A3 /r``
``386+``
``16/32/64-bit``
"""
BT_RM64_R64: int = 1951
"""
``BT r/m64, r64``
``o64 0F A3 /r``
``X64``
``64-bit``
"""
SHLD_RM16_R16_IMM8: int = 1952
"""
``SHLD r/m16, r16, imm8``
``o16 0F A4 /r ib``
``386+``
``16/32/64-bit``
"""
SHLD_RM32_R32_IMM8: int = 1953
"""
``SHLD r/m32, r32, imm8``
``o32 0F A4 /r ib``
``386+``
``16/32/64-bit``
"""
SHLD_RM64_R64_IMM8: int = 1954
"""
``SHLD r/m64, r64, imm8``
``o64 0F A4 /r ib``
``X64``
``64-bit``
"""
SHLD_RM16_R16_CL: int = 1955
"""
``SHLD r/m16, r16, CL``
``o16 0F A5 /r``
``386+``
``16/32/64-bit``
"""
SHLD_RM32_R32_CL: int = 1956
"""
``SHLD r/m32, r32, CL``
``o32 0F A5 /r``
``386+``
``16/32/64-bit``
"""
SHLD_RM64_R64_CL: int = 1957
"""
``SHLD r/m64, r64, CL``
``o64 0F A5 /r``
``X64``
``64-bit``
"""
MONTMUL_16: int = 1958
"""
``MONTMUL``
``a16 F3 0F A6 C0``
``PADLOCK_PMM``
``16/32-bit``
"""
MONTMUL_32: int = 1959
"""
``MONTMUL``
``a32 F3 0F A6 C0``
``PADLOCK_PMM``
``16/32/64-bit``
"""
MONTMUL_64: int = 1960
"""
``MONTMUL``
``a64 F3 0F A6 C0``
``PADLOCK_PMM``
``64-bit``
"""
XSHA1_16: int = 1961
"""
``XSHA1``
``a16 F3 0F A6 C8``
``PADLOCK_PHE``
``16/32-bit``
"""
XSHA1_32: int = 1962
"""
``XSHA1``
``a32 F3 0F A6 C8``
``PADLOCK_PHE``
``16/32/64-bit``
"""
XSHA1_64: int = 1963
"""
``XSHA1``
``a64 F3 0F A6 C8``
``PADLOCK_PHE``
``64-bit``
"""
XSHA256_16: int = 1964
"""
``XSHA256``
``a16 F3 0F A6 D0``
``PADLOCK_PHE``
``16/32-bit``
"""
XSHA256_32: int = 1965
"""
``XSHA256``
``a32 F3 0F A6 D0``
``PADLOCK_PHE``
``16/32/64-bit``
"""
XSHA256_64: int = 1966
"""
``XSHA256``
``a64 F3 0F A6 D0``
``PADLOCK_PHE``
``64-bit``
"""
XBTS_R16_RM16: int = 1967
"""
``XBTS r16, r/m16``
``o16 0F A6 /r``
``386 A0``
``16/32-bit``
"""
XBTS_R32_RM32: int = 1968
"""
``XBTS r32, r/m32``
``o32 0F A6 /r``
``386 A0``
``16/32-bit``
"""
XSTORE_16: int = 1969
"""
``XSTORE``
``a16 0F A7 C0``
``PADLOCK_RNG``
``16/32-bit``
"""
XSTORE_32: int = 1970
"""
``XSTORE``
``a32 0F A7 C0``
``PADLOCK_RNG``
``16/32/64-bit``
"""
XSTORE_64: int = 1971
"""
``XSTORE``
``a64 0F A7 C0``
``PADLOCK_RNG``
``64-bit``
"""
XCRYPTECB_16: int = 1972
"""
``XCRYPTECB``
``a16 F3 0F A7 C8``
``PADLOCK_ACE``
``16/32-bit``
"""
XCRYPTECB_32: int = 1973
"""
``XCRYPTECB``
``a32 F3 0F A7 C8``
``PADLOCK_ACE``
``16/32/64-bit``
"""
XCRYPTECB_64: int = 1974
"""
``XCRYPTECB``
``a64 F3 0F A7 C8``
``PADLOCK_ACE``
``64-bit``
"""
XCRYPTCBC_16: int = 1975
"""
``XCRYPTCBC``
``a16 F3 0F A7 D0``
``PADLOCK_ACE``
``16/32-bit``
"""
XCRYPTCBC_32: int = 1976
"""
``XCRYPTCBC``
``a32 F3 0F A7 D0``
``PADLOCK_ACE``
``16/32/64-bit``
"""
XCRYPTCBC_64: int = 1977
"""
``XCRYPTCBC``
``a64 F3 0F A7 D0``
``PADLOCK_ACE``
``64-bit``
"""
XCRYPTCTR_16: int = 1978
"""
``XCRYPTCTR``
``a16 F3 0F A7 D8``
``PADLOCK_ACE``
``16/32-bit``
"""
XCRYPTCTR_32: int = 1979
"""
``XCRYPTCTR``
``a32 F3 0F A7 D8``
``PADLOCK_ACE``
``16/32/64-bit``
"""
XCRYPTCTR_64: int = 1980
"""
``XCRYPTCTR``
``a64 F3 0F A7 D8``
``PADLOCK_ACE``
``64-bit``
"""
XCRYPTCFB_16: int = 1981
"""
``XCRYPTCFB``
``a16 F3 0F A7 E0``
``PADLOCK_ACE``
``16/32-bit``
"""
XCRYPTCFB_32: int = 1982
"""
``XCRYPTCFB``
``a32 F3 0F A7 E0``
``PADLOCK_ACE``
``16/32/64-bit``
"""
XCRYPTCFB_64: int = 1983
"""
``XCRYPTCFB``
``a64 F3 0F A7 E0``
``PADLOCK_ACE``
``64-bit``
"""
XCRYPTOFB_16: int = 1984
"""
``XCRYPTOFB``
``a16 F3 0F A7 E8``
``PADLOCK_ACE``
``16/32-bit``
"""
XCRYPTOFB_32: int = 1985
"""
``XCRYPTOFB``
``a32 F3 0F A7 E8``
``PADLOCK_ACE``
``16/32/64-bit``
"""
XCRYPTOFB_64: int = 1986
"""
``XCRYPTOFB``
``a64 F3 0F A7 E8``
``PADLOCK_ACE``
``64-bit``
"""
IBTS_RM16_R16: int = 1987
"""
``IBTS r/m16, r16``
``o16 0F A7 /r``
``386 A0``
``16/32-bit``
"""
IBTS_RM32_R32: int = 1988
"""
``IBTS r/m32, r32``
``o32 0F A7 /r``
``386 A0``
``16/32-bit``
"""
CMPXCHG486_RM8_R8: int = 1989
"""
``CMPXCHG r/m8, r8``
``0F A6 /r``
``486 A``
``16/32-bit``
"""
CMPXCHG486_RM16_R16: int = 1990
"""
``CMPXCHG r/m16, r16``
``o16 0F A7 /r``
``486 A``
``16/32-bit``
"""
CMPXCHG486_RM32_R32: int = 1991
"""
``CMPXCHG r/m32, r32``
``o32 0F A7 /r``
``486 A``
``16/32-bit``
"""
PUSHW_GS: int = 1992
"""
``PUSH GS``
``o16 0F A8``
``386+``
``16/32/64-bit``
"""
PUSHD_GS: int = 1993
"""
``PUSH GS``
``o32 0F A8``
``386+``
``16/32-bit``
"""
PUSHQ_GS: int = 1994
"""
``PUSH GS``
``o64 0F A8``
``X64``
``64-bit``
"""
POPW_GS: int = 1995
"""
``POP GS``
``o16 0F A9``
``386+``
``16/32/64-bit``
"""
POPD_GS: int = 1996
"""
``POP GS``
``o32 0F A9``
``386+``
``16/32-bit``
"""
POPQ_GS: int = 1997
"""
``POP GS``
``o64 0F A9``
``X64``
``64-bit``
"""
RSM: int = 1998
"""
``RSM``
``0F AA``
``386+``
``16/32/64-bit``
"""
BTS_RM16_R16: int = 1999
"""
``BTS r/m16, r16``
``o16 0F AB /r``
``386+``
``16/32/64-bit``
"""
BTS_RM32_R32: int = 2000
"""
``BTS r/m32, r32``
``o32 0F AB /r``
``386+``
``16/32/64-bit``
"""
BTS_RM64_R64: int = 2001
"""
``BTS r/m64, r64``
``o64 0F AB /r``
``X64``
``64-bit``
"""
SHRD_RM16_R16_IMM8: int = 2002
"""
``SHRD r/m16, r16, imm8``
``o16 0F AC /r ib``
``386+``
``16/32/64-bit``
"""
SHRD_RM32_R32_IMM8: int = 2003
"""
``SHRD r/m32, r32, imm8``
``o32 0F AC /r ib``
``386+``
``16/32/64-bit``
"""
SHRD_RM64_R64_IMM8: int = 2004
"""
``SHRD r/m64, r64, imm8``
``o64 0F AC /r ib``
``X64``
``64-bit``
"""
SHRD_RM16_R16_CL: int = 2005
"""
``SHRD r/m16, r16, CL``
``o16 0F AD /r``
``386+``
``16/32/64-bit``
"""
SHRD_RM32_R32_CL: int = 2006
"""
``SHRD r/m32, r32, CL``
``o32 0F AD /r``
``386+``
``16/32/64-bit``
"""
SHRD_RM64_R64_CL: int = 2007
"""
``SHRD r/m64, r64, CL``
``o64 0F AD /r``
``X64``
``64-bit``
"""
FXSAVE_M512BYTE: int = 2008
"""
``FXSAVE m512byte``
``NP 0F AE /0``
``FXSR``
``16/32/64-bit``
"""
FXSAVE64_M512BYTE: int = 2009
"""
``FXSAVE64 m512byte``
``NP o64 0F AE /0``
``FXSR``
``64-bit``
"""
RDFSBASE_R32: int = 2010
"""
``RDFSBASE r32``
``F3 0F AE /0``
``FSGSBASE``
``64-bit``
"""
RDFSBASE_R64: int = 2011
"""
``RDFSBASE r64``
``F3 o64 0F AE /0``
``FSGSBASE``
``64-bit``
"""
FXRSTOR_M512BYTE: int = 2012
"""
``FXRSTOR m512byte``
``NP 0F AE /1``
``FXSR``
``16/32/64-bit``
"""
FXRSTOR64_M512BYTE: int = 2013
"""
``FXRSTOR64 m512byte``
``NP o64 0F AE /1``
``FXSR``
``64-bit``
"""
RDGSBASE_R32: int = 2014
"""
``RDGSBASE r32``
``F3 0F AE /1``
``FSGSBASE``
``64-bit``
"""
RDGSBASE_R64: int = 2015
"""
``RDGSBASE r64``
``F3 o64 0F AE /1``
``FSGSBASE``
``64-bit``
"""
LDMXCSR_M32: int = 2016
"""
``LDMXCSR m32``
``NP 0F AE /2``
``SSE``
``16/32/64-bit``
"""
WRFSBASE_R32: int = 2017
"""
``WRFSBASE r32``
``F3 0F AE /2``
``FSGSBASE``
``64-bit``
"""
WRFSBASE_R64: int = 2018
"""
``WRFSBASE r64``
``F3 o64 0F AE /2``
``FSGSBASE``
``64-bit``
"""
VEX_VLDMXCSR_M32: int = 2019
"""
``VLDMXCSR m32``
``VEX.LZ.0F.WIG AE /2``
``AVX``
``16/32/64-bit``
"""
STMXCSR_M32: int = 2020
"""
``STMXCSR m32``
``NP 0F AE /3``
``SSE``
``16/32/64-bit``
"""
WRGSBASE_R32: int = 2021
"""
``WRGSBASE r32``
``F3 0F AE /3``
``FSGSBASE``
``64-bit``
"""
WRGSBASE_R64: int = 2022
"""
``WRGSBASE r64``
``F3 o64 0F AE /3``
``FSGSBASE``
``64-bit``
"""
VEX_VSTMXCSR_M32: int = 2023
"""
``VSTMXCSR m32``
``VEX.LZ.0F.WIG AE /3``
``AVX``
``16/32/64-bit``
"""
XSAVE_MEM: int = 2024
"""
``XSAVE mem``
``NP 0F AE /4``
``XSAVE``
``16/32/64-bit``
"""
XSAVE64_MEM: int = 2025
"""
``XSAVE64 mem``
``NP o64 0F AE /4``
``XSAVE``
``64-bit``
"""
PTWRITE_RM32: int = 2026
"""
``PTWRITE r/m32``
``F3 0F AE /4``
``PTWRITE``
``16/32/64-bit``
"""
PTWRITE_RM64: int = 2027
"""
``PTWRITE r/m64``
``F3 o64 0F AE /4``
``PTWRITE``
``64-bit``
"""
XRSTOR_MEM: int = 2028
"""
``XRSTOR mem``
``NP 0F AE /5``
``XSAVE``
``16/32/64-bit``
"""
XRSTOR64_MEM: int = 2029
"""
``XRSTOR64 mem``
``NP o64 0F AE /5``
``XSAVE``
``64-bit``
"""
INCSSPD_R32: int = 2030
"""
``INCSSPD r32``
``F3 0F AE /5``
``CET_SS``
``16/32/64-bit``
"""
INCSSPQ_R64: int = 2031
"""
``INCSSPQ r64``
``F3 o64 0F AE /5``
``CET_SS``
``64-bit``
"""
XSAVEOPT_MEM: int = 2032
"""
``XSAVEOPT mem``
``NP 0F AE /6``
``XSAVEOPT``
``16/32/64-bit``
"""
XSAVEOPT64_MEM: int = 2033
"""
``XSAVEOPT64 mem``
``NP o64 0F AE /6``
``XSAVEOPT``
``64-bit``
"""
CLWB_M8: int = 2034
"""
``CLWB m8``
``66 0F AE /6``
``CLWB``
``16/32/64-bit``
"""
TPAUSE_R32: int = 2035
"""
``TPAUSE r32, <edx>, <eax>``
``66 0F AE /6``
``WAITPKG``
``16/32/64-bit``
"""
TPAUSE_R64: int = 2036
"""
``TPAUSE r64, <edx>, <eax>``
``66 o64 0F AE /6``
``WAITPKG``
``64-bit``
"""
CLRSSBSY_M64: int = 2037
"""
``CLRSSBSY m64``
``F3 0F AE /6``
``CET_SS``
``16/32/64-bit``
"""
UMONITOR_R16: int = 2038
"""
``UMONITOR r16``
``a16 F3 0F AE /6``
``WAITPKG``
``16/32-bit``
"""
UMONITOR_R32: int = 2039
"""
``UMONITOR r32``
``a32 F3 0F AE /6``
``WAITPKG``
``16/32/64-bit``
"""
UMONITOR_R64: int = 2040
"""
``UMONITOR r64``
``a64 F3 0F AE /6``
``WAITPKG``
``64-bit``
"""
UMWAIT_R32: int = 2041
"""
``UMWAIT r32, <edx>, <eax>``
``F2 0F AE /6``
``WAITPKG``
``16/32/64-bit``
"""
UMWAIT_R64: int = 2042
"""
``UMWAIT r64, <edx>, <eax>``
``F2 o64 0F AE /6``
``WAITPKG``
``64-bit``
"""
CLFLUSH_M8: int = 2043
"""
``CLFLUSH m8``
``NP 0F AE /7``
``CLFSH``
``16/32/64-bit``
"""
CLFLUSHOPT_M8: int = 2044
"""
``CLFLUSHOPT m8``
``66 0F AE /7``
``CLFLUSHOPT``
``16/32/64-bit``
"""
LFENCE: int = 2045
"""
``LFENCE``
``NP 0F AE E8``
``SSE2``
``16/32/64-bit``
"""
LFENCE_E9: int = 2046
"""
``LFENCE``
``NP 0F AE E9``
``SSE2``
``16/32/64-bit``
"""
LFENCE_EA: int = 2047
"""
``LFENCE``
``NP 0F AE EA``
``SSE2``
``16/32/64-bit``
"""
LFENCE_EB: int = 2048
"""
``LFENCE``
``NP 0F AE EB``
``SSE2``
``16/32/64-bit``
"""
LFENCE_EC: int = 2049
"""
``LFENCE``
``NP 0F AE EC``
``SSE2``
``16/32/64-bit``
"""
LFENCE_ED: int = 2050
"""
``LFENCE``
``NP 0F AE ED``
``SSE2``
``16/32/64-bit``
"""
LFENCE_EE: int = 2051
"""
``LFENCE``
``NP 0F AE EE``
``SSE2``
``16/32/64-bit``
"""
LFENCE_EF: int = 2052
"""
``LFENCE``
``NP 0F AE EF``
``SSE2``
``16/32/64-bit``
"""
MFENCE: int = 2053
"""
``MFENCE``
``NP 0F AE F0``
``SSE2``
``16/32/64-bit``
"""
MFENCE_F1: int = 2054
"""
``MFENCE``
``NP 0F AE F1``
``SSE2``
``16/32/64-bit``
"""
MFENCE_F2: int = 2055
"""
``MFENCE``
``NP 0F AE F2``
``SSE2``
``16/32/64-bit``
"""
MFENCE_F3: int = 2056
"""
``MFENCE``
``NP 0F AE F3``
``SSE2``
``16/32/64-bit``
"""
MFENCE_F4: int = 2057
"""
``MFENCE``
``NP 0F AE F4``
``SSE2``
``16/32/64-bit``
"""
MFENCE_F5: int = 2058
"""
``MFENCE``
``NP 0F AE F5``
``SSE2``
``16/32/64-bit``
"""
MFENCE_F6: int = 2059
"""
``MFENCE``
``NP 0F AE F6``
``SSE2``
``16/32/64-bit``
"""
MFENCE_F7: int = 2060
"""
``MFENCE``
``NP 0F AE F7``
``SSE2``
``16/32/64-bit``
"""
SFENCE: int = 2061
"""
``SFENCE``
``NP 0F AE F8``
``SSE``
``16/32/64-bit``
"""
SFENCE_F9: int = 2062
"""
``SFENCE``
``NP 0F AE F9``
``SSE``
``16/32/64-bit``
"""
SFENCE_FA: int = 2063
"""
``SFENCE``
``NP 0F AE FA``
``SSE``
``16/32/64-bit``
"""
SFENCE_FB: int = 2064
"""
``SFENCE``
``NP 0F AE FB``
``SSE``
``16/32/64-bit``
"""
SFENCE_FC: int = 2065
"""
``SFENCE``
``NP 0F AE FC``
``SSE``
``16/32/64-bit``
"""
SFENCE_FD: int = 2066
"""
``SFENCE``
``NP 0F AE FD``
``SSE``
``16/32/64-bit``
"""
SFENCE_FE: int = 2067
"""
``SFENCE``
``NP 0F AE FE``
``SSE``
``16/32/64-bit``
"""
SFENCE_FF: int = 2068
"""
``SFENCE``
``NP 0F AE FF``
``SSE``
``16/32/64-bit``
"""
PCOMMIT: int = 2069
"""
``PCOMMIT``
``66 0F AE F8``
``PCOMMIT``
``16/32/64-bit``
"""
IMUL_R16_RM16: int = 2070
"""
``IMUL r16, r/m16``
``o16 0F AF /r``
``386+``
``16/32/64-bit``
"""
IMUL_R32_RM32: int = 2071
"""
``IMUL r32, r/m32``
``o32 0F AF /r``
``386+``
``16/32/64-bit``
"""
IMUL_R64_RM64: int = 2072
"""
``IMUL r64, r/m64``
``o64 0F AF /r``
``X64``
``64-bit``
"""
CMPXCHG_RM8_R8: int = 2073
"""
``CMPXCHG r/m8, r8``
``0F B0 /r``
``486+``
``16/32/64-bit``
"""
CMPXCHG_RM16_R16: int = 2074
"""
``CMPXCHG r/m16, r16``
``o16 0F B1 /r``
``486+``
``16/32/64-bit``
"""
CMPXCHG_RM32_R32: int = 2075
"""
``CMPXCHG r/m32, r32``
``o32 0F B1 /r``
``486+``
``16/32/64-bit``
"""
CMPXCHG_RM64_R64: int = 2076
"""
``CMPXCHG r/m64, r64``
``o64 0F B1 /r``
``X64``
``64-bit``
"""
LSS_R16_M1616: int = 2077
"""
``LSS r16, m16:16``
``o16 0F B2 /r``
``386+``
``16/32/64-bit``
"""
LSS_R32_M1632: int = 2078
"""
``LSS r32, m16:32``
``o32 0F B2 /r``
``386+``
``16/32/64-bit``
"""
LSS_R64_M1664: int = 2079
"""
``LSS r64, m16:64``
``o64 0F B2 /r``
``X64``
``64-bit``
"""
BTR_RM16_R16: int = 2080
"""
``BTR r/m16, r16``
``o16 0F B3 /r``
``386+``
``16/32/64-bit``
"""
BTR_RM32_R32: int = 2081
"""
``BTR r/m32, r32``
``o32 0F B3 /r``
``386+``
``16/32/64-bit``
"""
BTR_RM64_R64: int = 2082
"""
``BTR r/m64, r64``
``o64 0F B3 /r``
``X64``
``64-bit``
"""
LFS_R16_M1616: int = 2083
"""
``LFS r16, m16:16``
``o16 0F B4 /r``
``386+``
``16/32/64-bit``
"""
LFS_R32_M1632: int = 2084
"""
``LFS r32, m16:32``
``o32 0F B4 /r``
``386+``
``16/32/64-bit``
"""
LFS_R64_M1664: int = 2085
"""
``LFS r64, m16:64``
``o64 0F B4 /r``
``X64``
``64-bit``
"""
LGS_R16_M1616: int = 2086
"""
``LGS r16, m16:16``
``o16 0F B5 /r``
``386+``
``16/32/64-bit``
"""
LGS_R32_M1632: int = 2087
"""
``LGS r32, m16:32``
``o32 0F B5 /r``
``386+``
``16/32/64-bit``
"""
LGS_R64_M1664: int = 2088
"""
``LGS r64, m16:64``
``o64 0F B5 /r``
``X64``
``64-bit``
"""
MOVZX_R16_RM8: int = 2089
"""
``MOVZX r16, r/m8``
``o16 0F B6 /r``
``386+``
``16/32/64-bit``
"""
MOVZX_R32_RM8: int = 2090
"""
``MOVZX r32, r/m8``
``o32 0F B6 /r``
``386+``
``16/32/64-bit``
"""
MOVZX_R64_RM8: int = 2091
"""
``MOVZX r64, r/m8``
``o64 0F B6 /r``
``X64``
``64-bit``
"""
MOVZX_R16_RM16: int = 2092
"""
``MOVZX r16, r/m16``
``o16 0F B7 /r``
``386+``
``16/32/64-bit``
"""
MOVZX_R32_RM16: int = 2093
"""
``MOVZX r32, r/m16``
``o32 0F B7 /r``
``386+``
``16/32/64-bit``
"""
MOVZX_R64_RM16: int = 2094
"""
``MOVZX r64, r/m16``
``o64 0F B7 /r``
``X64``
``64-bit``
"""
JMPE_DISP16: int = 2095
"""
``JMPE disp16``
``o16 0F B8 cw``
``IA-64``
``16/32-bit``
"""
JMPE_DISP32: int = 2096
"""
``JMPE disp32``
``o32 0F B8 cd``
``IA-64``
``16/32-bit``
"""
POPCNT_R16_RM16: int = 2097
"""
``POPCNT r16, r/m16``
``o16 F3 0F B8 /r``
``POPCNT``
``16/32/64-bit``
"""
POPCNT_R32_RM32: int = 2098
"""
``POPCNT r32, r/m32``
``o32 F3 0F B8 /r``
``POPCNT``
``16/32/64-bit``
"""
POPCNT_R64_RM64: int = 2099
"""
``POPCNT r64, r/m64``
``F3 o64 0F B8 /r``
``POPCNT``
``64-bit``
"""
UD1_R16_RM16: int = 2100
"""
``UD1 r16, r/m16``
``o16 0F B9 /r``
``286+``
``16/32/64-bit``
"""
UD1_R32_RM32: int = 2101
"""
``UD1 r32, r/m32``
``o32 0F B9 /r``
``386+``
``16/32/64-bit``
"""
UD1_R64_RM64: int = 2102
"""
``UD1 r64, r/m64``
``o64 0F B9 /r``
``X64``
``64-bit``
"""
BT_RM16_IMM8: int = 2103
"""
``BT r/m16, imm8``
``o16 0F BA /4 ib``
``386+``
``16/32/64-bit``
"""
BT_RM32_IMM8: int = 2104
"""
``BT r/m32, imm8``
``o32 0F BA /4 ib``
``386+``
``16/32/64-bit``
"""
BT_RM64_IMM8: int = 2105
"""
``BT r/m64, imm8``
``o64 0F BA /4 ib``
``X64``
``64-bit``
"""
BTS_RM16_IMM8: int = 2106
"""
``BTS r/m16, imm8``
``o16 0F BA /5 ib``
``386+``
``16/32/64-bit``
"""
BTS_RM32_IMM8: int = 2107
"""
``BTS r/m32, imm8``
``o32 0F BA /5 ib``
``386+``
``16/32/64-bit``
"""
BTS_RM64_IMM8: int = 2108
"""
``BTS r/m64, imm8``
``o64 0F BA /5 ib``
``X64``
``64-bit``
"""
BTR_RM16_IMM8: int = 2109
"""
``BTR r/m16, imm8``
``o16 0F BA /6 ib``
``386+``
``16/32/64-bit``
"""
BTR_RM32_IMM8: int = 2110
"""
``BTR r/m32, imm8``
``o32 0F BA /6 ib``
``386+``
``16/32/64-bit``
"""
BTR_RM64_IMM8: int = 2111
"""
``BTR r/m64, imm8``
``o64 0F BA /6 ib``
``X64``
``64-bit``
"""
BTC_RM16_IMM8: int = 2112
"""
``BTC r/m16, imm8``
``o16 0F BA /7 ib``
``386+``
``16/32/64-bit``
"""
BTC_RM32_IMM8: int = 2113
"""
``BTC r/m32, imm8``
``o32 0F BA /7 ib``
``386+``
``16/32/64-bit``
"""
BTC_RM64_IMM8: int = 2114
"""
``BTC r/m64, imm8``
``o64 0F BA /7 ib``
``X64``
``64-bit``
"""
BTC_RM16_R16: int = 2115
"""
``BTC r/m16, r16``
``o16 0F BB /r``
``386+``
``16/32/64-bit``
"""
BTC_RM32_R32: int = 2116
"""
``BTC r/m32, r32``
``o32 0F BB /r``
``386+``
``16/32/64-bit``
"""
BTC_RM64_R64: int = 2117
"""
``BTC r/m64, r64``
``o64 0F BB /r``
``X64``
``64-bit``
"""
BSF_R16_RM16: int = 2118
"""
``BSF r16, r/m16``
``o16 0F BC /r``
``386+``
``16/32/64-bit``
"""
BSF_R32_RM32: int = 2119
"""
``BSF r32, r/m32``
``o32 0F BC /r``
``386+``
``16/32/64-bit``
"""
BSF_R64_RM64: int = 2120
"""
``BSF r64, r/m64``
``o64 0F BC /r``
``X64``
``64-bit``
"""
TZCNT_R16_RM16: int = 2121
"""
``TZCNT r16, r/m16``
``o16 F3 0F BC /r``
``BMI1``
``16/32/64-bit``
"""
TZCNT_R32_RM32: int = 2122
"""
``TZCNT r32, r/m32``
``o32 F3 0F BC /r``
``BMI1``
``16/32/64-bit``
"""
TZCNT_R64_RM64: int = 2123
"""
``TZCNT r64, r/m64``
``F3 o64 0F BC /r``
``BMI1``
``64-bit``
"""
BSR_R16_RM16: int = 2124
"""
``BSR r16, r/m16``
``o16 0F BD /r``
``386+``
``16/32/64-bit``
"""
BSR_R32_RM32: int = 2125
"""
``BSR r32, r/m32``
``o32 0F BD /r``
``386+``
``16/32/64-bit``
"""
BSR_R64_RM64: int = 2126
"""
``BSR r64, r/m64``
``o64 0F BD /r``
``X64``
``64-bit``
"""
LZCNT_R16_RM16: int = 2127
"""
``LZCNT r16, r/m16``
``o16 F3 0F BD /r``
``LZCNT``
``16/32/64-bit``
"""
LZCNT_R32_RM32: int = 2128
"""
``LZCNT r32, r/m32``
``o32 F3 0F BD /r``
``LZCNT``
``16/32/64-bit``
"""
LZCNT_R64_RM64: int = 2129
"""
``LZCNT r64, r/m64``
``F3 o64 0F BD /r``
``LZCNT``
``64-bit``
"""
MOVSX_R16_RM8: int = 2130
"""
``MOVSX r16, r/m8``
``o16 0F BE /r``
``386+``
``16/32/64-bit``
"""
MOVSX_R32_RM8: int = 2131
"""
``MOVSX r32, r/m8``
``o32 0F BE /r``
``386+``
``16/32/64-bit``
"""
MOVSX_R64_RM8: int = 2132
"""
``MOVSX r64, r/m8``
``o64 0F BE /r``
``X64``
``64-bit``
"""
MOVSX_R16_RM16: int = 2133
"""
``MOVSX r16, r/m16``
``o16 0F BF /r``
``386+``
``16/32/64-bit``
"""
MOVSX_R32_RM16: int = 2134
"""
``MOVSX r32, r/m16``
``o32 0F BF /r``
``386+``
``16/32/64-bit``
"""
MOVSX_R64_RM16: int = 2135
"""
``MOVSX r64, r/m16``
``o64 0F BF /r``
``X64``
``64-bit``
"""
XADD_RM8_R8: int = 2136
"""
``XADD r/m8, r8``
``0F C0 /r``
``486+``
``16/32/64-bit``
"""
XADD_RM16_R16: int = 2137
"""
``XADD r/m16, r16``
``o16 0F C1 /r``
``486+``
``16/32/64-bit``
"""
XADD_RM32_R32: int = 2138
"""
``XADD r/m32, r32``
``o32 0F C1 /r``
``486+``
``16/32/64-bit``
"""
XADD_RM64_R64: int = 2139
"""
``XADD r/m64, r64``
``o64 0F C1 /r``
``X64``
``64-bit``
"""
CMPPS_XMM_XMMM128_IMM8: int = 2140
"""
``CMPPS xmm1, xmm2/m128, imm8``
``NP 0F C2 /r ib``
``SSE``
``16/32/64-bit``
"""
VEX_VCMPPS_XMM_XMM_XMMM128_IMM8: int = 2141
"""
``VCMPPS xmm1, xmm2, xmm3/m128, imm8``
``VEX.128.0F.WIG C2 /r ib``
``AVX``
``16/32/64-bit``
"""
VEX_VCMPPS_YMM_YMM_YMMM256_IMM8: int = 2142
"""
``VCMPPS ymm1, ymm2, ymm3/m256, imm8``
``VEX.256.0F.WIG C2 /r ib``
``AVX``
``16/32/64-bit``
"""
EVEX_VCMPPS_KR_K1_XMM_XMMM128B32_IMM8: int = 2143
"""
``VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8``
``EVEX.128.0F.W0 C2 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VCMPPS_KR_K1_YMM_YMMM256B32_IMM8: int = 2144
"""
``VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8``
``EVEX.256.0F.W0 C2 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VCMPPS_KR_K1_ZMM_ZMMM512B32_IMM8_SAE: int = 2145
"""
``VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8``
``EVEX.512.0F.W0 C2 /r ib``
``AVX512F``
``16/32/64-bit``
"""
CMPPD_XMM_XMMM128_IMM8: int = 2146
"""
``CMPPD xmm1, xmm2/m128, imm8``
``66 0F C2 /r ib``
``SSE2``
``16/32/64-bit``
"""
VEX_VCMPPD_XMM_XMM_XMMM128_IMM8: int = 2147
"""
``VCMPPD xmm1, xmm2, xmm3/m128, imm8``
``VEX.128.66.0F.WIG C2 /r ib``
``AVX``
``16/32/64-bit``
"""
VEX_VCMPPD_YMM_YMM_YMMM256_IMM8: int = 2148
"""
``VCMPPD ymm1, ymm2, ymm3/m256, imm8``
``VEX.256.66.0F.WIG C2 /r ib``
``AVX``
``16/32/64-bit``
"""
EVEX_VCMPPD_KR_K1_XMM_XMMM128B64_IMM8: int = 2149
"""
``VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8``
``EVEX.128.66.0F.W1 C2 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VCMPPD_KR_K1_YMM_YMMM256B64_IMM8: int = 2150
"""
``VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8``
``EVEX.256.66.0F.W1 C2 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VCMPPD_KR_K1_ZMM_ZMMM512B64_IMM8_SAE: int = 2151
"""
``VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8``
``EVEX.512.66.0F.W1 C2 /r ib``
``AVX512F``
``16/32/64-bit``
"""
CMPSS_XMM_XMMM32_IMM8: int = 2152
"""
``CMPSS xmm1, xmm2/m32, imm8``
``F3 0F C2 /r ib``
``SSE``
``16/32/64-bit``
"""
VEX_VCMPSS_XMM_XMM_XMMM32_IMM8: int = 2153
"""
``VCMPSS xmm1, xmm2, xmm3/m32, imm8``
``VEX.LIG.F3.0F.WIG C2 /r ib``
``AVX``
``16/32/64-bit``
"""
EVEX_VCMPSS_KR_K1_XMM_XMMM32_IMM8_SAE: int = 2154
"""
``VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8``
``EVEX.LIG.F3.0F.W0 C2 /r ib``
``AVX512F``
``16/32/64-bit``
"""
CMPSD_XMM_XMMM64_IMM8: int = 2155
"""
``CMPSD xmm1, xmm2/m64, imm8``
``F2 0F C2 /r ib``
``SSE2``
``16/32/64-bit``
"""
VEX_VCMPSD_XMM_XMM_XMMM64_IMM8: int = 2156
"""
``VCMPSD xmm1, xmm2, xmm3/m64, imm8``
``VEX.LIG.F2.0F.WIG C2 /r ib``
``AVX``
``16/32/64-bit``
"""
EVEX_VCMPSD_KR_K1_XMM_XMMM64_IMM8_SAE: int = 2157
"""
``VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8``
``EVEX.LIG.F2.0F.W1 C2 /r ib``
``AVX512F``
``16/32/64-bit``
"""
MOVNTI_M32_R32: int = 2158
"""
``MOVNTI m32, r32``
``NP 0F C3 /r``
``SSE2``
``16/32/64-bit``
"""
MOVNTI_M64_R64: int = 2159
"""
``MOVNTI m64, r64``
``NP o64 0F C3 /r``
``SSE2``
``64-bit``
"""
PINSRW_MM_R32M16_IMM8: int = 2160
"""
``PINSRW mm, r32/m16, imm8``
``NP 0F C4 /r ib``
``SSE``
``16/32/64-bit``
"""
PINSRW_MM_R64M16_IMM8: int = 2161
"""
``PINSRW mm, r64/m16, imm8``
``NP o64 0F C4 /r ib``
``SSE``
``64-bit``
"""
PINSRW_XMM_R32M16_IMM8: int = 2162
"""
``PINSRW xmm, r32/m16, imm8``
``66 0F C4 /r ib``
``SSE2``
``16/32/64-bit``
"""
PINSRW_XMM_R64M16_IMM8: int = 2163
"""
``PINSRW xmm, r64/m16, imm8``
``66 o64 0F C4 /r ib``
``SSE2``
``64-bit``
"""
VEX_VPINSRW_XMM_XMM_R32M16_IMM8: int = 2164
"""
``VPINSRW xmm1, xmm2, r32/m16, imm8``
``VEX.128.66.0F.W0 C4 /r ib``
``AVX``
``16/32/64-bit``
"""
VEX_VPINSRW_XMM_XMM_R64M16_IMM8: int = 2165
"""
``VPINSRW xmm1, xmm2, r64/m16, imm8``
``VEX.128.66.0F.W1 C4 /r ib``
``AVX``
``64-bit``
"""
EVEX_VPINSRW_XMM_XMM_R32M16_IMM8: int = 2166
"""
``VPINSRW xmm1, xmm2, r32/m16, imm8``
``EVEX.128.66.0F.W0 C4 /r ib``
``AVX512BW``
``16/32/64-bit``
"""
EVEX_VPINSRW_XMM_XMM_R64M16_IMM8: int = 2167
"""
``VPINSRW xmm1, xmm2, r64/m16, imm8``
``EVEX.128.66.0F.W1 C4 /r ib``
``AVX512BW``
``64-bit``
"""
PEXTRW_R32_MM_IMM8: int = 2168
"""
``PEXTRW r32, mm, imm8``
``NP 0F C5 /r ib``
``SSE``
``16/32/64-bit``
"""
PEXTRW_R64_MM_IMM8: int = 2169
"""
``PEXTRW r64, mm, imm8``
``NP o64 0F C5 /r ib``
``SSE``
``64-bit``
"""
PEXTRW_R32_XMM_IMM8: int = 2170
"""
``PEXTRW r32, xmm, imm8``
``66 0F C5 /r ib``
``SSE2``
``16/32/64-bit``
"""
PEXTRW_R64_XMM_IMM8: int = 2171
"""
``PEXTRW r64, xmm, imm8``
``66 o64 0F C5 /r ib``
``SSE2``
``64-bit``
"""
VEX_VPEXTRW_R32_XMM_IMM8: int = 2172
"""
``VPEXTRW r32, xmm1, imm8``
``VEX.128.66.0F.W0 C5 /r ib``
``AVX``
``16/32/64-bit``
"""
VEX_VPEXTRW_R64_XMM_IMM8: int = 2173
"""
``VPEXTRW r64, xmm1, imm8``
``VEX.128.66.0F.W1 C5 /r ib``
``AVX``
``64-bit``
"""
EVEX_VPEXTRW_R32_XMM_IMM8: int = 2174
"""
``VPEXTRW r32, xmm1, imm8``
``EVEX.128.66.0F.W0 C5 /r ib``
``AVX512BW``
``16/32/64-bit``
"""
EVEX_VPEXTRW_R64_XMM_IMM8: int = 2175
"""
``VPEXTRW r64, xmm1, imm8``
``EVEX.128.66.0F.W1 C5 /r ib``
``AVX512BW``
``64-bit``
"""
SHUFPS_XMM_XMMM128_IMM8: int = 2176
"""
``SHUFPS xmm1, xmm2/m128, imm8``
``NP 0F C6 /r ib``
``SSE``
``16/32/64-bit``
"""
VEX_VSHUFPS_XMM_XMM_XMMM128_IMM8: int = 2177
"""
``VSHUFPS xmm1, xmm2, xmm3/m128, imm8``
``VEX.128.0F.WIG C6 /r ib``
``AVX``
``16/32/64-bit``
"""
VEX_VSHUFPS_YMM_YMM_YMMM256_IMM8: int = 2178
"""
``VSHUFPS ymm1, ymm2, ymm3/m256, imm8``
``VEX.256.0F.WIG C6 /r ib``
``AVX``
``16/32/64-bit``
"""
EVEX_VSHUFPS_XMM_K1Z_XMM_XMMM128B32_IMM8: int = 2179
"""
``VSHUFPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8``
``EVEX.128.0F.W0 C6 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VSHUFPS_YMM_K1Z_YMM_YMMM256B32_IMM8: int = 2180
"""
``VSHUFPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8``
``EVEX.256.0F.W0 C6 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VSHUFPS_ZMM_K1Z_ZMM_ZMMM512B32_IMM8: int = 2181
"""
``VSHUFPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8``
``EVEX.512.0F.W0 C6 /r ib``
``AVX512F``
``16/32/64-bit``
"""
SHUFPD_XMM_XMMM128_IMM8: int = 2182
"""
``SHUFPD xmm1, xmm2/m128, imm8``
``66 0F C6 /r ib``
``SSE2``
``16/32/64-bit``
"""
VEX_VSHUFPD_XMM_XMM_XMMM128_IMM8: int = 2183
"""
``VSHUFPD xmm1, xmm2, xmm3/m128, imm8``
``VEX.128.66.0F.WIG C6 /r ib``
``AVX``
``16/32/64-bit``
"""
VEX_VSHUFPD_YMM_YMM_YMMM256_IMM8: int = 2184
"""
``VSHUFPD ymm1, ymm2, ymm3/m256, imm8``
``VEX.256.66.0F.WIG C6 /r ib``
``AVX``
``16/32/64-bit``
"""
EVEX_VSHUFPD_XMM_K1Z_XMM_XMMM128B64_IMM8: int = 2185
"""
``VSHUFPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8``
``EVEX.128.66.0F.W1 C6 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VSHUFPD_YMM_K1Z_YMM_YMMM256B64_IMM8: int = 2186
"""
``VSHUFPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8``
``EVEX.256.66.0F.W1 C6 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VSHUFPD_ZMM_K1Z_ZMM_ZMMM512B64_IMM8: int = 2187
"""
``VSHUFPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8``
``EVEX.512.66.0F.W1 C6 /r ib``
``AVX512F``
``16/32/64-bit``
"""
CMPXCHG8B_M64: int = 2188
"""
``CMPXCHG8B m64``
``0F C7 /1``
``CX8``
``16/32/64-bit``
"""
CMPXCHG16B_M128: int = 2189
"""
``CMPXCHG16B m128``
``o64 0F C7 /1``
``CMPXCHG16B``
``64-bit``
"""
XRSTORS_MEM: int = 2190
"""
``XRSTORS mem``
``NP 0F C7 /3``
``XSAVES``
``16/32/64-bit``
"""
XRSTORS64_MEM: int = 2191
"""
``XRSTORS64 mem``
``NP o64 0F C7 /3``
``XSAVES``
``64-bit``
"""
XSAVEC_MEM: int = 2192
"""
``XSAVEC mem``
``NP 0F C7 /4``
``XSAVEC``
``16/32/64-bit``
"""
XSAVEC64_MEM: int = 2193
"""
``XSAVEC64 mem``
``NP o64 0F C7 /4``
``XSAVEC``
``64-bit``
"""
XSAVES_MEM: int = 2194
"""
``XSAVES mem``
``NP 0F C7 /5``
``XSAVES``
``16/32/64-bit``
"""
XSAVES64_MEM: int = 2195
"""
``XSAVES64 mem``
``NP o64 0F C7 /5``
``XSAVES``
``64-bit``
"""
VMPTRLD_M64: int = 2196
"""
``VMPTRLD m64``
``NP 0F C7 /6``
``VMX``
``16/32/64-bit``
"""
VMCLEAR_M64: int = 2197
"""
``VMCLEAR m64``
``66 0F C7 /6``
``VMX``
``16/32/64-bit``
"""
VMXON_M64: int = 2198
"""
``VMXON m64``
``F3 0F C7 /6``
``VMX``
``16/32/64-bit``
"""
RDRAND_R16: int = 2199
"""
``RDRAND r16``
``o16 0F C7 /6``
``RDRAND``
``16/32/64-bit``
"""
RDRAND_R32: int = 2200
"""
``RDRAND r32``
``o32 0F C7 /6``
``RDRAND``
``16/32/64-bit``
"""
RDRAND_R64: int = 2201
"""
``RDRAND r64``
``o64 0F C7 /6``
``RDRAND``
``64-bit``
"""
VMPTRST_M64: int = 2202
"""
``VMPTRST m64``
``NP 0F C7 /7``
``VMX``
``16/32/64-bit``
"""
RDSEED_R16: int = 2203
"""
``RDSEED r16``
``o16 0F C7 /7``
``RDSEED``
``16/32/64-bit``
"""
RDSEED_R32: int = 2204
"""
``RDSEED r32``
``o32 0F C7 /7``
``RDSEED``
``16/32/64-bit``
"""
RDSEED_R64: int = 2205
"""
``RDSEED r64``
``o64 0F C7 /7``
``RDSEED``
``64-bit``
"""
RDPID_R32: int = 2206
"""
``RDPID r32``
``F3 0F C7 /7``
``RDPID``
``16/32-bit``
"""
RDPID_R64: int = 2207
"""
``RDPID r64``
``F3 0F C7 /7``
``RDPID``
``64-bit``
"""
BSWAP_R16: int = 2208
"""
``BSWAP r16``
``o16 0F C8+rw``
``486+``
``16/32/64-bit``
"""
BSWAP_R32: int = 2209
"""
``BSWAP r32``
``o32 0F C8+rd``
``486+``
``16/32/64-bit``
"""
BSWAP_R64: int = 2210
"""
``BSWAP r64``
``o64 0F C8+ro``
``X64``
``64-bit``
"""
ADDSUBPD_XMM_XMMM128: int = 2211
"""
``ADDSUBPD xmm1, xmm2/m128``
``66 0F D0 /r``
``SSE3``
``16/32/64-bit``
"""
VEX_VADDSUBPD_XMM_XMM_XMMM128: int = 2212
"""
``VADDSUBPD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG D0 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VADDSUBPD_YMM_YMM_YMMM256: int = 2213
"""
``VADDSUBPD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG D0 /r``
``AVX``
``16/32/64-bit``
"""
ADDSUBPS_XMM_XMMM128: int = 2214
"""
``ADDSUBPS xmm1, xmm2/m128``
``F2 0F D0 /r``
``SSE3``
``16/32/64-bit``
"""
VEX_VADDSUBPS_XMM_XMM_XMMM128: int = 2215
"""
``VADDSUBPS xmm1, xmm2, xmm3/m128``
``VEX.128.F2.0F.WIG D0 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VADDSUBPS_YMM_YMM_YMMM256: int = 2216
"""
``VADDSUBPS ymm1, ymm2, ymm3/m256``
``VEX.256.F2.0F.WIG D0 /r``
``AVX``
``16/32/64-bit``
"""
PSRLW_MM_MMM64: int = 2217
"""
``PSRLW mm, mm/m64``
``NP 0F D1 /r``
``MMX``
``16/32/64-bit``
"""
PSRLW_XMM_XMMM128: int = 2218
"""
``PSRLW xmm1, xmm2/m128``
``66 0F D1 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPSRLW_XMM_XMM_XMMM128: int = 2219
"""
``VPSRLW xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG D1 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPSRLW_YMM_YMM_XMMM128: int = 2220
"""
``VPSRLW ymm1, ymm2, xmm3/m128``
``VEX.256.66.0F.WIG D1 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPSRLW_XMM_K1Z_XMM_XMMM128: int = 2221
"""
``VPSRLW xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F.WIG D1 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSRLW_YMM_K1Z_YMM_XMMM128: int = 2222
"""
``VPSRLW ymm1 {k1}{z}, ymm2, xmm3/m128``
``EVEX.256.66.0F.WIG D1 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSRLW_ZMM_K1Z_ZMM_XMMM128: int = 2223
"""
``VPSRLW zmm1 {k1}{z}, zmm2, xmm3/m128``
``EVEX.512.66.0F.WIG D1 /r``
``AVX512BW``
``16/32/64-bit``
"""
PSRLD_MM_MMM64: int = 2224
"""
``PSRLD mm, mm/m64``
``NP 0F D2 /r``
``MMX``
``16/32/64-bit``
"""
PSRLD_XMM_XMMM128: int = 2225
"""
``PSRLD xmm1, xmm2/m128``
``66 0F D2 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPSRLD_XMM_XMM_XMMM128: int = 2226
"""
``VPSRLD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG D2 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPSRLD_YMM_YMM_XMMM128: int = 2227
"""
``VPSRLD ymm1, ymm2, xmm3/m128``
``VEX.256.66.0F.WIG D2 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPSRLD_XMM_K1Z_XMM_XMMM128: int = 2228
"""
``VPSRLD xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F.W0 D2 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSRLD_YMM_K1Z_YMM_XMMM128: int = 2229
"""
``VPSRLD ymm1 {k1}{z}, ymm2, xmm3/m128``
``EVEX.256.66.0F.W0 D2 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSRLD_ZMM_K1Z_ZMM_XMMM128: int = 2230
"""
``VPSRLD zmm1 {k1}{z}, zmm2, xmm3/m128``
``EVEX.512.66.0F.W0 D2 /r``
``AVX512F``
``16/32/64-bit``
"""
PSRLQ_MM_MMM64: int = 2231
"""
``PSRLQ mm, mm/m64``
``NP 0F D3 /r``
``MMX``
``16/32/64-bit``
"""
PSRLQ_XMM_XMMM128: int = 2232
"""
``PSRLQ xmm1, xmm2/m128``
``66 0F D3 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPSRLQ_XMM_XMM_XMMM128: int = 2233
"""
``VPSRLQ xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG D3 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPSRLQ_YMM_YMM_XMMM128: int = 2234
"""
``VPSRLQ ymm1, ymm2, xmm3/m128``
``VEX.256.66.0F.WIG D3 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPSRLQ_XMM_K1Z_XMM_XMMM128: int = 2235
"""
``VPSRLQ xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F.W1 D3 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSRLQ_YMM_K1Z_YMM_XMMM128: int = 2236
"""
``VPSRLQ ymm1 {k1}{z}, ymm2, xmm3/m128``
``EVEX.256.66.0F.W1 D3 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSRLQ_ZMM_K1Z_ZMM_XMMM128: int = 2237
"""
``VPSRLQ zmm1 {k1}{z}, zmm2, xmm3/m128``
``EVEX.512.66.0F.W1 D3 /r``
``AVX512F``
``16/32/64-bit``
"""
PADDQ_MM_MMM64: int = 2238
"""
``PADDQ mm, mm/m64``
``NP 0F D4 /r``
``MMX``
``16/32/64-bit``
"""
PADDQ_XMM_XMMM128: int = 2239
"""
``PADDQ xmm1, xmm2/m128``
``66 0F D4 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPADDQ_XMM_XMM_XMMM128: int = 2240
"""
``VPADDQ xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG D4 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPADDQ_YMM_YMM_YMMM256: int = 2241
"""
``VPADDQ ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG D4 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPADDQ_XMM_K1Z_XMM_XMMM128B64: int = 2242
"""
``VPADDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F.W1 D4 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPADDQ_YMM_K1Z_YMM_YMMM256B64: int = 2243
"""
``VPADDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F.W1 D4 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPADDQ_ZMM_K1Z_ZMM_ZMMM512B64: int = 2244
"""
``VPADDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F.W1 D4 /r``
``AVX512F``
``16/32/64-bit``
"""
PMULLW_MM_MMM64: int = 2245
"""
``PMULLW mm, mm/m64``
``NP 0F D5 /r``
``MMX``
``16/32/64-bit``
"""
PMULLW_XMM_XMMM128: int = 2246
"""
``PMULLW xmm1, xmm2/m128``
``66 0F D5 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPMULLW_XMM_XMM_XMMM128: int = 2247
"""
``VPMULLW xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG D5 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPMULLW_YMM_YMM_YMMM256: int = 2248
"""
``VPMULLW ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG D5 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPMULLW_XMM_K1Z_XMM_XMMM128: int = 2249
"""
``VPMULLW xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F.WIG D5 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMULLW_YMM_K1Z_YMM_YMMM256: int = 2250
"""
``VPMULLW ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F.WIG D5 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMULLW_ZMM_K1Z_ZMM_ZMMM512: int = 2251
"""
``VPMULLW zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F.WIG D5 /r``
``AVX512BW``
``16/32/64-bit``
"""
MOVQ_XMMM64_XMM: int = 2252
"""
``MOVQ xmm2/m64, xmm1``
``66 0F D6 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VMOVQ_XMMM64_XMM: int = 2253
"""
``VMOVQ xmm1/m64, xmm2``
``VEX.128.66.0F.WIG D6 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMOVQ_XMMM64_XMM: int = 2254
"""
``VMOVQ xmm1/m64, xmm2``
``EVEX.128.66.0F.W1 D6 /r``
``AVX512F``
``16/32/64-bit``
"""
MOVQ2DQ_XMM_MM: int = 2255
"""
``MOVQ2DQ xmm, mm``
``F3 0F D6 /r``
``SSE2``
``16/32/64-bit``
"""
MOVDQ2Q_MM_XMM: int = 2256
"""
``MOVDQ2Q mm, xmm``
``F2 0F D6 /r``
``SSE2``
``16/32/64-bit``
"""
PMOVMSKB_R32_MM: int = 2257
"""
``PMOVMSKB r32, mm``
``NP 0F D7 /r``
``SSE``
``16/32/64-bit``
"""
PMOVMSKB_R64_MM: int = 2258
"""
``PMOVMSKB r64, mm``
``NP o64 0F D7 /r``
``SSE``
``64-bit``
"""
PMOVMSKB_R32_XMM: int = 2259
"""
``PMOVMSKB r32, xmm``
``66 0F D7 /r``
``SSE2``
``16/32/64-bit``
"""
PMOVMSKB_R64_XMM: int = 2260
"""
``PMOVMSKB r64, xmm``
``66 o64 0F D7 /r``
``SSE2``
``64-bit``
"""
VEX_VPMOVMSKB_R32_XMM: int = 2261
"""
``VPMOVMSKB r32, xmm1``
``VEX.128.66.0F.W0 D7 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPMOVMSKB_R64_XMM: int = 2262
"""
``VPMOVMSKB r64, xmm1``
``VEX.128.66.0F.W1 D7 /r``
``AVX``
``64-bit``
"""
VEX_VPMOVMSKB_R32_YMM: int = 2263
"""
``VPMOVMSKB r32, ymm1``
``VEX.256.66.0F.W0 D7 /r``
``AVX2``
``16/32/64-bit``
"""
VEX_VPMOVMSKB_R64_YMM: int = 2264
"""
``VPMOVMSKB r64, ymm1``
``VEX.256.66.0F.W1 D7 /r``
``AVX2``
``64-bit``
"""
PSUBUSB_MM_MMM64: int = 2265
"""
``PSUBUSB mm, mm/m64``
``NP 0F D8 /r``
``MMX``
``16/32/64-bit``
"""
PSUBUSB_XMM_XMMM128: int = 2266
"""
``PSUBUSB xmm1, xmm2/m128``
``66 0F D8 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPSUBUSB_XMM_XMM_XMMM128: int = 2267
"""
``VPSUBUSB xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG D8 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPSUBUSB_YMM_YMM_YMMM256: int = 2268
"""
``VPSUBUSB ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG D8 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPSUBUSB_XMM_K1Z_XMM_XMMM128: int = 2269
"""
``VPSUBUSB xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F.WIG D8 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSUBUSB_YMM_K1Z_YMM_YMMM256: int = 2270
"""
``VPSUBUSB ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F.WIG D8 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSUBUSB_ZMM_K1Z_ZMM_ZMMM512: int = 2271
"""
``VPSUBUSB zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F.WIG D8 /r``
``AVX512BW``
``16/32/64-bit``
"""
PSUBUSW_MM_MMM64: int = 2272
"""
``PSUBUSW mm, mm/m64``
``NP 0F D9 /r``
``MMX``
``16/32/64-bit``
"""
PSUBUSW_XMM_XMMM128: int = 2273
"""
``PSUBUSW xmm1, xmm2/m128``
``66 0F D9 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPSUBUSW_XMM_XMM_XMMM128: int = 2274
"""
``VPSUBUSW xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG D9 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPSUBUSW_YMM_YMM_YMMM256: int = 2275
"""
``VPSUBUSW ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG D9 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPSUBUSW_XMM_K1Z_XMM_XMMM128: int = 2276
"""
``VPSUBUSW xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F.WIG D9 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSUBUSW_YMM_K1Z_YMM_YMMM256: int = 2277
"""
``VPSUBUSW ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F.WIG D9 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSUBUSW_ZMM_K1Z_ZMM_ZMMM512: int = 2278
"""
``VPSUBUSW zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F.WIG D9 /r``
``AVX512BW``
``16/32/64-bit``
"""
PMINUB_MM_MMM64: int = 2279
"""
``PMINUB mm1, mm2/m64``
``NP 0F DA /r``
``SSE``
``16/32/64-bit``
"""
PMINUB_XMM_XMMM128: int = 2280
"""
``PMINUB xmm1, xmm2/m128``
``66 0F DA /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPMINUB_XMM_XMM_XMMM128: int = 2281
"""
``VPMINUB xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG DA /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPMINUB_YMM_YMM_YMMM256: int = 2282
"""
``VPMINUB ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG DA /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPMINUB_XMM_K1Z_XMM_XMMM128: int = 2283
"""
``VPMINUB xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F.WIG DA /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMINUB_YMM_K1Z_YMM_YMMM256: int = 2284
"""
``VPMINUB ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F.WIG DA /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMINUB_ZMM_K1Z_ZMM_ZMMM512: int = 2285
"""
``VPMINUB zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F.WIG DA /r``
``AVX512BW``
``16/32/64-bit``
"""
PAND_MM_MMM64: int = 2286
"""
``PAND mm, mm/m64``
``NP 0F DB /r``
``MMX``
``16/32/64-bit``
"""
PAND_XMM_XMMM128: int = 2287
"""
``PAND xmm1, xmm2/m128``
``66 0F DB /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPAND_XMM_XMM_XMMM128: int = 2288
"""
``VPAND xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG DB /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPAND_YMM_YMM_YMMM256: int = 2289
"""
``VPAND ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG DB /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPANDD_XMM_K1Z_XMM_XMMM128B32: int = 2290
"""
``VPANDD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F.W0 DB /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPANDD_YMM_K1Z_YMM_YMMM256B32: int = 2291
"""
``VPANDD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F.W0 DB /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPANDD_ZMM_K1Z_ZMM_ZMMM512B32: int = 2292
"""
``VPANDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.66.0F.W0 DB /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPANDQ_XMM_K1Z_XMM_XMMM128B64: int = 2293
"""
``VPANDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F.W1 DB /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPANDQ_YMM_K1Z_YMM_YMMM256B64: int = 2294
"""
``VPANDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F.W1 DB /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPANDQ_ZMM_K1Z_ZMM_ZMMM512B64: int = 2295
"""
``VPANDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F.W1 DB /r``
``AVX512F``
``16/32/64-bit``
"""
PADDUSB_MM_MMM64: int = 2296
"""
``PADDUSB mm, mm/m64``
``NP 0F DC /r``
``MMX``
``16/32/64-bit``
"""
PADDUSB_XMM_XMMM128: int = 2297
"""
``PADDUSB xmm1, xmm2/m128``
``66 0F DC /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPADDUSB_XMM_XMM_XMMM128: int = 2298
"""
``VPADDUSB xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG DC /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPADDUSB_YMM_YMM_YMMM256: int = 2299
"""
``VPADDUSB ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG DC /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPADDUSB_XMM_K1Z_XMM_XMMM128: int = 2300
"""
``VPADDUSB xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F.WIG DC /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPADDUSB_YMM_K1Z_YMM_YMMM256: int = 2301
"""
``VPADDUSB ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F.WIG DC /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPADDUSB_ZMM_K1Z_ZMM_ZMMM512: int = 2302
"""
``VPADDUSB zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F.WIG DC /r``
``AVX512BW``
``16/32/64-bit``
"""
PADDUSW_MM_MMM64: int = 2303
"""
``PADDUSW mm, mm/m64``
``NP 0F DD /r``
``MMX``
``16/32/64-bit``
"""
PADDUSW_XMM_XMMM128: int = 2304
"""
``PADDUSW xmm1, xmm2/m128``
``66 0F DD /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPADDUSW_XMM_XMM_XMMM128: int = 2305
"""
``VPADDUSW xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG DD /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPADDUSW_YMM_YMM_YMMM256: int = 2306
"""
``VPADDUSW ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG DD /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPADDUSW_XMM_K1Z_XMM_XMMM128: int = 2307
"""
``VPADDUSW xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F.WIG DD /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPADDUSW_YMM_K1Z_YMM_YMMM256: int = 2308
"""
``VPADDUSW ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F.WIG DD /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPADDUSW_ZMM_K1Z_ZMM_ZMMM512: int = 2309
"""
``VPADDUSW zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F.WIG DD /r``
``AVX512BW``
``16/32/64-bit``
"""
PMAXUB_MM_MMM64: int = 2310
"""
``PMAXUB mm1, mm2/m64``
``NP 0F DE /r``
``SSE``
``16/32/64-bit``
"""
PMAXUB_XMM_XMMM128: int = 2311
"""
``PMAXUB xmm1, xmm2/m128``
``66 0F DE /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPMAXUB_XMM_XMM_XMMM128: int = 2312
"""
``VPMAXUB xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG DE /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPMAXUB_YMM_YMM_YMMM256: int = 2313
"""
``VPMAXUB ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG DE /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPMAXUB_XMM_K1Z_XMM_XMMM128: int = 2314
"""
``VPMAXUB xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F.WIG DE /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMAXUB_YMM_K1Z_YMM_YMMM256: int = 2315
"""
``VPMAXUB ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F.WIG DE /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMAXUB_ZMM_K1Z_ZMM_ZMMM512: int = 2316
"""
``VPMAXUB zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F.WIG DE /r``
``AVX512BW``
``16/32/64-bit``
"""
PANDN_MM_MMM64: int = 2317
"""
``PANDN mm, mm/m64``
``NP 0F DF /r``
``MMX``
``16/32/64-bit``
"""
PANDN_XMM_XMMM128: int = 2318
"""
``PANDN xmm1, xmm2/m128``
``66 0F DF /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPANDN_XMM_XMM_XMMM128: int = 2319
"""
``VPANDN xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG DF /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPANDN_YMM_YMM_YMMM256: int = 2320
"""
``VPANDN ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG DF /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPANDND_XMM_K1Z_XMM_XMMM128B32: int = 2321
"""
``VPANDND xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F.W0 DF /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPANDND_YMM_K1Z_YMM_YMMM256B32: int = 2322
"""
``VPANDND ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F.W0 DF /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPANDND_ZMM_K1Z_ZMM_ZMMM512B32: int = 2323
"""
``VPANDND zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.66.0F.W0 DF /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPANDNQ_XMM_K1Z_XMM_XMMM128B64: int = 2324
"""
``VPANDNQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F.W1 DF /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPANDNQ_YMM_K1Z_YMM_YMMM256B64: int = 2325
"""
``VPANDNQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F.W1 DF /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPANDNQ_ZMM_K1Z_ZMM_ZMMM512B64: int = 2326
"""
``VPANDNQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F.W1 DF /r``
``AVX512F``
``16/32/64-bit``
"""
PAVGB_MM_MMM64: int = 2327
"""
``PAVGB mm1, mm2/m64``
``NP 0F E0 /r``
``SSE``
``16/32/64-bit``
"""
PAVGB_XMM_XMMM128: int = 2328
"""
``PAVGB xmm1, xmm2/m128``
``66 0F E0 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPAVGB_XMM_XMM_XMMM128: int = 2329
"""
``VPAVGB xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG E0 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPAVGB_YMM_YMM_YMMM256: int = 2330
"""
``VPAVGB ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG E0 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPAVGB_XMM_K1Z_XMM_XMMM128: int = 2331
"""
``VPAVGB xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F.WIG E0 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPAVGB_YMM_K1Z_YMM_YMMM256: int = 2332
"""
``VPAVGB ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F.WIG E0 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPAVGB_ZMM_K1Z_ZMM_ZMMM512: int = 2333
"""
``VPAVGB zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F.WIG E0 /r``
``AVX512BW``
``16/32/64-bit``
"""
PSRAW_MM_MMM64: int = 2334
"""
``PSRAW mm, mm/m64``
``NP 0F E1 /r``
``MMX``
``16/32/64-bit``
"""
PSRAW_XMM_XMMM128: int = 2335
"""
``PSRAW xmm1, xmm2/m128``
``66 0F E1 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPSRAW_XMM_XMM_XMMM128: int = 2336
"""
``VPSRAW xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG E1 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPSRAW_YMM_YMM_XMMM128: int = 2337
"""
``VPSRAW ymm1, ymm2, xmm3/m128``
``VEX.256.66.0F.WIG E1 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPSRAW_XMM_K1Z_XMM_XMMM128: int = 2338
"""
``VPSRAW xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F.WIG E1 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSRAW_YMM_K1Z_YMM_XMMM128: int = 2339
"""
``VPSRAW ymm1 {k1}{z}, ymm2, xmm3/m128``
``EVEX.256.66.0F.WIG E1 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSRAW_ZMM_K1Z_ZMM_XMMM128: int = 2340
"""
``VPSRAW zmm1 {k1}{z}, zmm2, xmm3/m128``
``EVEX.512.66.0F.WIG E1 /r``
``AVX512BW``
``16/32/64-bit``
"""
PSRAD_MM_MMM64: int = 2341
"""
``PSRAD mm, mm/m64``
``NP 0F E2 /r``
``MMX``
``16/32/64-bit``
"""
PSRAD_XMM_XMMM128: int = 2342
"""
``PSRAD xmm1, xmm2/m128``
``66 0F E2 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPSRAD_XMM_XMM_XMMM128: int = 2343
"""
``VPSRAD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG E2 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPSRAD_YMM_YMM_XMMM128: int = 2344
"""
``VPSRAD ymm1, ymm2, xmm3/m128``
``VEX.256.66.0F.WIG E2 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPSRAD_XMM_K1Z_XMM_XMMM128: int = 2345
"""
``VPSRAD xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F.W0 E2 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSRAD_YMM_K1Z_YMM_XMMM128: int = 2346
"""
``VPSRAD ymm1 {k1}{z}, ymm2, xmm3/m128``
``EVEX.256.66.0F.W0 E2 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSRAD_ZMM_K1Z_ZMM_XMMM128: int = 2347
"""
``VPSRAD zmm1 {k1}{z}, zmm2, xmm3/m128``
``EVEX.512.66.0F.W0 E2 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPSRAQ_XMM_K1Z_XMM_XMMM128: int = 2348
"""
``VPSRAQ xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F.W1 E2 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSRAQ_YMM_K1Z_YMM_XMMM128: int = 2349
"""
``VPSRAQ ymm1 {k1}{z}, ymm2, xmm3/m128``
``EVEX.256.66.0F.W1 E2 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSRAQ_ZMM_K1Z_ZMM_XMMM128: int = 2350
"""
``VPSRAQ zmm1 {k1}{z}, zmm2, xmm3/m128``
``EVEX.512.66.0F.W1 E2 /r``
``AVX512F``
``16/32/64-bit``
"""
PAVGW_MM_MMM64: int = 2351
"""
``PAVGW mm1, mm2/m64``
``NP 0F E3 /r``
``SSE``
``16/32/64-bit``
"""
PAVGW_XMM_XMMM128: int = 2352
"""
``PAVGW xmm1, xmm2/m128``
``66 0F E3 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPAVGW_XMM_XMM_XMMM128: int = 2353
"""
``VPAVGW xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG E3 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPAVGW_YMM_YMM_YMMM256: int = 2354
"""
``VPAVGW ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG E3 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPAVGW_XMM_K1Z_XMM_XMMM128: int = 2355
"""
``VPAVGW xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F.WIG E3 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPAVGW_YMM_K1Z_YMM_YMMM256: int = 2356
"""
``VPAVGW ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F.WIG E3 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPAVGW_ZMM_K1Z_ZMM_ZMMM512: int = 2357
"""
``VPAVGW zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F.WIG E3 /r``
``AVX512BW``
``16/32/64-bit``
"""
PMULHUW_MM_MMM64: int = 2358
"""
``PMULHUW mm1, mm2/m64``
``NP 0F E4 /r``
``SSE``
``16/32/64-bit``
"""
PMULHUW_XMM_XMMM128: int = 2359
"""
``PMULHUW xmm1, xmm2/m128``
``66 0F E4 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPMULHUW_XMM_XMM_XMMM128: int = 2360
"""
``VPMULHUW xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG E4 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPMULHUW_YMM_YMM_YMMM256: int = 2361
"""
``VPMULHUW ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG E4 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPMULHUW_XMM_K1Z_XMM_XMMM128: int = 2362
"""
``VPMULHUW xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F.WIG E4 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMULHUW_YMM_K1Z_YMM_YMMM256: int = 2363
"""
``VPMULHUW ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F.WIG E4 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMULHUW_ZMM_K1Z_ZMM_ZMMM512: int = 2364
"""
``VPMULHUW zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F.WIG E4 /r``
``AVX512BW``
``16/32/64-bit``
"""
PMULHW_MM_MMM64: int = 2365
"""
``PMULHW mm, mm/m64``
``NP 0F E5 /r``
``MMX``
``16/32/64-bit``
"""
PMULHW_XMM_XMMM128: int = 2366
"""
``PMULHW xmm1, xmm2/m128``
``66 0F E5 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPMULHW_XMM_XMM_XMMM128: int = 2367
"""
``VPMULHW xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG E5 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPMULHW_YMM_YMM_YMMM256: int = 2368
"""
``VPMULHW ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG E5 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPMULHW_XMM_K1Z_XMM_XMMM128: int = 2369
"""
``VPMULHW xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F.WIG E5 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMULHW_YMM_K1Z_YMM_YMMM256: int = 2370
"""
``VPMULHW ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F.WIG E5 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMULHW_ZMM_K1Z_ZMM_ZMMM512: int = 2371
"""
``VPMULHW zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F.WIG E5 /r``
``AVX512BW``
``16/32/64-bit``
"""
CVTTPD2DQ_XMM_XMMM128: int = 2372
"""
``CVTTPD2DQ xmm1, xmm2/m128``
``66 0F E6 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VCVTTPD2DQ_XMM_XMMM128: int = 2373
"""
``VCVTTPD2DQ xmm1, xmm2/m128``
``VEX.128.66.0F.WIG E6 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VCVTTPD2DQ_XMM_YMMM256: int = 2374
"""
``VCVTTPD2DQ xmm1, ymm2/m256``
``VEX.256.66.0F.WIG E6 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VCVTTPD2DQ_XMM_K1Z_XMMM128B64: int = 2375
"""
``VCVTTPD2DQ xmm1 {k1}{z}, xmm2/m128/m64bcst``
``EVEX.128.66.0F.W1 E6 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTTPD2DQ_XMM_K1Z_YMMM256B64: int = 2376
"""
``VCVTTPD2DQ xmm1 {k1}{z}, ymm2/m256/m64bcst``
``EVEX.256.66.0F.W1 E6 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTTPD2DQ_YMM_K1Z_ZMMM512B64_SAE: int = 2377
"""
``VCVTTPD2DQ ymm1 {k1}{z}, zmm2/m512/m64bcst{sae}``
``EVEX.512.66.0F.W1 E6 /r``
``AVX512F``
``16/32/64-bit``
"""
CVTDQ2PD_XMM_XMMM64: int = 2378
"""
``CVTDQ2PD xmm1, xmm2/m64``
``F3 0F E6 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VCVTDQ2PD_XMM_XMMM64: int = 2379
"""
``VCVTDQ2PD xmm1, xmm2/m64``
``VEX.128.F3.0F.WIG E6 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VCVTDQ2PD_YMM_XMMM128: int = 2380
"""
``VCVTDQ2PD ymm1, xmm2/m128``
``VEX.256.F3.0F.WIG E6 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VCVTDQ2PD_XMM_K1Z_XMMM64B32: int = 2381
"""
``VCVTDQ2PD xmm1 {k1}{z}, xmm2/m64/m32bcst``
``EVEX.128.F3.0F.W0 E6 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTDQ2PD_YMM_K1Z_XMMM128B32: int = 2382
"""
``VCVTDQ2PD ymm1 {k1}{z}, xmm2/m128/m32bcst``
``EVEX.256.F3.0F.W0 E6 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTDQ2PD_ZMM_K1Z_YMMM256B32_ER: int = 2383
"""
``VCVTDQ2PD zmm1 {k1}{z}, ymm2/m256/m32bcst{er}``
``EVEX.512.F3.0F.W0 E6 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTQQ2PD_XMM_K1Z_XMMM128B64: int = 2384
"""
``VCVTQQ2PD xmm1 {k1}{z}, xmm2/m128/m64bcst``
``EVEX.128.F3.0F.W1 E6 /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VCVTQQ2PD_YMM_K1Z_YMMM256B64: int = 2385
"""
``VCVTQQ2PD ymm1 {k1}{z}, ymm2/m256/m64bcst``
``EVEX.256.F3.0F.W1 E6 /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VCVTQQ2PD_ZMM_K1Z_ZMMM512B64_ER: int = 2386
"""
``VCVTQQ2PD zmm1 {k1}{z}, zmm2/m512/m64bcst{er}``
``EVEX.512.F3.0F.W1 E6 /r``
``AVX512DQ``
``16/32/64-bit``
"""
CVTPD2DQ_XMM_XMMM128: int = 2387
"""
``CVTPD2DQ xmm1, xmm2/m128``
``F2 0F E6 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VCVTPD2DQ_XMM_XMMM128: int = 2388
"""
``VCVTPD2DQ xmm1, xmm2/m128``
``VEX.128.F2.0F.WIG E6 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VCVTPD2DQ_XMM_YMMM256: int = 2389
"""
``VCVTPD2DQ xmm1, ymm2/m256``
``VEX.256.F2.0F.WIG E6 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VCVTPD2DQ_XMM_K1Z_XMMM128B64: int = 2390
"""
``VCVTPD2DQ xmm1 {k1}{z}, xmm2/m128/m64bcst``
``EVEX.128.F2.0F.W1 E6 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTPD2DQ_XMM_K1Z_YMMM256B64: int = 2391
"""
``VCVTPD2DQ xmm1 {k1}{z}, ymm2/m256/m64bcst``
``EVEX.256.F2.0F.W1 E6 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTPD2DQ_YMM_K1Z_ZMMM512B64_ER: int = 2392
"""
``VCVTPD2DQ ymm1 {k1}{z}, zmm2/m512/m64bcst{er}``
``EVEX.512.F2.0F.W1 E6 /r``
``AVX512F``
``16/32/64-bit``
"""
MOVNTQ_M64_MM: int = 2393
"""
``MOVNTQ m64, mm``
``NP 0F E7 /r``
``SSE``
``16/32/64-bit``
"""
MOVNTDQ_M128_XMM: int = 2394
"""
``MOVNTDQ m128, xmm1``
``66 0F E7 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VMOVNTDQ_M128_XMM: int = 2395
"""
``VMOVNTDQ m128, xmm1``
``VEX.128.66.0F.WIG E7 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VMOVNTDQ_M256_YMM: int = 2396
"""
``VMOVNTDQ m256, ymm1``
``VEX.256.66.0F.WIG E7 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VMOVNTDQ_M128_XMM: int = 2397
"""
``VMOVNTDQ m128, xmm1``
``EVEX.128.66.0F.W0 E7 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVNTDQ_M256_YMM: int = 2398
"""
``VMOVNTDQ m256, ymm1``
``EVEX.256.66.0F.W0 E7 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVNTDQ_M512_ZMM: int = 2399
"""
``VMOVNTDQ m512, zmm1``
``EVEX.512.66.0F.W0 E7 /r``
``AVX512F``
``16/32/64-bit``
"""
PSUBSB_MM_MMM64: int = 2400
"""
``PSUBSB mm, mm/m64``
``NP 0F E8 /r``
``MMX``
``16/32/64-bit``
"""
PSUBSB_XMM_XMMM128: int = 2401
"""
``PSUBSB xmm1, xmm2/m128``
``66 0F E8 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPSUBSB_XMM_XMM_XMMM128: int = 2402
"""
``VPSUBSB xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG E8 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPSUBSB_YMM_YMM_YMMM256: int = 2403
"""
``VPSUBSB ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG E8 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPSUBSB_XMM_K1Z_XMM_XMMM128: int = 2404
"""
``VPSUBSB xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F.WIG E8 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSUBSB_YMM_K1Z_YMM_YMMM256: int = 2405
"""
``VPSUBSB ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F.WIG E8 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSUBSB_ZMM_K1Z_ZMM_ZMMM512: int = 2406
"""
``VPSUBSB zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F.WIG E8 /r``
``AVX512BW``
``16/32/64-bit``
"""
PSUBSW_MM_MMM64: int = 2407
"""
``PSUBSW mm, mm/m64``
``NP 0F E9 /r``
``MMX``
``16/32/64-bit``
"""
PSUBSW_XMM_XMMM128: int = 2408
"""
``PSUBSW xmm1, xmm2/m128``
``66 0F E9 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPSUBSW_XMM_XMM_XMMM128: int = 2409
"""
``VPSUBSW xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG E9 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPSUBSW_YMM_YMM_YMMM256: int = 2410
"""
``VPSUBSW ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG E9 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPSUBSW_XMM_K1Z_XMM_XMMM128: int = 2411
"""
``VPSUBSW xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F.WIG E9 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSUBSW_YMM_K1Z_YMM_YMMM256: int = 2412
"""
``VPSUBSW ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F.WIG E9 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSUBSW_ZMM_K1Z_ZMM_ZMMM512: int = 2413
"""
``VPSUBSW zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F.WIG E9 /r``
``AVX512BW``
``16/32/64-bit``
"""
PMINSW_MM_MMM64: int = 2414
"""
``PMINSW mm1, mm2/m64``
``NP 0F EA /r``
``SSE``
``16/32/64-bit``
"""
PMINSW_XMM_XMMM128: int = 2415
"""
``PMINSW xmm1, xmm2/m128``
``66 0F EA /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPMINSW_XMM_XMM_XMMM128: int = 2416
"""
``VPMINSW xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG EA /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPMINSW_YMM_YMM_YMMM256: int = 2417
"""
``VPMINSW ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG EA /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPMINSW_XMM_K1Z_XMM_XMMM128: int = 2418
"""
``VPMINSW xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F.WIG EA /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMINSW_YMM_K1Z_YMM_YMMM256: int = 2419
"""
``VPMINSW ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F.WIG EA /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMINSW_ZMM_K1Z_ZMM_ZMMM512: int = 2420
"""
``VPMINSW zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F.WIG EA /r``
``AVX512BW``
``16/32/64-bit``
"""
POR_MM_MMM64: int = 2421
"""
``POR mm, mm/m64``
``NP 0F EB /r``
``MMX``
``16/32/64-bit``
"""
POR_XMM_XMMM128: int = 2422
"""
``POR xmm1, xmm2/m128``
``66 0F EB /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPOR_XMM_XMM_XMMM128: int = 2423
"""
``VPOR xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG EB /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPOR_YMM_YMM_YMMM256: int = 2424
"""
``VPOR ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG EB /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPORD_XMM_K1Z_XMM_XMMM128B32: int = 2425
"""
``VPORD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F.W0 EB /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPORD_YMM_K1Z_YMM_YMMM256B32: int = 2426
"""
``VPORD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F.W0 EB /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPORD_ZMM_K1Z_ZMM_ZMMM512B32: int = 2427
"""
``VPORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.66.0F.W0 EB /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPORQ_XMM_K1Z_XMM_XMMM128B64: int = 2428
"""
``VPORQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F.W1 EB /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPORQ_YMM_K1Z_YMM_YMMM256B64: int = 2429
"""
``VPORQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F.W1 EB /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPORQ_ZMM_K1Z_ZMM_ZMMM512B64: int = 2430
"""
``VPORQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F.W1 EB /r``
``AVX512F``
``16/32/64-bit``
"""
PADDSB_MM_MMM64: int = 2431
"""
``PADDSB mm, mm/m64``
``NP 0F EC /r``
``MMX``
``16/32/64-bit``
"""
PADDSB_XMM_XMMM128: int = 2432
"""
``PADDSB xmm1, xmm2/m128``
``66 0F EC /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPADDSB_XMM_XMM_XMMM128: int = 2433
"""
``VPADDSB xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG EC /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPADDSB_YMM_YMM_YMMM256: int = 2434
"""
``VPADDSB ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG EC /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPADDSB_XMM_K1Z_XMM_XMMM128: int = 2435
"""
``VPADDSB xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F.WIG EC /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPADDSB_YMM_K1Z_YMM_YMMM256: int = 2436
"""
``VPADDSB ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F.WIG EC /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPADDSB_ZMM_K1Z_ZMM_ZMMM512: int = 2437
"""
``VPADDSB zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F.WIG EC /r``
``AVX512BW``
``16/32/64-bit``
"""
PADDSW_MM_MMM64: int = 2438
"""
``PADDSW mm, mm/m64``
``NP 0F ED /r``
``MMX``
``16/32/64-bit``
"""
PADDSW_XMM_XMMM128: int = 2439
"""
``PADDSW xmm1, xmm2/m128``
``66 0F ED /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPADDSW_XMM_XMM_XMMM128: int = 2440
"""
``VPADDSW xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG ED /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPADDSW_YMM_YMM_YMMM256: int = 2441
"""
``VPADDSW ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG ED /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPADDSW_XMM_K1Z_XMM_XMMM128: int = 2442
"""
``VPADDSW xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F.WIG ED /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPADDSW_YMM_K1Z_YMM_YMMM256: int = 2443
"""
``VPADDSW ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F.WIG ED /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPADDSW_ZMM_K1Z_ZMM_ZMMM512: int = 2444
"""
``VPADDSW zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F.WIG ED /r``
``AVX512BW``
``16/32/64-bit``
"""
PMAXSW_MM_MMM64: int = 2445
"""
``PMAXSW mm1, mm2/m64``
``NP 0F EE /r``
``SSE``
``16/32/64-bit``
"""
PMAXSW_XMM_XMMM128: int = 2446
"""
``PMAXSW xmm1, xmm2/m128``
``66 0F EE /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPMAXSW_XMM_XMM_XMMM128: int = 2447
"""
``VPMAXSW xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG EE /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPMAXSW_YMM_YMM_YMMM256: int = 2448
"""
``VPMAXSW ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG EE /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPMAXSW_XMM_K1Z_XMM_XMMM128: int = 2449
"""
``VPMAXSW xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F.WIG EE /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMAXSW_YMM_K1Z_YMM_YMMM256: int = 2450
"""
``VPMAXSW ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F.WIG EE /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMAXSW_ZMM_K1Z_ZMM_ZMMM512: int = 2451
"""
``VPMAXSW zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F.WIG EE /r``
``AVX512BW``
``16/32/64-bit``
"""
PXOR_MM_MMM64: int = 2452
"""
``PXOR mm, mm/m64``
``NP 0F EF /r``
``MMX``
``16/32/64-bit``
"""
PXOR_XMM_XMMM128: int = 2453
"""
``PXOR xmm1, xmm2/m128``
``66 0F EF /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPXOR_XMM_XMM_XMMM128: int = 2454
"""
``VPXOR xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG EF /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPXOR_YMM_YMM_YMMM256: int = 2455
"""
``VPXOR ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG EF /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPXORD_XMM_K1Z_XMM_XMMM128B32: int = 2456
"""
``VPXORD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F.W0 EF /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPXORD_YMM_K1Z_YMM_YMMM256B32: int = 2457
"""
``VPXORD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F.W0 EF /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPXORD_ZMM_K1Z_ZMM_ZMMM512B32: int = 2458
"""
``VPXORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.66.0F.W0 EF /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPXORQ_XMM_K1Z_XMM_XMMM128B64: int = 2459
"""
``VPXORQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F.W1 EF /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPXORQ_YMM_K1Z_YMM_YMMM256B64: int = 2460
"""
``VPXORQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F.W1 EF /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPXORQ_ZMM_K1Z_ZMM_ZMMM512B64: int = 2461
"""
``VPXORQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F.W1 EF /r``
``AVX512F``
``16/32/64-bit``
"""
LDDQU_XMM_M128: int = 2462
"""
``LDDQU xmm1, m128``
``F2 0F F0 /r``
``SSE3``
``16/32/64-bit``
"""
VEX_VLDDQU_XMM_M128: int = 2463
"""
``VLDDQU xmm1, m128``
``VEX.128.F2.0F.WIG F0 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VLDDQU_YMM_M256: int = 2464
"""
``VLDDQU ymm1, m256``
``VEX.256.F2.0F.WIG F0 /r``
``AVX``
``16/32/64-bit``
"""
PSLLW_MM_MMM64: int = 2465
"""
``PSLLW mm, mm/m64``
``NP 0F F1 /r``
``MMX``
``16/32/64-bit``
"""
PSLLW_XMM_XMMM128: int = 2466
"""
``PSLLW xmm1, xmm2/m128``
``66 0F F1 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPSLLW_XMM_XMM_XMMM128: int = 2467
"""
``VPSLLW xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG F1 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPSLLW_YMM_YMM_XMMM128: int = 2468
"""
``VPSLLW ymm1, ymm2, xmm3/m128``
``VEX.256.66.0F.WIG F1 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPSLLW_XMM_K1Z_XMM_XMMM128: int = 2469
"""
``VPSLLW xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F.WIG F1 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSLLW_YMM_K1Z_YMM_XMMM128: int = 2470
"""
``VPSLLW ymm1 {k1}{z}, ymm2, xmm3/m128``
``EVEX.256.66.0F.WIG F1 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSLLW_ZMM_K1Z_ZMM_XMMM128: int = 2471
"""
``VPSLLW zmm1 {k1}{z}, zmm2, xmm3/m128``
``EVEX.512.66.0F.WIG F1 /r``
``AVX512BW``
``16/32/64-bit``
"""
PSLLD_MM_MMM64: int = 2472
"""
``PSLLD mm, mm/m64``
``NP 0F F2 /r``
``MMX``
``16/32/64-bit``
"""
PSLLD_XMM_XMMM128: int = 2473
"""
``PSLLD xmm1, xmm2/m128``
``66 0F F2 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPSLLD_XMM_XMM_XMMM128: int = 2474
"""
``VPSLLD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG F2 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPSLLD_YMM_YMM_XMMM128: int = 2475
"""
``VPSLLD ymm1, ymm2, xmm3/m128``
``VEX.256.66.0F.WIG F2 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPSLLD_XMM_K1Z_XMM_XMMM128: int = 2476
"""
``VPSLLD xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F.W0 F2 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSLLD_YMM_K1Z_YMM_XMMM128: int = 2477
"""
``VPSLLD ymm1 {k1}{z}, ymm2, xmm3/m128``
``EVEX.256.66.0F.W0 F2 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSLLD_ZMM_K1Z_ZMM_XMMM128: int = 2478
"""
``VPSLLD zmm1 {k1}{z}, zmm2, xmm3/m128``
``EVEX.512.66.0F.W0 F2 /r``
``AVX512F``
``16/32/64-bit``
"""
PSLLQ_MM_MMM64: int = 2479
"""
``PSLLQ mm, mm/m64``
``NP 0F F3 /r``
``MMX``
``16/32/64-bit``
"""
PSLLQ_XMM_XMMM128: int = 2480
"""
``PSLLQ xmm1, xmm2/m128``
``66 0F F3 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPSLLQ_XMM_XMM_XMMM128: int = 2481
"""
``VPSLLQ xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG F3 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPSLLQ_YMM_YMM_XMMM128: int = 2482
"""
``VPSLLQ ymm1, ymm2, xmm3/m128``
``VEX.256.66.0F.WIG F3 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPSLLQ_XMM_K1Z_XMM_XMMM128: int = 2483
"""
``VPSLLQ xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F.W1 F3 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSLLQ_YMM_K1Z_YMM_XMMM128: int = 2484
"""
``VPSLLQ ymm1 {k1}{z}, ymm2, xmm3/m128``
``EVEX.256.66.0F.W1 F3 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSLLQ_ZMM_K1Z_ZMM_XMMM128: int = 2485
"""
``VPSLLQ zmm1 {k1}{z}, zmm2, xmm3/m128``
``EVEX.512.66.0F.W1 F3 /r``
``AVX512F``
``16/32/64-bit``
"""
PMULUDQ_MM_MMM64: int = 2486
"""
``PMULUDQ mm1, mm2/m64``
``NP 0F F4 /r``
``SSE2``
``16/32/64-bit``
"""
PMULUDQ_XMM_XMMM128: int = 2487
"""
``PMULUDQ xmm1, xmm2/m128``
``66 0F F4 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPMULUDQ_XMM_XMM_XMMM128: int = 2488
"""
``VPMULUDQ xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG F4 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPMULUDQ_YMM_YMM_YMMM256: int = 2489
"""
``VPMULUDQ ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG F4 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPMULUDQ_XMM_K1Z_XMM_XMMM128B64: int = 2490
"""
``VPMULUDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F.W1 F4 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMULUDQ_YMM_K1Z_YMM_YMMM256B64: int = 2491
"""
``VPMULUDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F.W1 F4 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMULUDQ_ZMM_K1Z_ZMM_ZMMM512B64: int = 2492
"""
``VPMULUDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F.W1 F4 /r``
``AVX512F``
``16/32/64-bit``
"""
PMADDWD_MM_MMM64: int = 2493
"""
``PMADDWD mm, mm/m64``
``NP 0F F5 /r``
``MMX``
``16/32/64-bit``
"""
PMADDWD_XMM_XMMM128: int = 2494
"""
``PMADDWD xmm1, xmm2/m128``
``66 0F F5 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPMADDWD_XMM_XMM_XMMM128: int = 2495
"""
``VPMADDWD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG F5 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPMADDWD_YMM_YMM_YMMM256: int = 2496
"""
``VPMADDWD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG F5 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPMADDWD_XMM_K1Z_XMM_XMMM128: int = 2497
"""
``VPMADDWD xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F.WIG F5 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMADDWD_YMM_K1Z_YMM_YMMM256: int = 2498
"""
``VPMADDWD ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F.WIG F5 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMADDWD_ZMM_K1Z_ZMM_ZMMM512: int = 2499
"""
``VPMADDWD zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F.WIG F5 /r``
``AVX512BW``
``16/32/64-bit``
"""
PSADBW_MM_MMM64: int = 2500
"""
``PSADBW mm1, mm2/m64``
``NP 0F F6 /r``
``SSE``
``16/32/64-bit``
"""
PSADBW_XMM_XMMM128: int = 2501
"""
``PSADBW xmm1, xmm2/m128``
``66 0F F6 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPSADBW_XMM_XMM_XMMM128: int = 2502
"""
``VPSADBW xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG F6 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPSADBW_YMM_YMM_YMMM256: int = 2503
"""
``VPSADBW ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG F6 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPSADBW_XMM_XMM_XMMM128: int = 2504
"""
``VPSADBW xmm1, xmm2, xmm3/m128``
``EVEX.128.66.0F.WIG F6 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSADBW_YMM_YMM_YMMM256: int = 2505
"""
``VPSADBW ymm1, ymm2, ymm3/m256``
``EVEX.256.66.0F.WIG F6 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSADBW_ZMM_ZMM_ZMMM512: int = 2506
"""
``VPSADBW zmm1, zmm2, zmm3/m512``
``EVEX.512.66.0F.WIG F6 /r``
``AVX512BW``
``16/32/64-bit``
"""
MASKMOVQ_RDI_MM_MM: int = 2507
"""
``MASKMOVQ mm1, mm2``
``NP 0F F7 /r``
``SSE``
``16/32/64-bit``
"""
MASKMOVDQU_RDI_XMM_XMM: int = 2508
"""
``MASKMOVDQU xmm1, xmm2``
``66 0F F7 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VMASKMOVDQU_RDI_XMM_XMM: int = 2509
"""
``VMASKMOVDQU xmm1, xmm2``
``VEX.128.66.0F.WIG F7 /r``
``AVX``
``16/32/64-bit``
"""
PSUBB_MM_MMM64: int = 2510
"""
``PSUBB mm, mm/m64``
``NP 0F F8 /r``
``MMX``
``16/32/64-bit``
"""
PSUBB_XMM_XMMM128: int = 2511
"""
``PSUBB xmm1, xmm2/m128``
``66 0F F8 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPSUBB_XMM_XMM_XMMM128: int = 2512
"""
``VPSUBB xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG F8 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPSUBB_YMM_YMM_YMMM256: int = 2513
"""
``VPSUBB ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG F8 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPSUBB_XMM_K1Z_XMM_XMMM128: int = 2514
"""
``VPSUBB xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F.WIG F8 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSUBB_YMM_K1Z_YMM_YMMM256: int = 2515
"""
``VPSUBB ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F.WIG F8 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSUBB_ZMM_K1Z_ZMM_ZMMM512: int = 2516
"""
``VPSUBB zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F.WIG F8 /r``
``AVX512BW``
``16/32/64-bit``
"""
PSUBW_MM_MMM64: int = 2517
"""
``PSUBW mm, mm/m64``
``NP 0F F9 /r``
``MMX``
``16/32/64-bit``
"""
PSUBW_XMM_XMMM128: int = 2518
"""
``PSUBW xmm1, xmm2/m128``
``66 0F F9 /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPSUBW_XMM_XMM_XMMM128: int = 2519
"""
``VPSUBW xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG F9 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPSUBW_YMM_YMM_YMMM256: int = 2520
"""
``VPSUBW ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG F9 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPSUBW_XMM_K1Z_XMM_XMMM128: int = 2521
"""
``VPSUBW xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F.WIG F9 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSUBW_YMM_K1Z_YMM_YMMM256: int = 2522
"""
``VPSUBW ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F.WIG F9 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSUBW_ZMM_K1Z_ZMM_ZMMM512: int = 2523
"""
``VPSUBW zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F.WIG F9 /r``
``AVX512BW``
``16/32/64-bit``
"""
PSUBD_MM_MMM64: int = 2524
"""
``PSUBD mm, mm/m64``
``NP 0F FA /r``
``MMX``
``16/32/64-bit``
"""
PSUBD_XMM_XMMM128: int = 2525
"""
``PSUBD xmm1, xmm2/m128``
``66 0F FA /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPSUBD_XMM_XMM_XMMM128: int = 2526
"""
``VPSUBD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG FA /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPSUBD_YMM_YMM_YMMM256: int = 2527
"""
``VPSUBD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG FA /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPSUBD_XMM_K1Z_XMM_XMMM128B32: int = 2528
"""
``VPSUBD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F.W0 FA /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSUBD_YMM_K1Z_YMM_YMMM256B32: int = 2529
"""
``VPSUBD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F.W0 FA /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSUBD_ZMM_K1Z_ZMM_ZMMM512B32: int = 2530
"""
``VPSUBD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.66.0F.W0 FA /r``
``AVX512F``
``16/32/64-bit``
"""
PSUBQ_MM_MMM64: int = 2531
"""
``PSUBQ mm1, mm2/m64``
``NP 0F FB /r``
``SSE2``
``16/32/64-bit``
"""
PSUBQ_XMM_XMMM128: int = 2532
"""
``PSUBQ xmm1, xmm2/m128``
``66 0F FB /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPSUBQ_XMM_XMM_XMMM128: int = 2533
"""
``VPSUBQ xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG FB /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPSUBQ_YMM_YMM_YMMM256: int = 2534
"""
``VPSUBQ ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG FB /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPSUBQ_XMM_K1Z_XMM_XMMM128B64: int = 2535
"""
``VPSUBQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F.W1 FB /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSUBQ_YMM_K1Z_YMM_YMMM256B64: int = 2536
"""
``VPSUBQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F.W1 FB /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSUBQ_ZMM_K1Z_ZMM_ZMMM512B64: int = 2537
"""
``VPSUBQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F.W1 FB /r``
``AVX512F``
``16/32/64-bit``
"""
PADDB_MM_MMM64: int = 2538
"""
``PADDB mm, mm/m64``
``NP 0F FC /r``
``MMX``
``16/32/64-bit``
"""
PADDB_XMM_XMMM128: int = 2539
"""
``PADDB xmm1, xmm2/m128``
``66 0F FC /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPADDB_XMM_XMM_XMMM128: int = 2540
"""
``VPADDB xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG FC /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPADDB_YMM_YMM_YMMM256: int = 2541
"""
``VPADDB ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG FC /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPADDB_XMM_K1Z_XMM_XMMM128: int = 2542
"""
``VPADDB xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F.WIG FC /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPADDB_YMM_K1Z_YMM_YMMM256: int = 2543
"""
``VPADDB ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F.WIG FC /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPADDB_ZMM_K1Z_ZMM_ZMMM512: int = 2544
"""
``VPADDB zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F.WIG FC /r``
``AVX512BW``
``16/32/64-bit``
"""
PADDW_MM_MMM64: int = 2545
"""
``PADDW mm, mm/m64``
``NP 0F FD /r``
``MMX``
``16/32/64-bit``
"""
PADDW_XMM_XMMM128: int = 2546
"""
``PADDW xmm1, xmm2/m128``
``66 0F FD /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPADDW_XMM_XMM_XMMM128: int = 2547
"""
``VPADDW xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG FD /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPADDW_YMM_YMM_YMMM256: int = 2548
"""
``VPADDW ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG FD /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPADDW_XMM_K1Z_XMM_XMMM128: int = 2549
"""
``VPADDW xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F.WIG FD /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPADDW_YMM_K1Z_YMM_YMMM256: int = 2550
"""
``VPADDW ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F.WIG FD /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPADDW_ZMM_K1Z_ZMM_ZMMM512: int = 2551
"""
``VPADDW zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F.WIG FD /r``
``AVX512BW``
``16/32/64-bit``
"""
PADDD_MM_MMM64: int = 2552
"""
``PADDD mm, mm/m64``
``NP 0F FE /r``
``MMX``
``16/32/64-bit``
"""
PADDD_XMM_XMMM128: int = 2553
"""
``PADDD xmm1, xmm2/m128``
``66 0F FE /r``
``SSE2``
``16/32/64-bit``
"""
VEX_VPADDD_XMM_XMM_XMMM128: int = 2554
"""
``VPADDD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F.WIG FE /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPADDD_YMM_YMM_YMMM256: int = 2555
"""
``VPADDD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F.WIG FE /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPADDD_XMM_K1Z_XMM_XMMM128B32: int = 2556
"""
``VPADDD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F.W0 FE /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPADDD_YMM_K1Z_YMM_YMMM256B32: int = 2557
"""
``VPADDD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F.W0 FE /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPADDD_ZMM_K1Z_ZMM_ZMMM512B32: int = 2558
"""
``VPADDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.66.0F.W0 FE /r``
``AVX512F``
``16/32/64-bit``
"""
UD0_R16_RM16: int = 2559
"""
``UD0 r16, r/m16``
``o16 0F FF /r``
``286+``
``16/32/64-bit``
"""
UD0_R32_RM32: int = 2560
"""
``UD0 r32, r/m32``
``o32 0F FF /r``
``386+``
``16/32/64-bit``
"""
UD0_R64_RM64: int = 2561
"""
``UD0 r64, r/m64``
``o64 0F FF /r``
``X64``
``64-bit``
"""
PSHUFB_MM_MMM64: int = 2562
"""
``PSHUFB mm1, mm2/m64``
``NP 0F 38 00 /r``
``SSSE3``
``16/32/64-bit``
"""
PSHUFB_XMM_XMMM128: int = 2563
"""
``PSHUFB xmm1, xmm2/m128``
``66 0F 38 00 /r``
``SSSE3``
``16/32/64-bit``
"""
VEX_VPSHUFB_XMM_XMM_XMMM128: int = 2564
"""
``VPSHUFB xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.WIG 00 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPSHUFB_YMM_YMM_YMMM256: int = 2565
"""
``VPSHUFB ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.WIG 00 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPSHUFB_XMM_K1Z_XMM_XMMM128: int = 2566
"""
``VPSHUFB xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F38.WIG 00 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSHUFB_YMM_K1Z_YMM_YMMM256: int = 2567
"""
``VPSHUFB ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F38.WIG 00 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSHUFB_ZMM_K1Z_ZMM_ZMMM512: int = 2568
"""
``VPSHUFB zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F38.WIG 00 /r``
``AVX512BW``
``16/32/64-bit``
"""
PHADDW_MM_MMM64: int = 2569
"""
``PHADDW mm1, mm2/m64``
``NP 0F 38 01 /r``
``SSSE3``
``16/32/64-bit``
"""
PHADDW_XMM_XMMM128: int = 2570
"""
``PHADDW xmm1, xmm2/m128``
``66 0F 38 01 /r``
``SSSE3``
``16/32/64-bit``
"""
VEX_VPHADDW_XMM_XMM_XMMM128: int = 2571
"""
``VPHADDW xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.WIG 01 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPHADDW_YMM_YMM_YMMM256: int = 2572
"""
``VPHADDW ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.WIG 01 /r``
``AVX2``
``16/32/64-bit``
"""
PHADDD_MM_MMM64: int = 2573
"""
``PHADDD mm1, mm2/m64``
``NP 0F 38 02 /r``
``SSSE3``
``16/32/64-bit``
"""
PHADDD_XMM_XMMM128: int = 2574
"""
``PHADDD xmm1, xmm2/m128``
``66 0F 38 02 /r``
``SSSE3``
``16/32/64-bit``
"""
VEX_VPHADDD_XMM_XMM_XMMM128: int = 2575
"""
``VPHADDD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.WIG 02 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPHADDD_YMM_YMM_YMMM256: int = 2576
"""
``VPHADDD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.WIG 02 /r``
``AVX2``
``16/32/64-bit``
"""
PHADDSW_MM_MMM64: int = 2577
"""
``PHADDSW mm1, mm2/m64``
``NP 0F 38 03 /r``
``SSSE3``
``16/32/64-bit``
"""
PHADDSW_XMM_XMMM128: int = 2578
"""
``PHADDSW xmm1, xmm2/m128``
``66 0F 38 03 /r``
``SSSE3``
``16/32/64-bit``
"""
VEX_VPHADDSW_XMM_XMM_XMMM128: int = 2579
"""
``VPHADDSW xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.WIG 03 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPHADDSW_YMM_YMM_YMMM256: int = 2580
"""
``VPHADDSW ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.WIG 03 /r``
``AVX2``
``16/32/64-bit``
"""
PMADDUBSW_MM_MMM64: int = 2581
"""
``PMADDUBSW mm1, mm2/m64``
``NP 0F 38 04 /r``
``SSSE3``
``16/32/64-bit``
"""
PMADDUBSW_XMM_XMMM128: int = 2582
"""
``PMADDUBSW xmm1, xmm2/m128``
``66 0F 38 04 /r``
``SSSE3``
``16/32/64-bit``
"""
VEX_VPMADDUBSW_XMM_XMM_XMMM128: int = 2583
"""
``VPMADDUBSW xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.WIG 04 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPMADDUBSW_YMM_YMM_YMMM256: int = 2584
"""
``VPMADDUBSW ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.WIG 04 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPMADDUBSW_XMM_K1Z_XMM_XMMM128: int = 2585
"""
``VPMADDUBSW xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F38.WIG 04 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMADDUBSW_YMM_K1Z_YMM_YMMM256: int = 2586
"""
``VPMADDUBSW ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F38.WIG 04 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMADDUBSW_ZMM_K1Z_ZMM_ZMMM512: int = 2587
"""
``VPMADDUBSW zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F38.WIG 04 /r``
``AVX512BW``
``16/32/64-bit``
"""
PHSUBW_MM_MMM64: int = 2588
"""
``PHSUBW mm1, mm2/m64``
``NP 0F 38 05 /r``
``SSSE3``
``16/32/64-bit``
"""
PHSUBW_XMM_XMMM128: int = 2589
"""
``PHSUBW xmm1, xmm2/m128``
``66 0F 38 05 /r``
``SSSE3``
``16/32/64-bit``
"""
VEX_VPHSUBW_XMM_XMM_XMMM128: int = 2590
"""
``VPHSUBW xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.WIG 05 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPHSUBW_YMM_YMM_YMMM256: int = 2591
"""
``VPHSUBW ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.WIG 05 /r``
``AVX2``
``16/32/64-bit``
"""
PHSUBD_MM_MMM64: int = 2592
"""
``PHSUBD mm1, mm2/m64``
``NP 0F 38 06 /r``
``SSSE3``
``16/32/64-bit``
"""
PHSUBD_XMM_XMMM128: int = 2593
"""
``PHSUBD xmm1, xmm2/m128``
``66 0F 38 06 /r``
``SSSE3``
``16/32/64-bit``
"""
VEX_VPHSUBD_XMM_XMM_XMMM128: int = 2594
"""
``VPHSUBD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.WIG 06 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPHSUBD_YMM_YMM_YMMM256: int = 2595
"""
``VPHSUBD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.WIG 06 /r``
``AVX2``
``16/32/64-bit``
"""
PHSUBSW_MM_MMM64: int = 2596
"""
``PHSUBSW mm1, mm2/m64``
``NP 0F 38 07 /r``
``SSSE3``
``16/32/64-bit``
"""
PHSUBSW_XMM_XMMM128: int = 2597
"""
``PHSUBSW xmm1, xmm2/m128``
``66 0F 38 07 /r``
``SSSE3``
``16/32/64-bit``
"""
VEX_VPHSUBSW_XMM_XMM_XMMM128: int = 2598
"""
``VPHSUBSW xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.WIG 07 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPHSUBSW_YMM_YMM_YMMM256: int = 2599
"""
``VPHSUBSW ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.WIG 07 /r``
``AVX2``
``16/32/64-bit``
"""
PSIGNB_MM_MMM64: int = 2600
"""
``PSIGNB mm1, mm2/m64``
``NP 0F 38 08 /r``
``SSSE3``
``16/32/64-bit``
"""
PSIGNB_XMM_XMMM128: int = 2601
"""
``PSIGNB xmm1, xmm2/m128``
``66 0F 38 08 /r``
``SSSE3``
``16/32/64-bit``
"""
VEX_VPSIGNB_XMM_XMM_XMMM128: int = 2602
"""
``VPSIGNB xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.WIG 08 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPSIGNB_YMM_YMM_YMMM256: int = 2603
"""
``VPSIGNB ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.WIG 08 /r``
``AVX2``
``16/32/64-bit``
"""
PSIGNW_MM_MMM64: int = 2604
"""
``PSIGNW mm1, mm2/m64``
``NP 0F 38 09 /r``
``SSSE3``
``16/32/64-bit``
"""
PSIGNW_XMM_XMMM128: int = 2605
"""
``PSIGNW xmm1, xmm2/m128``
``66 0F 38 09 /r``
``SSSE3``
``16/32/64-bit``
"""
VEX_VPSIGNW_XMM_XMM_XMMM128: int = 2606
"""
``VPSIGNW xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.WIG 09 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPSIGNW_YMM_YMM_YMMM256: int = 2607
"""
``VPSIGNW ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.WIG 09 /r``
``AVX2``
``16/32/64-bit``
"""
PSIGND_MM_MMM64: int = 2608
"""
``PSIGND mm1, mm2/m64``
``NP 0F 38 0A /r``
``SSSE3``
``16/32/64-bit``
"""
PSIGND_XMM_XMMM128: int = 2609
"""
``PSIGND xmm1, xmm2/m128``
``66 0F 38 0A /r``
``SSSE3``
``16/32/64-bit``
"""
VEX_VPSIGND_XMM_XMM_XMMM128: int = 2610
"""
``VPSIGND xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.WIG 0A /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPSIGND_YMM_YMM_YMMM256: int = 2611
"""
``VPSIGND ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.WIG 0A /r``
``AVX2``
``16/32/64-bit``
"""
PMULHRSW_MM_MMM64: int = 2612
"""
``PMULHRSW mm1, mm2/m64``
``NP 0F 38 0B /r``
``SSSE3``
``16/32/64-bit``
"""
PMULHRSW_XMM_XMMM128: int = 2613
"""
``PMULHRSW xmm1, xmm2/m128``
``66 0F 38 0B /r``
``SSSE3``
``16/32/64-bit``
"""
VEX_VPMULHRSW_XMM_XMM_XMMM128: int = 2614
"""
``VPMULHRSW xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.WIG 0B /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPMULHRSW_YMM_YMM_YMMM256: int = 2615
"""
``VPMULHRSW ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.WIG 0B /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPMULHRSW_XMM_K1Z_XMM_XMMM128: int = 2616
"""
``VPMULHRSW xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F38.WIG 0B /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMULHRSW_YMM_K1Z_YMM_YMMM256: int = 2617
"""
``VPMULHRSW ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F38.WIG 0B /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMULHRSW_ZMM_K1Z_ZMM_ZMMM512: int = 2618
"""
``VPMULHRSW zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F38.WIG 0B /r``
``AVX512BW``
``16/32/64-bit``
"""
VEX_VPERMILPS_XMM_XMM_XMMM128: int = 2619
"""
``VPERMILPS xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W0 0C /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPERMILPS_YMM_YMM_YMMM256: int = 2620
"""
``VPERMILPS ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W0 0C /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VPERMILPS_XMM_K1Z_XMM_XMMM128B32: int = 2621
"""
``VPERMILPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 0C /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPERMILPS_YMM_K1Z_YMM_YMMM256B32: int = 2622
"""
``VPERMILPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 0C /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPERMILPS_ZMM_K1Z_ZMM_ZMMM512B32: int = 2623
"""
``VPERMILPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.66.0F38.W0 0C /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_VPERMILPD_XMM_XMM_XMMM128: int = 2624
"""
``VPERMILPD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W0 0D /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPERMILPD_YMM_YMM_YMMM256: int = 2625
"""
``VPERMILPD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W0 0D /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VPERMILPD_XMM_K1Z_XMM_XMMM128B64: int = 2626
"""
``VPERMILPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 0D /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPERMILPD_YMM_K1Z_YMM_YMMM256B64: int = 2627
"""
``VPERMILPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 0D /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPERMILPD_ZMM_K1Z_ZMM_ZMMM512B64: int = 2628
"""
``VPERMILPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F38.W1 0D /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_VTESTPS_XMM_XMMM128: int = 2629
"""
``VTESTPS xmm1, xmm2/m128``
``VEX.128.66.0F38.W0 0E /r``
``AVX``
``16/32/64-bit``
"""
VEX_VTESTPS_YMM_YMMM256: int = 2630
"""
``VTESTPS ymm1, ymm2/m256``
``VEX.256.66.0F38.W0 0E /r``
``AVX``
``16/32/64-bit``
"""
VEX_VTESTPD_XMM_XMMM128: int = 2631
"""
``VTESTPD xmm1, xmm2/m128``
``VEX.128.66.0F38.W0 0F /r``
``AVX``
``16/32/64-bit``
"""
VEX_VTESTPD_YMM_YMMM256: int = 2632
"""
``VTESTPD ymm1, ymm2/m256``
``VEX.256.66.0F38.W0 0F /r``
``AVX``
``16/32/64-bit``
"""
PBLENDVB_XMM_XMMM128: int = 2633
"""
``PBLENDVB xmm1, xmm2/m128, <XMM0>``
``66 0F 38 10 /r``
``SSE4.1``
``16/32/64-bit``
"""
EVEX_VPSRLVW_XMM_K1Z_XMM_XMMM128: int = 2634
"""
``VPSRLVW xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F38.W1 10 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSRLVW_YMM_K1Z_YMM_YMMM256: int = 2635
"""
``VPSRLVW ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F38.W1 10 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSRLVW_ZMM_K1Z_ZMM_ZMMM512: int = 2636
"""
``VPSRLVW zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F38.W1 10 /r``
``AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMOVUSWB_XMMM64_K1Z_XMM: int = 2637
"""
``VPMOVUSWB xmm1/m64 {k1}{z}, xmm2``
``EVEX.128.F3.0F38.W0 10 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMOVUSWB_XMMM128_K1Z_YMM: int = 2638
"""
``VPMOVUSWB xmm1/m128 {k1}{z}, ymm2``
``EVEX.256.F3.0F38.W0 10 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMOVUSWB_YMMM256_K1Z_ZMM: int = 2639
"""
``VPMOVUSWB ymm1/m256 {k1}{z}, zmm2``
``EVEX.512.F3.0F38.W0 10 /r``
``AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSRAVW_XMM_K1Z_XMM_XMMM128: int = 2640
"""
``VPSRAVW xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F38.W1 11 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSRAVW_YMM_K1Z_YMM_YMMM256: int = 2641
"""
``VPSRAVW ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F38.W1 11 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSRAVW_ZMM_K1Z_ZMM_ZMMM512: int = 2642
"""
``VPSRAVW zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F38.W1 11 /r``
``AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMOVUSDB_XMMM32_K1Z_XMM: int = 2643
"""
``VPMOVUSDB xmm1/m32 {k1}{z}, xmm2``
``EVEX.128.F3.0F38.W0 11 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVUSDB_XMMM64_K1Z_YMM: int = 2644
"""
``VPMOVUSDB xmm1/m64 {k1}{z}, ymm2``
``EVEX.256.F3.0F38.W0 11 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVUSDB_XMMM128_K1Z_ZMM: int = 2645
"""
``VPMOVUSDB xmm1/m128 {k1}{z}, zmm2``
``EVEX.512.F3.0F38.W0 11 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPSLLVW_XMM_K1Z_XMM_XMMM128: int = 2646
"""
``VPSLLVW xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F38.W1 12 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSLLVW_YMM_K1Z_YMM_YMMM256: int = 2647
"""
``VPSLLVW ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F38.W1 12 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPSLLVW_ZMM_K1Z_ZMM_ZMMM512: int = 2648
"""
``VPSLLVW zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F38.W1 12 /r``
``AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMOVUSQB_XMMM16_K1Z_XMM: int = 2649
"""
``VPMOVUSQB xmm1/m16 {k1}{z}, xmm2``
``EVEX.128.F3.0F38.W0 12 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVUSQB_XMMM32_K1Z_YMM: int = 2650
"""
``VPMOVUSQB xmm1/m32 {k1}{z}, ymm2``
``EVEX.256.F3.0F38.W0 12 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVUSQB_XMMM64_K1Z_ZMM: int = 2651
"""
``VPMOVUSQB xmm1/m64 {k1}{z}, zmm2``
``EVEX.512.F3.0F38.W0 12 /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_VCVTPH2PS_XMM_XMMM64: int = 2652
"""
``VCVTPH2PS xmm1, xmm2/m64``
``VEX.128.66.0F38.W0 13 /r``
``F16C``
``16/32/64-bit``
"""
VEX_VCVTPH2PS_YMM_XMMM128: int = 2653
"""
``VCVTPH2PS ymm1, xmm2/m128``
``VEX.256.66.0F38.W0 13 /r``
``F16C``
``16/32/64-bit``
"""
EVEX_VCVTPH2PS_XMM_K1Z_XMMM64: int = 2654
"""
``VCVTPH2PS xmm1 {k1}{z}, xmm2/m64``
``EVEX.128.66.0F38.W0 13 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTPH2PS_YMM_K1Z_XMMM128: int = 2655
"""
``VCVTPH2PS ymm1 {k1}{z}, xmm2/m128``
``EVEX.256.66.0F38.W0 13 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTPH2PS_ZMM_K1Z_YMMM256_SAE: int = 2656
"""
``VCVTPH2PS zmm1 {k1}{z}, ymm2/m256{sae}``
``EVEX.512.66.0F38.W0 13 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVUSDW_XMMM64_K1Z_XMM: int = 2657
"""
``VPMOVUSDW xmm1/m64 {k1}{z}, xmm2``
``EVEX.128.F3.0F38.W0 13 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVUSDW_XMMM128_K1Z_YMM: int = 2658
"""
``VPMOVUSDW xmm1/m128 {k1}{z}, ymm2``
``EVEX.256.F3.0F38.W0 13 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVUSDW_YMMM256_K1Z_ZMM: int = 2659
"""
``VPMOVUSDW ymm1/m256 {k1}{z}, zmm2``
``EVEX.512.F3.0F38.W0 13 /r``
``AVX512F``
``16/32/64-bit``
"""
BLENDVPS_XMM_XMMM128: int = 2660
"""
``BLENDVPS xmm1, xmm2/m128, <XMM0>``
``66 0F 38 14 /r``
``SSE4.1``
``16/32/64-bit``
"""
EVEX_VPRORVD_XMM_K1Z_XMM_XMMM128B32: int = 2661
"""
``VPRORVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 14 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPRORVD_YMM_K1Z_YMM_YMMM256B32: int = 2662
"""
``VPRORVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 14 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPRORVD_ZMM_K1Z_ZMM_ZMMM512B32: int = 2663
"""
``VPRORVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.66.0F38.W0 14 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPRORVQ_XMM_K1Z_XMM_XMMM128B64: int = 2664
"""
``VPRORVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 14 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPRORVQ_YMM_K1Z_YMM_YMMM256B64: int = 2665
"""
``VPRORVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 14 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPRORVQ_ZMM_K1Z_ZMM_ZMMM512B64: int = 2666
"""
``VPRORVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F38.W1 14 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVUSQW_XMMM32_K1Z_XMM: int = 2667
"""
``VPMOVUSQW xmm1/m32 {k1}{z}, xmm2``
``EVEX.128.F3.0F38.W0 14 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVUSQW_XMMM64_K1Z_YMM: int = 2668
"""
``VPMOVUSQW xmm1/m64 {k1}{z}, ymm2``
``EVEX.256.F3.0F38.W0 14 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVUSQW_XMMM128_K1Z_ZMM: int = 2669
"""
``VPMOVUSQW xmm1/m128 {k1}{z}, zmm2``
``EVEX.512.F3.0F38.W0 14 /r``
``AVX512F``
``16/32/64-bit``
"""
BLENDVPD_XMM_XMMM128: int = 2670
"""
``BLENDVPD xmm1, xmm2/m128, <XMM0>``
``66 0F 38 15 /r``
``SSE4.1``
``16/32/64-bit``
"""
EVEX_VPROLVD_XMM_K1Z_XMM_XMMM128B32: int = 2671
"""
``VPROLVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 15 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPROLVD_YMM_K1Z_YMM_YMMM256B32: int = 2672
"""
``VPROLVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 15 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPROLVD_ZMM_K1Z_ZMM_ZMMM512B32: int = 2673
"""
``VPROLVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.66.0F38.W0 15 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPROLVQ_XMM_K1Z_XMM_XMMM128B64: int = 2674
"""
``VPROLVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 15 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPROLVQ_YMM_K1Z_YMM_YMMM256B64: int = 2675
"""
``VPROLVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 15 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPROLVQ_ZMM_K1Z_ZMM_ZMMM512B64: int = 2676
"""
``VPROLVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F38.W1 15 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVUSQD_XMMM64_K1Z_XMM: int = 2677
"""
``VPMOVUSQD xmm1/m64 {k1}{z}, xmm2``
``EVEX.128.F3.0F38.W0 15 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVUSQD_XMMM128_K1Z_YMM: int = 2678
"""
``VPMOVUSQD xmm1/m128 {k1}{z}, ymm2``
``EVEX.256.F3.0F38.W0 15 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVUSQD_YMMM256_K1Z_ZMM: int = 2679
"""
``VPMOVUSQD ymm1/m256 {k1}{z}, zmm2``
``EVEX.512.F3.0F38.W0 15 /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_VPERMPS_YMM_YMM_YMMM256: int = 2680
"""
``VPERMPS ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W0 16 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPERMPS_YMM_K1Z_YMM_YMMM256B32: int = 2681
"""
``VPERMPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 16 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPERMPS_ZMM_K1Z_ZMM_ZMMM512B32: int = 2682
"""
``VPERMPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.66.0F38.W0 16 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPERMPD_YMM_K1Z_YMM_YMMM256B64: int = 2683
"""
``VPERMPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 16 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPERMPD_ZMM_K1Z_ZMM_ZMMM512B64: int = 2684
"""
``VPERMPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F38.W1 16 /r``
``AVX512F``
``16/32/64-bit``
"""
PTEST_XMM_XMMM128: int = 2685
"""
``PTEST xmm1, xmm2/m128``
``66 0F 38 17 /r``
``SSE4.1``
``16/32/64-bit``
"""
VEX_VPTEST_XMM_XMMM128: int = 2686
"""
``VPTEST xmm1, xmm2/m128``
``VEX.128.66.0F38.WIG 17 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPTEST_YMM_YMMM256: int = 2687
"""
``VPTEST ymm1, ymm2/m256``
``VEX.256.66.0F38.WIG 17 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VBROADCASTSS_XMM_M32: int = 2688
"""
``VBROADCASTSS xmm1, m32``
``VEX.128.66.0F38.W0 18 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VBROADCASTSS_YMM_M32: int = 2689
"""
``VBROADCASTSS ymm1, m32``
``VEX.256.66.0F38.W0 18 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VBROADCASTSS_XMM_K1Z_XMMM32: int = 2690
"""
``VBROADCASTSS xmm1 {k1}{z}, xmm2/m32``
``EVEX.128.66.0F38.W0 18 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VBROADCASTSS_YMM_K1Z_XMMM32: int = 2691
"""
``VBROADCASTSS ymm1 {k1}{z}, xmm2/m32``
``EVEX.256.66.0F38.W0 18 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VBROADCASTSS_ZMM_K1Z_XMMM32: int = 2692
"""
``VBROADCASTSS zmm1 {k1}{z}, xmm2/m32``
``EVEX.512.66.0F38.W0 18 /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_VBROADCASTSD_YMM_M64: int = 2693
"""
``VBROADCASTSD ymm1, m64``
``VEX.256.66.0F38.W0 19 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VBROADCASTF32X2_YMM_K1Z_XMMM64: int = 2694
"""
``VBROADCASTF32X2 ymm1 {k1}{z}, xmm2/m64``
``EVEX.256.66.0F38.W0 19 /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VBROADCASTF32X2_ZMM_K1Z_XMMM64: int = 2695
"""
``VBROADCASTF32X2 zmm1 {k1}{z}, xmm2/m64``
``EVEX.512.66.0F38.W0 19 /r``
``AVX512DQ``
``16/32/64-bit``
"""
EVEX_VBROADCASTSD_YMM_K1Z_XMMM64: int = 2696
"""
``VBROADCASTSD ymm1 {k1}{z}, xmm2/m64``
``EVEX.256.66.0F38.W1 19 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VBROADCASTSD_ZMM_K1Z_XMMM64: int = 2697
"""
``VBROADCASTSD zmm1 {k1}{z}, xmm2/m64``
``EVEX.512.66.0F38.W1 19 /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_VBROADCASTF128_YMM_M128: int = 2698
"""
``VBROADCASTF128 ymm1, m128``
``VEX.256.66.0F38.W0 1A /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VBROADCASTF32X4_YMM_K1Z_M128: int = 2699
"""
``VBROADCASTF32X4 ymm1 {k1}{z}, m128``
``EVEX.256.66.0F38.W0 1A /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VBROADCASTF32X4_ZMM_K1Z_M128: int = 2700
"""
``VBROADCASTF32X4 zmm1 {k1}{z}, m128``
``EVEX.512.66.0F38.W0 1A /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VBROADCASTF64X2_YMM_K1Z_M128: int = 2701
"""
``VBROADCASTF64X2 ymm1 {k1}{z}, m128``
``EVEX.256.66.0F38.W1 1A /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VBROADCASTF64X2_ZMM_K1Z_M128: int = 2702
"""
``VBROADCASTF64X2 zmm1 {k1}{z}, m128``
``EVEX.512.66.0F38.W1 1A /r``
``AVX512DQ``
``16/32/64-bit``
"""
EVEX_VBROADCASTF32X8_ZMM_K1Z_M256: int = 2703
"""
``VBROADCASTF32X8 zmm1 {k1}{z}, m256``
``EVEX.512.66.0F38.W0 1B /r``
``AVX512DQ``
``16/32/64-bit``
"""
EVEX_VBROADCASTF64X4_ZMM_K1Z_M256: int = 2704
"""
``VBROADCASTF64X4 zmm1 {k1}{z}, m256``
``EVEX.512.66.0F38.W1 1B /r``
``AVX512F``
``16/32/64-bit``
"""
PABSB_MM_MMM64: int = 2705
"""
``PABSB mm1, mm2/m64``
``NP 0F 38 1C /r``
``SSSE3``
``16/32/64-bit``
"""
PABSB_XMM_XMMM128: int = 2706
"""
``PABSB xmm1, xmm2/m128``
``66 0F 38 1C /r``
``SSSE3``
``16/32/64-bit``
"""
VEX_VPABSB_XMM_XMMM128: int = 2707
"""
``VPABSB xmm1, xmm2/m128``
``VEX.128.66.0F38.WIG 1C /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPABSB_YMM_YMMM256: int = 2708
"""
``VPABSB ymm1, ymm2/m256``
``VEX.256.66.0F38.WIG 1C /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPABSB_XMM_K1Z_XMMM128: int = 2709
"""
``VPABSB xmm1 {k1}{z}, xmm2/m128``
``EVEX.128.66.0F38.WIG 1C /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPABSB_YMM_K1Z_YMMM256: int = 2710
"""
``VPABSB ymm1 {k1}{z}, ymm2/m256``
``EVEX.256.66.0F38.WIG 1C /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPABSB_ZMM_K1Z_ZMMM512: int = 2711
"""
``VPABSB zmm1 {k1}{z}, zmm2/m512``
``EVEX.512.66.0F38.WIG 1C /r``
``AVX512BW``
``16/32/64-bit``
"""
PABSW_MM_MMM64: int = 2712
"""
``PABSW mm1, mm2/m64``
``NP 0F 38 1D /r``
``SSSE3``
``16/32/64-bit``
"""
PABSW_XMM_XMMM128: int = 2713
"""
``PABSW xmm1, xmm2/m128``
``66 0F 38 1D /r``
``SSSE3``
``16/32/64-bit``
"""
VEX_VPABSW_XMM_XMMM128: int = 2714
"""
``VPABSW xmm1, xmm2/m128``
``VEX.128.66.0F38.WIG 1D /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPABSW_YMM_YMMM256: int = 2715
"""
``VPABSW ymm1, ymm2/m256``
``VEX.256.66.0F38.WIG 1D /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPABSW_XMM_K1Z_XMMM128: int = 2716
"""
``VPABSW xmm1 {k1}{z}, xmm2/m128``
``EVEX.128.66.0F38.WIG 1D /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPABSW_YMM_K1Z_YMMM256: int = 2717
"""
``VPABSW ymm1 {k1}{z}, ymm2/m256``
``EVEX.256.66.0F38.WIG 1D /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPABSW_ZMM_K1Z_ZMMM512: int = 2718
"""
``VPABSW zmm1 {k1}{z}, zmm2/m512``
``EVEX.512.66.0F38.WIG 1D /r``
``AVX512BW``
``16/32/64-bit``
"""
PABSD_MM_MMM64: int = 2719
"""
``PABSD mm1, mm2/m64``
``NP 0F 38 1E /r``
``SSSE3``
``16/32/64-bit``
"""
PABSD_XMM_XMMM128: int = 2720
"""
``PABSD xmm1, xmm2/m128``
``66 0F 38 1E /r``
``SSSE3``
``16/32/64-bit``
"""
VEX_VPABSD_XMM_XMMM128: int = 2721
"""
``VPABSD xmm1, xmm2/m128``
``VEX.128.66.0F38.WIG 1E /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPABSD_YMM_YMMM256: int = 2722
"""
``VPABSD ymm1, ymm2/m256``
``VEX.256.66.0F38.WIG 1E /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPABSD_XMM_K1Z_XMMM128B32: int = 2723
"""
``VPABSD xmm1 {k1}{z}, xmm2/m128/m32bcst``
``EVEX.128.66.0F38.W0 1E /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPABSD_YMM_K1Z_YMMM256B32: int = 2724
"""
``VPABSD ymm1 {k1}{z}, ymm2/m256/m32bcst``
``EVEX.256.66.0F38.W0 1E /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPABSD_ZMM_K1Z_ZMMM512B32: int = 2725
"""
``VPABSD zmm1 {k1}{z}, zmm2/m512/m32bcst``
``EVEX.512.66.0F38.W0 1E /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPABSQ_XMM_K1Z_XMMM128B64: int = 2726
"""
``VPABSQ xmm1 {k1}{z}, xmm2/m128/m64bcst``
``EVEX.128.66.0F38.W1 1F /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPABSQ_YMM_K1Z_YMMM256B64: int = 2727
"""
``VPABSQ ymm1 {k1}{z}, ymm2/m256/m64bcst``
``EVEX.256.66.0F38.W1 1F /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPABSQ_ZMM_K1Z_ZMMM512B64: int = 2728
"""
``VPABSQ zmm1 {k1}{z}, zmm2/m512/m64bcst``
``EVEX.512.66.0F38.W1 1F /r``
``AVX512F``
``16/32/64-bit``
"""
PMOVSXBW_XMM_XMMM64: int = 2729
"""
``PMOVSXBW xmm1, xmm2/m64``
``66 0F 38 20 /r``
``SSE4.1``
``16/32/64-bit``
"""
VEX_VPMOVSXBW_XMM_XMMM64: int = 2730
"""
``VPMOVSXBW xmm1, xmm2/m64``
``VEX.128.66.0F38.WIG 20 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPMOVSXBW_YMM_XMMM128: int = 2731
"""
``VPMOVSXBW ymm1, xmm2/m128``
``VEX.256.66.0F38.WIG 20 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPMOVSXBW_XMM_K1Z_XMMM64: int = 2732
"""
``VPMOVSXBW xmm1 {k1}{z}, xmm2/m64``
``EVEX.128.66.0F38.WIG 20 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMOVSXBW_YMM_K1Z_XMMM128: int = 2733
"""
``VPMOVSXBW ymm1 {k1}{z}, xmm2/m128``
``EVEX.256.66.0F38.WIG 20 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMOVSXBW_ZMM_K1Z_YMMM256: int = 2734
"""
``VPMOVSXBW zmm1 {k1}{z}, ymm2/m256``
``EVEX.512.66.0F38.WIG 20 /r``
``AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMOVSWB_XMMM64_K1Z_XMM: int = 2735
"""
``VPMOVSWB xmm1/m64 {k1}{z}, xmm2``
``EVEX.128.F3.0F38.W0 20 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMOVSWB_XMMM128_K1Z_YMM: int = 2736
"""
``VPMOVSWB xmm1/m128 {k1}{z}, ymm2``
``EVEX.256.F3.0F38.W0 20 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMOVSWB_YMMM256_K1Z_ZMM: int = 2737
"""
``VPMOVSWB ymm1/m256 {k1}{z}, zmm2``
``EVEX.512.F3.0F38.W0 20 /r``
``AVX512BW``
``16/32/64-bit``
"""
PMOVSXBD_XMM_XMMM32: int = 2738
"""
``PMOVSXBD xmm1, xmm2/m32``
``66 0F 38 21 /r``
``SSE4.1``
``16/32/64-bit``
"""
VEX_VPMOVSXBD_XMM_XMMM32: int = 2739
"""
``VPMOVSXBD xmm1, xmm2/m32``
``VEX.128.66.0F38.WIG 21 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPMOVSXBD_YMM_XMMM64: int = 2740
"""
``VPMOVSXBD ymm1, xmm2/m64``
``VEX.256.66.0F38.WIG 21 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPMOVSXBD_XMM_K1Z_XMMM32: int = 2741
"""
``VPMOVSXBD xmm1 {k1}{z}, xmm2/m32``
``EVEX.128.66.0F38.WIG 21 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVSXBD_YMM_K1Z_XMMM64: int = 2742
"""
``VPMOVSXBD ymm1 {k1}{z}, xmm2/m64``
``EVEX.256.66.0F38.WIG 21 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVSXBD_ZMM_K1Z_XMMM128: int = 2743
"""
``VPMOVSXBD zmm1 {k1}{z}, xmm2/m128``
``EVEX.512.66.0F38.WIG 21 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVSDB_XMMM32_K1Z_XMM: int = 2744
"""
``VPMOVSDB xmm1/m32 {k1}{z}, xmm2``
``EVEX.128.F3.0F38.W0 21 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVSDB_XMMM64_K1Z_YMM: int = 2745
"""
``VPMOVSDB xmm1/m64 {k1}{z}, ymm2``
``EVEX.256.F3.0F38.W0 21 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVSDB_XMMM128_K1Z_ZMM: int = 2746
"""
``VPMOVSDB xmm1/m128 {k1}{z}, zmm2``
``EVEX.512.F3.0F38.W0 21 /r``
``AVX512F``
``16/32/64-bit``
"""
PMOVSXBQ_XMM_XMMM16: int = 2747
"""
``PMOVSXBQ xmm1, xmm2/m16``
``66 0F 38 22 /r``
``SSE4.1``
``16/32/64-bit``
"""
VEX_VPMOVSXBQ_XMM_XMMM16: int = 2748
"""
``VPMOVSXBQ xmm1, xmm2/m16``
``VEX.128.66.0F38.WIG 22 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPMOVSXBQ_YMM_XMMM32: int = 2749
"""
``VPMOVSXBQ ymm1, xmm2/m32``
``VEX.256.66.0F38.WIG 22 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPMOVSXBQ_XMM_K1Z_XMMM16: int = 2750
"""
``VPMOVSXBQ xmm1 {k1}{z}, xmm2/m16``
``EVEX.128.66.0F38.WIG 22 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVSXBQ_YMM_K1Z_XMMM32: int = 2751
"""
``VPMOVSXBQ ymm1 {k1}{z}, xmm2/m32``
``EVEX.256.66.0F38.WIG 22 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVSXBQ_ZMM_K1Z_XMMM64: int = 2752
"""
``VPMOVSXBQ zmm1 {k1}{z}, xmm2/m64``
``EVEX.512.66.0F38.WIG 22 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVSQB_XMMM16_K1Z_XMM: int = 2753
"""
``VPMOVSQB xmm1/m16 {k1}{z}, xmm2``
``EVEX.128.F3.0F38.W0 22 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVSQB_XMMM32_K1Z_YMM: int = 2754
"""
``VPMOVSQB xmm1/m32 {k1}{z}, ymm2``
``EVEX.256.F3.0F38.W0 22 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVSQB_XMMM64_K1Z_ZMM: int = 2755
"""
``VPMOVSQB xmm1/m64 {k1}{z}, zmm2``
``EVEX.512.F3.0F38.W0 22 /r``
``AVX512F``
``16/32/64-bit``
"""
PMOVSXWD_XMM_XMMM64: int = 2756
"""
``PMOVSXWD xmm1, xmm2/m64``
``66 0F 38 23 /r``
``SSE4.1``
``16/32/64-bit``
"""
VEX_VPMOVSXWD_XMM_XMMM64: int = 2757
"""
``VPMOVSXWD xmm1, xmm2/m64``
``VEX.128.66.0F38.WIG 23 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPMOVSXWD_YMM_XMMM128: int = 2758
"""
``VPMOVSXWD ymm1, xmm2/m128``
``VEX.256.66.0F38.WIG 23 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPMOVSXWD_XMM_K1Z_XMMM64: int = 2759
"""
``VPMOVSXWD xmm1 {k1}{z}, xmm2/m64``
``EVEX.128.66.0F38.WIG 23 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVSXWD_YMM_K1Z_XMMM128: int = 2760
"""
``VPMOVSXWD ymm1 {k1}{z}, xmm2/m128``
``EVEX.256.66.0F38.WIG 23 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVSXWD_ZMM_K1Z_YMMM256: int = 2761
"""
``VPMOVSXWD zmm1 {k1}{z}, ymm2/m256``
``EVEX.512.66.0F38.WIG 23 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVSDW_XMMM64_K1Z_XMM: int = 2762
"""
``VPMOVSDW xmm1/m64 {k1}{z}, xmm2``
``EVEX.128.F3.0F38.W0 23 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVSDW_XMMM128_K1Z_YMM: int = 2763
"""
``VPMOVSDW xmm1/m128 {k1}{z}, ymm2``
``EVEX.256.F3.0F38.W0 23 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVSDW_YMMM256_K1Z_ZMM: int = 2764
"""
``VPMOVSDW ymm1/m256 {k1}{z}, zmm2``
``EVEX.512.F3.0F38.W0 23 /r``
``AVX512F``
``16/32/64-bit``
"""
PMOVSXWQ_XMM_XMMM32: int = 2765
"""
``PMOVSXWQ xmm1, xmm2/m32``
``66 0F 38 24 /r``
``SSE4.1``
``16/32/64-bit``
"""
VEX_VPMOVSXWQ_XMM_XMMM32: int = 2766
"""
``VPMOVSXWQ xmm1, xmm2/m32``
``VEX.128.66.0F38.WIG 24 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPMOVSXWQ_YMM_XMMM64: int = 2767
"""
``VPMOVSXWQ ymm1, xmm2/m64``
``VEX.256.66.0F38.WIG 24 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPMOVSXWQ_XMM_K1Z_XMMM32: int = 2768
"""
``VPMOVSXWQ xmm1 {k1}{z}, xmm2/m32``
``EVEX.128.66.0F38.WIG 24 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVSXWQ_YMM_K1Z_XMMM64: int = 2769
"""
``VPMOVSXWQ ymm1 {k1}{z}, xmm2/m64``
``EVEX.256.66.0F38.WIG 24 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVSXWQ_ZMM_K1Z_XMMM128: int = 2770
"""
``VPMOVSXWQ zmm1 {k1}{z}, xmm2/m128``
``EVEX.512.66.0F38.WIG 24 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVSQW_XMMM32_K1Z_XMM: int = 2771
"""
``VPMOVSQW xmm1/m32 {k1}{z}, xmm2``
``EVEX.128.F3.0F38.W0 24 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVSQW_XMMM64_K1Z_YMM: int = 2772
"""
``VPMOVSQW xmm1/m64 {k1}{z}, ymm2``
``EVEX.256.F3.0F38.W0 24 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVSQW_XMMM128_K1Z_ZMM: int = 2773
"""
``VPMOVSQW xmm1/m128 {k1}{z}, zmm2``
``EVEX.512.F3.0F38.W0 24 /r``
``AVX512F``
``16/32/64-bit``
"""
PMOVSXDQ_XMM_XMMM64: int = 2774
"""
``PMOVSXDQ xmm1, xmm2/m64``
``66 0F 38 25 /r``
``SSE4.1``
``16/32/64-bit``
"""
VEX_VPMOVSXDQ_XMM_XMMM64: int = 2775
"""
``VPMOVSXDQ xmm1, xmm2/m64``
``VEX.128.66.0F38.WIG 25 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPMOVSXDQ_YMM_XMMM128: int = 2776
"""
``VPMOVSXDQ ymm1, xmm2/m128``
``VEX.256.66.0F38.WIG 25 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPMOVSXDQ_XMM_K1Z_XMMM64: int = 2777
"""
``VPMOVSXDQ xmm1 {k1}{z}, xmm2/m64``
``EVEX.128.66.0F38.W0 25 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVSXDQ_YMM_K1Z_XMMM128: int = 2778
"""
``VPMOVSXDQ ymm1 {k1}{z}, xmm2/m128``
``EVEX.256.66.0F38.W0 25 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVSXDQ_ZMM_K1Z_YMMM256: int = 2779
"""
``VPMOVSXDQ zmm1 {k1}{z}, ymm2/m256``
``EVEX.512.66.0F38.W0 25 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVSQD_XMMM64_K1Z_XMM: int = 2780
"""
``VPMOVSQD xmm1/m64 {k1}{z}, xmm2``
``EVEX.128.F3.0F38.W0 25 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVSQD_XMMM128_K1Z_YMM: int = 2781
"""
``VPMOVSQD xmm1/m128 {k1}{z}, ymm2``
``EVEX.256.F3.0F38.W0 25 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVSQD_YMMM256_K1Z_ZMM: int = 2782
"""
``VPMOVSQD ymm1/m256 {k1}{z}, zmm2``
``EVEX.512.F3.0F38.W0 25 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPTESTMB_KR_K1_XMM_XMMM128: int = 2783
"""
``VPTESTMB k2 {k1}, xmm2, xmm3/m128``
``EVEX.128.66.0F38.W0 26 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPTESTMB_KR_K1_YMM_YMMM256: int = 2784
"""
``VPTESTMB k2 {k1}, ymm2, ymm3/m256``
``EVEX.256.66.0F38.W0 26 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPTESTMB_KR_K1_ZMM_ZMMM512: int = 2785
"""
``VPTESTMB k2 {k1}, zmm2, zmm3/m512``
``EVEX.512.66.0F38.W0 26 /r``
``AVX512BW``
``16/32/64-bit``
"""
EVEX_VPTESTMW_KR_K1_XMM_XMMM128: int = 2786
"""
``VPTESTMW k2 {k1}, xmm2, xmm3/m128``
``EVEX.128.66.0F38.W1 26 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPTESTMW_KR_K1_YMM_YMMM256: int = 2787
"""
``VPTESTMW k2 {k1}, ymm2, ymm3/m256``
``EVEX.256.66.0F38.W1 26 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPTESTMW_KR_K1_ZMM_ZMMM512: int = 2788
"""
``VPTESTMW k2 {k1}, zmm2, zmm3/m512``
``EVEX.512.66.0F38.W1 26 /r``
``AVX512BW``
``16/32/64-bit``
"""
EVEX_VPTESTNMB_KR_K1_XMM_XMMM128: int = 2789
"""
``VPTESTNMB k2 {k1}, xmm2, xmm3/m128``
``EVEX.128.F3.0F38.W0 26 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPTESTNMB_KR_K1_YMM_YMMM256: int = 2790
"""
``VPTESTNMB k2 {k1}, ymm2, ymm3/m256``
``EVEX.256.F3.0F38.W0 26 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPTESTNMB_KR_K1_ZMM_ZMMM512: int = 2791
"""
``VPTESTNMB k2 {k1}, zmm2, zmm3/m512``
``EVEX.512.F3.0F38.W0 26 /r``
``AVX512BW``
``16/32/64-bit``
"""
EVEX_VPTESTNMW_KR_K1_XMM_XMMM128: int = 2792
"""
``VPTESTNMW k2 {k1}, xmm2, xmm3/m128``
``EVEX.128.F3.0F38.W1 26 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPTESTNMW_KR_K1_YMM_YMMM256: int = 2793
"""
``VPTESTNMW k2 {k1}, ymm2, ymm3/m256``
``EVEX.256.F3.0F38.W1 26 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPTESTNMW_KR_K1_ZMM_ZMMM512: int = 2794
"""
``VPTESTNMW k2 {k1}, zmm2, zmm3/m512``
``EVEX.512.F3.0F38.W1 26 /r``
``AVX512BW``
``16/32/64-bit``
"""
EVEX_VPTESTMD_KR_K1_XMM_XMMM128B32: int = 2795
"""
``VPTESTMD k2 {k1}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 27 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPTESTMD_KR_K1_YMM_YMMM256B32: int = 2796
"""
``VPTESTMD k2 {k1}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 27 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPTESTMD_KR_K1_ZMM_ZMMM512B32: int = 2797
"""
``VPTESTMD k2 {k1}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.66.0F38.W0 27 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPTESTMQ_KR_K1_XMM_XMMM128B64: int = 2798
"""
``VPTESTMQ k2 {k1}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 27 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPTESTMQ_KR_K1_YMM_YMMM256B64: int = 2799
"""
``VPTESTMQ k2 {k1}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 27 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPTESTMQ_KR_K1_ZMM_ZMMM512B64: int = 2800
"""
``VPTESTMQ k2 {k1}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F38.W1 27 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPTESTNMD_KR_K1_XMM_XMMM128B32: int = 2801
"""
``VPTESTNMD k2 {k1}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.F3.0F38.W0 27 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPTESTNMD_KR_K1_YMM_YMMM256B32: int = 2802
"""
``VPTESTNMD k2 {k1}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.F3.0F38.W0 27 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPTESTNMD_KR_K1_ZMM_ZMMM512B32: int = 2803
"""
``VPTESTNMD k2 {k1}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.F3.0F38.W0 27 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPTESTNMQ_KR_K1_XMM_XMMM128B64: int = 2804
"""
``VPTESTNMQ k2 {k1}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.F3.0F38.W1 27 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPTESTNMQ_KR_K1_YMM_YMMM256B64: int = 2805
"""
``VPTESTNMQ k2 {k1}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.F3.0F38.W1 27 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPTESTNMQ_KR_K1_ZMM_ZMMM512B64: int = 2806
"""
``VPTESTNMQ k2 {k1}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.F3.0F38.W1 27 /r``
``AVX512F``
``16/32/64-bit``
"""
PMULDQ_XMM_XMMM128: int = 2807
"""
``PMULDQ xmm1, xmm2/m128``
``66 0F 38 28 /r``
``SSE4.1``
``16/32/64-bit``
"""
VEX_VPMULDQ_XMM_XMM_XMMM128: int = 2808
"""
``VPMULDQ xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.WIG 28 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPMULDQ_YMM_YMM_YMMM256: int = 2809
"""
``VPMULDQ ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.WIG 28 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPMULDQ_XMM_K1Z_XMM_XMMM128B64: int = 2810
"""
``VPMULDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 28 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMULDQ_YMM_K1Z_YMM_YMMM256B64: int = 2811
"""
``VPMULDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 28 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMULDQ_ZMM_K1Z_ZMM_ZMMM512B64: int = 2812
"""
``VPMULDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F38.W1 28 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVM2B_XMM_KR: int = 2813
"""
``VPMOVM2B xmm1, k1``
``EVEX.128.F3.0F38.W0 28 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMOVM2B_YMM_KR: int = 2814
"""
``VPMOVM2B ymm1, k1``
``EVEX.256.F3.0F38.W0 28 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMOVM2B_ZMM_KR: int = 2815
"""
``VPMOVM2B zmm1, k1``
``EVEX.512.F3.0F38.W0 28 /r``
``AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMOVM2W_XMM_KR: int = 2816
"""
``VPMOVM2W xmm1, k1``
``EVEX.128.F3.0F38.W1 28 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMOVM2W_YMM_KR: int = 2817
"""
``VPMOVM2W ymm1, k1``
``EVEX.256.F3.0F38.W1 28 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMOVM2W_ZMM_KR: int = 2818
"""
``VPMOVM2W zmm1, k1``
``EVEX.512.F3.0F38.W1 28 /r``
``AVX512BW``
``16/32/64-bit``
"""
PCMPEQQ_XMM_XMMM128: int = 2819
"""
``PCMPEQQ xmm1, xmm2/m128``
``66 0F 38 29 /r``
``SSE4.1``
``16/32/64-bit``
"""
VEX_VPCMPEQQ_XMM_XMM_XMMM128: int = 2820
"""
``VPCMPEQQ xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.WIG 29 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPCMPEQQ_YMM_YMM_YMMM256: int = 2821
"""
``VPCMPEQQ ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.WIG 29 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPCMPEQQ_KR_K1_XMM_XMMM128B64: int = 2822
"""
``VPCMPEQQ k1 {k2}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 29 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPCMPEQQ_KR_K1_YMM_YMMM256B64: int = 2823
"""
``VPCMPEQQ k1 {k2}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 29 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPCMPEQQ_KR_K1_ZMM_ZMMM512B64: int = 2824
"""
``VPCMPEQQ k1 {k2}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F38.W1 29 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVB2M_KR_XMM: int = 2825
"""
``VPMOVB2M k1, xmm1``
``EVEX.128.F3.0F38.W0 29 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMOVB2M_KR_YMM: int = 2826
"""
``VPMOVB2M k1, ymm1``
``EVEX.256.F3.0F38.W0 29 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMOVB2M_KR_ZMM: int = 2827
"""
``VPMOVB2M k1, zmm1``
``EVEX.512.F3.0F38.W0 29 /r``
``AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMOVW2M_KR_XMM: int = 2828
"""
``VPMOVW2M k1, xmm1``
``EVEX.128.F3.0F38.W1 29 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMOVW2M_KR_YMM: int = 2829
"""
``VPMOVW2M k1, ymm1``
``EVEX.256.F3.0F38.W1 29 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMOVW2M_KR_ZMM: int = 2830
"""
``VPMOVW2M k1, zmm1``
``EVEX.512.F3.0F38.W1 29 /r``
``AVX512BW``
``16/32/64-bit``
"""
MOVNTDQA_XMM_M128: int = 2831
"""
``MOVNTDQA xmm1, m128``
``66 0F 38 2A /r``
``SSE4.1``
``16/32/64-bit``
"""
VEX_VMOVNTDQA_XMM_M128: int = 2832
"""
``VMOVNTDQA xmm1, m128``
``VEX.128.66.0F38.WIG 2A /r``
``AVX``
``16/32/64-bit``
"""
VEX_VMOVNTDQA_YMM_M256: int = 2833
"""
``VMOVNTDQA ymm1, m256``
``VEX.256.66.0F38.WIG 2A /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VMOVNTDQA_XMM_M128: int = 2834
"""
``VMOVNTDQA xmm1, m128``
``EVEX.128.66.0F38.W0 2A /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVNTDQA_YMM_M256: int = 2835
"""
``VMOVNTDQA ymm1, m256``
``EVEX.256.66.0F38.W0 2A /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VMOVNTDQA_ZMM_M512: int = 2836
"""
``VMOVNTDQA zmm1, m512``
``EVEX.512.66.0F38.W0 2A /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPBROADCASTMB2Q_XMM_KR: int = 2837
"""
``VPBROADCASTMB2Q xmm1, k1``
``EVEX.128.F3.0F38.W1 2A /r``
``AVX512VL and AVX512CD``
``16/32/64-bit``
"""
EVEX_VPBROADCASTMB2Q_YMM_KR: int = 2838
"""
``VPBROADCASTMB2Q ymm1, k1``
``EVEX.256.F3.0F38.W1 2A /r``
``AVX512VL and AVX512CD``
``16/32/64-bit``
"""
EVEX_VPBROADCASTMB2Q_ZMM_KR: int = 2839
"""
``VPBROADCASTMB2Q zmm1, k1``
``EVEX.512.F3.0F38.W1 2A /r``
``AVX512CD``
``16/32/64-bit``
"""
PACKUSDW_XMM_XMMM128: int = 2840
"""
``PACKUSDW xmm1, xmm2/m128``
``66 0F 38 2B /r``
``SSE4.1``
``16/32/64-bit``
"""
VEX_VPACKUSDW_XMM_XMM_XMMM128: int = 2841
"""
``VPACKUSDW xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.WIG 2B /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPACKUSDW_YMM_YMM_YMMM256: int = 2842
"""
``VPACKUSDW ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.WIG 2B /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPACKUSDW_XMM_K1Z_XMM_XMMM128B32: int = 2843
"""
``VPACKUSDW xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 2B /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPACKUSDW_YMM_K1Z_YMM_YMMM256B32: int = 2844
"""
``VPACKUSDW ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 2B /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPACKUSDW_ZMM_K1Z_ZMM_ZMMM512B32: int = 2845
"""
``VPACKUSDW zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.66.0F38.W0 2B /r``
``AVX512BW``
``16/32/64-bit``
"""
VEX_VMASKMOVPS_XMM_XMM_M128: int = 2846
"""
``VMASKMOVPS xmm1, xmm2, m128``
``VEX.128.66.0F38.W0 2C /r``
``AVX``
``16/32/64-bit``
"""
VEX_VMASKMOVPS_YMM_YMM_M256: int = 2847
"""
``VMASKMOVPS ymm1, ymm2, m256``
``VEX.256.66.0F38.W0 2C /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VSCALEFPS_XMM_K1Z_XMM_XMMM128B32: int = 2848
"""
``VSCALEFPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 2C /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VSCALEFPS_YMM_K1Z_YMM_YMMM256B32: int = 2849
"""
``VSCALEFPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 2C /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VSCALEFPS_ZMM_K1Z_ZMM_ZMMM512B32_ER: int = 2850
"""
``VSCALEFPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}``
``EVEX.512.66.0F38.W0 2C /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VSCALEFPD_XMM_K1Z_XMM_XMMM128B64: int = 2851
"""
``VSCALEFPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 2C /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VSCALEFPD_YMM_K1Z_YMM_YMMM256B64: int = 2852
"""
``VSCALEFPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 2C /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VSCALEFPD_ZMM_K1Z_ZMM_ZMMM512B64_ER: int = 2853
"""
``VSCALEFPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}``
``EVEX.512.66.0F38.W1 2C /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_VMASKMOVPD_XMM_XMM_M128: int = 2854
"""
``VMASKMOVPD xmm1, xmm2, m128``
``VEX.128.66.0F38.W0 2D /r``
``AVX``
``16/32/64-bit``
"""
VEX_VMASKMOVPD_YMM_YMM_M256: int = 2855
"""
``VMASKMOVPD ymm1, ymm2, m256``
``VEX.256.66.0F38.W0 2D /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VSCALEFSS_XMM_K1Z_XMM_XMMM32_ER: int = 2856
"""
``VSCALEFSS xmm1 {k1}{z}, xmm2, xmm3/m32{er}``
``EVEX.LIG.66.0F38.W0 2D /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VSCALEFSD_XMM_K1Z_XMM_XMMM64_ER: int = 2857
"""
``VSCALEFSD xmm1 {k1}{z}, xmm2, xmm3/m64{er}``
``EVEX.LIG.66.0F38.W1 2D /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_VMASKMOVPS_M128_XMM_XMM: int = 2858
"""
``VMASKMOVPS m128, xmm1, xmm2``
``VEX.128.66.0F38.W0 2E /r``
``AVX``
``16/32/64-bit``
"""
VEX_VMASKMOVPS_M256_YMM_YMM: int = 2859
"""
``VMASKMOVPS m256, ymm1, ymm2``
``VEX.256.66.0F38.W0 2E /r``
``AVX``
``16/32/64-bit``
"""
VEX_VMASKMOVPD_M128_XMM_XMM: int = 2860
"""
``VMASKMOVPD m128, xmm1, xmm2``
``VEX.128.66.0F38.W0 2F /r``
``AVX``
``16/32/64-bit``
"""
VEX_VMASKMOVPD_M256_YMM_YMM: int = 2861
"""
``VMASKMOVPD m256, ymm1, ymm2``
``VEX.256.66.0F38.W0 2F /r``
``AVX``
``16/32/64-bit``
"""
PMOVZXBW_XMM_XMMM64: int = 2862
"""
``PMOVZXBW xmm1, xmm2/m64``
``66 0F 38 30 /r``
``SSE4.1``
``16/32/64-bit``
"""
VEX_VPMOVZXBW_XMM_XMMM64: int = 2863
"""
``VPMOVZXBW xmm1, xmm2/m64``
``VEX.128.66.0F38.WIG 30 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPMOVZXBW_YMM_XMMM128: int = 2864
"""
``VPMOVZXBW ymm1, xmm2/m128``
``VEX.256.66.0F38.WIG 30 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPMOVZXBW_XMM_K1Z_XMMM64: int = 2865
"""
``VPMOVZXBW xmm1 {k1}{z}, xmm2/m64``
``EVEX.128.66.0F38.WIG 30 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMOVZXBW_YMM_K1Z_XMMM128: int = 2866
"""
``VPMOVZXBW ymm1 {k1}{z}, xmm2/m128``
``EVEX.256.66.0F38.WIG 30 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMOVZXBW_ZMM_K1Z_YMMM256: int = 2867
"""
``VPMOVZXBW zmm1 {k1}{z}, ymm2/m256``
``EVEX.512.66.0F38.WIG 30 /r``
``AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMOVWB_XMMM64_K1Z_XMM: int = 2868
"""
``VPMOVWB xmm1/m64 {k1}{z}, xmm2``
``EVEX.128.F3.0F38.W0 30 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMOVWB_XMMM128_K1Z_YMM: int = 2869
"""
``VPMOVWB xmm1/m128 {k1}{z}, ymm2``
``EVEX.256.F3.0F38.W0 30 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMOVWB_YMMM256_K1Z_ZMM: int = 2870
"""
``VPMOVWB ymm1/m256 {k1}{z}, zmm2``
``EVEX.512.F3.0F38.W0 30 /r``
``AVX512BW``
``16/32/64-bit``
"""
PMOVZXBD_XMM_XMMM32: int = 2871
"""
``PMOVZXBD xmm1, xmm2/m32``
``66 0F 38 31 /r``
``SSE4.1``
``16/32/64-bit``
"""
VEX_VPMOVZXBD_XMM_XMMM32: int = 2872
"""
``VPMOVZXBD xmm1, xmm2/m32``
``VEX.128.66.0F38.WIG 31 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPMOVZXBD_YMM_XMMM64: int = 2873
"""
``VPMOVZXBD ymm1, xmm2/m64``
``VEX.256.66.0F38.WIG 31 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPMOVZXBD_XMM_K1Z_XMMM32: int = 2874
"""
``VPMOVZXBD xmm1 {k1}{z}, xmm2/m32``
``EVEX.128.66.0F38.WIG 31 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVZXBD_YMM_K1Z_XMMM64: int = 2875
"""
``VPMOVZXBD ymm1 {k1}{z}, xmm2/m64``
``EVEX.256.66.0F38.WIG 31 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVZXBD_ZMM_K1Z_XMMM128: int = 2876
"""
``VPMOVZXBD zmm1 {k1}{z}, xmm2/m128``
``EVEX.512.66.0F38.WIG 31 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVDB_XMMM32_K1Z_XMM: int = 2877
"""
``VPMOVDB xmm1/m32 {k1}{z}, xmm2``
``EVEX.128.F3.0F38.W0 31 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVDB_XMMM64_K1Z_YMM: int = 2878
"""
``VPMOVDB xmm1/m64 {k1}{z}, ymm2``
``EVEX.256.F3.0F38.W0 31 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVDB_XMMM128_K1Z_ZMM: int = 2879
"""
``VPMOVDB xmm1/m128 {k1}{z}, zmm2``
``EVEX.512.F3.0F38.W0 31 /r``
``AVX512F``
``16/32/64-bit``
"""
PMOVZXBQ_XMM_XMMM16: int = 2880
"""
``PMOVZXBQ xmm1, xmm2/m16``
``66 0F 38 32 /r``
``SSE4.1``
``16/32/64-bit``
"""
VEX_VPMOVZXBQ_XMM_XMMM16: int = 2881
"""
``VPMOVZXBQ xmm1, xmm2/m16``
``VEX.128.66.0F38.WIG 32 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPMOVZXBQ_YMM_XMMM32: int = 2882
"""
``VPMOVZXBQ ymm1, xmm2/m32``
``VEX.256.66.0F38.WIG 32 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPMOVZXBQ_XMM_K1Z_XMMM16: int = 2883
"""
``VPMOVZXBQ xmm1 {k1}{z}, xmm2/m16``
``EVEX.128.66.0F38.WIG 32 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVZXBQ_YMM_K1Z_XMMM32: int = 2884
"""
``VPMOVZXBQ ymm1 {k1}{z}, xmm2/m32``
``EVEX.256.66.0F38.WIG 32 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVZXBQ_ZMM_K1Z_XMMM64: int = 2885
"""
``VPMOVZXBQ zmm1 {k1}{z}, xmm2/m64``
``EVEX.512.66.0F38.WIG 32 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVQB_XMMM16_K1Z_XMM: int = 2886
"""
``VPMOVQB xmm1/m16 {k1}{z}, xmm2``
``EVEX.128.F3.0F38.W0 32 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVQB_XMMM32_K1Z_YMM: int = 2887
"""
``VPMOVQB xmm1/m32 {k1}{z}, ymm2``
``EVEX.256.F3.0F38.W0 32 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVQB_XMMM64_K1Z_ZMM: int = 2888
"""
``VPMOVQB xmm1/m64 {k1}{z}, zmm2``
``EVEX.512.F3.0F38.W0 32 /r``
``AVX512F``
``16/32/64-bit``
"""
PMOVZXWD_XMM_XMMM64: int = 2889
"""
``PMOVZXWD xmm1, xmm2/m64``
``66 0F 38 33 /r``
``SSE4.1``
``16/32/64-bit``
"""
VEX_VPMOVZXWD_XMM_XMMM64: int = 2890
"""
``VPMOVZXWD xmm1, xmm2/m64``
``VEX.128.66.0F38.WIG 33 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPMOVZXWD_YMM_XMMM128: int = 2891
"""
``VPMOVZXWD ymm1, xmm2/m128``
``VEX.256.66.0F38.WIG 33 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPMOVZXWD_XMM_K1Z_XMMM64: int = 2892
"""
``VPMOVZXWD xmm1 {k1}{z}, xmm2/m64``
``EVEX.128.66.0F38.WIG 33 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVZXWD_YMM_K1Z_XMMM128: int = 2893
"""
``VPMOVZXWD ymm1 {k1}{z}, xmm2/m128``
``EVEX.256.66.0F38.WIG 33 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVZXWD_ZMM_K1Z_YMMM256: int = 2894
"""
``VPMOVZXWD zmm1 {k1}{z}, ymm2/m256``
``EVEX.512.66.0F38.WIG 33 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVDW_XMMM64_K1Z_XMM: int = 2895
"""
``VPMOVDW xmm1/m64 {k1}{z}, xmm2``
``EVEX.128.F3.0F38.W0 33 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVDW_XMMM128_K1Z_YMM: int = 2896
"""
``VPMOVDW xmm1/m128 {k1}{z}, ymm2``
``EVEX.256.F3.0F38.W0 33 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVDW_YMMM256_K1Z_ZMM: int = 2897
"""
``VPMOVDW ymm1/m256 {k1}{z}, zmm2``
``EVEX.512.F3.0F38.W0 33 /r``
``AVX512F``
``16/32/64-bit``
"""
PMOVZXWQ_XMM_XMMM32: int = 2898
"""
``PMOVZXWQ xmm1, xmm2/m32``
``66 0F 38 34 /r``
``SSE4.1``
``16/32/64-bit``
"""
VEX_VPMOVZXWQ_XMM_XMMM32: int = 2899
"""
``VPMOVZXWQ xmm1, xmm2/m32``
``VEX.128.66.0F38.WIG 34 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPMOVZXWQ_YMM_XMMM64: int = 2900
"""
``VPMOVZXWQ ymm1, xmm2/m64``
``VEX.256.66.0F38.WIG 34 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPMOVZXWQ_XMM_K1Z_XMMM32: int = 2901
"""
``VPMOVZXWQ xmm1 {k1}{z}, xmm2/m32``
``EVEX.128.66.0F38.WIG 34 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVZXWQ_YMM_K1Z_XMMM64: int = 2902
"""
``VPMOVZXWQ ymm1 {k1}{z}, xmm2/m64``
``EVEX.256.66.0F38.WIG 34 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVZXWQ_ZMM_K1Z_XMMM128: int = 2903
"""
``VPMOVZXWQ zmm1 {k1}{z}, xmm2/m128``
``EVEX.512.66.0F38.WIG 34 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVQW_XMMM32_K1Z_XMM: int = 2904
"""
``VPMOVQW xmm1/m32 {k1}{z}, xmm2``
``EVEX.128.F3.0F38.W0 34 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVQW_XMMM64_K1Z_YMM: int = 2905
"""
``VPMOVQW xmm1/m64 {k1}{z}, ymm2``
``EVEX.256.F3.0F38.W0 34 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVQW_XMMM128_K1Z_ZMM: int = 2906
"""
``VPMOVQW xmm1/m128 {k1}{z}, zmm2``
``EVEX.512.F3.0F38.W0 34 /r``
``AVX512F``
``16/32/64-bit``
"""
PMOVZXDQ_XMM_XMMM64: int = 2907
"""
``PMOVZXDQ xmm1, xmm2/m64``
``66 0F 38 35 /r``
``SSE4.1``
``16/32/64-bit``
"""
VEX_VPMOVZXDQ_XMM_XMMM64: int = 2908
"""
``VPMOVZXDQ xmm1, xmm2/m64``
``VEX.128.66.0F38.WIG 35 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPMOVZXDQ_YMM_XMMM128: int = 2909
"""
``VPMOVZXDQ ymm1, xmm2/m128``
``VEX.256.66.0F38.WIG 35 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPMOVZXDQ_XMM_K1Z_XMMM64: int = 2910
"""
``VPMOVZXDQ xmm1 {k1}{z}, xmm2/m64``
``EVEX.128.66.0F38.W0 35 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVZXDQ_YMM_K1Z_XMMM128: int = 2911
"""
``VPMOVZXDQ ymm1 {k1}{z}, xmm2/m128``
``EVEX.256.66.0F38.W0 35 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVZXDQ_ZMM_K1Z_YMMM256: int = 2912
"""
``VPMOVZXDQ zmm1 {k1}{z}, ymm2/m256``
``EVEX.512.66.0F38.W0 35 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVQD_XMMM64_K1Z_XMM: int = 2913
"""
``VPMOVQD xmm1/m64 {k1}{z}, xmm2``
``EVEX.128.F3.0F38.W0 35 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVQD_XMMM128_K1Z_YMM: int = 2914
"""
``VPMOVQD xmm1/m128 {k1}{z}, ymm2``
``EVEX.256.F3.0F38.W0 35 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVQD_YMMM256_K1Z_ZMM: int = 2915
"""
``VPMOVQD ymm1/m256 {k1}{z}, zmm2``
``EVEX.512.F3.0F38.W0 35 /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_VPERMD_YMM_YMM_YMMM256: int = 2916
"""
``VPERMD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W0 36 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPERMD_YMM_K1Z_YMM_YMMM256B32: int = 2917
"""
``VPERMD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 36 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPERMD_ZMM_K1Z_ZMM_ZMMM512B32: int = 2918
"""
``VPERMD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.66.0F38.W0 36 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPERMQ_YMM_K1Z_YMM_YMMM256B64: int = 2919
"""
``VPERMQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 36 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPERMQ_ZMM_K1Z_ZMM_ZMMM512B64: int = 2920
"""
``VPERMQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F38.W1 36 /r``
``AVX512F``
``16/32/64-bit``
"""
PCMPGTQ_XMM_XMMM128: int = 2921
"""
``PCMPGTQ xmm1, xmm2/m128``
``66 0F 38 37 /r``
``SSE4.2``
``16/32/64-bit``
"""
VEX_VPCMPGTQ_XMM_XMM_XMMM128: int = 2922
"""
``VPCMPGTQ xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.WIG 37 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPCMPGTQ_YMM_YMM_YMMM256: int = 2923
"""
``VPCMPGTQ ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.WIG 37 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPCMPGTQ_KR_K1_XMM_XMMM128B64: int = 2924
"""
``VPCMPGTQ k1 {k2}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 37 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPCMPGTQ_KR_K1_YMM_YMMM256B64: int = 2925
"""
``VPCMPGTQ k1 {k2}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 37 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPCMPGTQ_KR_K1_ZMM_ZMMM512B64: int = 2926
"""
``VPCMPGTQ k1 {k2}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F38.W1 37 /r``
``AVX512F``
``16/32/64-bit``
"""
PMINSB_XMM_XMMM128: int = 2927
"""
``PMINSB xmm1, xmm2/m128``
``66 0F 38 38 /r``
``SSE4.1``
``16/32/64-bit``
"""
VEX_VPMINSB_XMM_XMM_XMMM128: int = 2928
"""
``VPMINSB xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.WIG 38 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPMINSB_YMM_YMM_YMMM256: int = 2929
"""
``VPMINSB ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.WIG 38 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPMINSB_XMM_K1Z_XMM_XMMM128: int = 2930
"""
``VPMINSB xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F38.WIG 38 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMINSB_YMM_K1Z_YMM_YMMM256: int = 2931
"""
``VPMINSB ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F38.WIG 38 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMINSB_ZMM_K1Z_ZMM_ZMMM512: int = 2932
"""
``VPMINSB zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F38.WIG 38 /r``
``AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMOVM2D_XMM_KR: int = 2933
"""
``VPMOVM2D xmm1, k1``
``EVEX.128.F3.0F38.W0 38 /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VPMOVM2D_YMM_KR: int = 2934
"""
``VPMOVM2D ymm1, k1``
``EVEX.256.F3.0F38.W0 38 /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VPMOVM2D_ZMM_KR: int = 2935
"""
``VPMOVM2D zmm1, k1``
``EVEX.512.F3.0F38.W0 38 /r``
``AVX512DQ``
``16/32/64-bit``
"""
EVEX_VPMOVM2Q_XMM_KR: int = 2936
"""
``VPMOVM2Q xmm1, k1``
``EVEX.128.F3.0F38.W1 38 /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VPMOVM2Q_YMM_KR: int = 2937
"""
``VPMOVM2Q ymm1, k1``
``EVEX.256.F3.0F38.W1 38 /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VPMOVM2Q_ZMM_KR: int = 2938
"""
``VPMOVM2Q zmm1, k1``
``EVEX.512.F3.0F38.W1 38 /r``
``AVX512DQ``
``16/32/64-bit``
"""
PMINSD_XMM_XMMM128: int = 2939
"""
``PMINSD xmm1, xmm2/m128``
``66 0F 38 39 /r``
``SSE4.1``
``16/32/64-bit``
"""
VEX_VPMINSD_XMM_XMM_XMMM128: int = 2940
"""
``VPMINSD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.WIG 39 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPMINSD_YMM_YMM_YMMM256: int = 2941
"""
``VPMINSD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.WIG 39 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPMINSD_XMM_K1Z_XMM_XMMM128B32: int = 2942
"""
``VPMINSD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 39 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMINSD_YMM_K1Z_YMM_YMMM256B32: int = 2943
"""
``VPMINSD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 39 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMINSD_ZMM_K1Z_ZMM_ZMMM512B32: int = 2944
"""
``VPMINSD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.66.0F38.W0 39 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPMINSQ_XMM_K1Z_XMM_XMMM128B64: int = 2945
"""
``VPMINSQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 39 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMINSQ_YMM_K1Z_YMM_YMMM256B64: int = 2946
"""
``VPMINSQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 39 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMINSQ_ZMM_K1Z_ZMM_ZMMM512B64: int = 2947
"""
``VPMINSQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F38.W1 39 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPMOVD2M_KR_XMM: int = 2948
"""
``VPMOVD2M k1, xmm1``
``EVEX.128.F3.0F38.W0 39 /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VPMOVD2M_KR_YMM: int = 2949
"""
``VPMOVD2M k1, ymm1``
``EVEX.256.F3.0F38.W0 39 /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VPMOVD2M_KR_ZMM: int = 2950
"""
``VPMOVD2M k1, zmm1``
``EVEX.512.F3.0F38.W0 39 /r``
``AVX512DQ``
``16/32/64-bit``
"""
EVEX_VPMOVQ2M_KR_XMM: int = 2951
"""
``VPMOVQ2M k1, xmm1``
``EVEX.128.F3.0F38.W1 39 /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VPMOVQ2M_KR_YMM: int = 2952
"""
``VPMOVQ2M k1, ymm1``
``EVEX.256.F3.0F38.W1 39 /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VPMOVQ2M_KR_ZMM: int = 2953
"""
``VPMOVQ2M k1, zmm1``
``EVEX.512.F3.0F38.W1 39 /r``
``AVX512DQ``
``16/32/64-bit``
"""
PMINUW_XMM_XMMM128: int = 2954
"""
``PMINUW xmm1, xmm2/m128``
``66 0F 38 3A /r``
``SSE4.1``
``16/32/64-bit``
"""
VEX_VPMINUW_XMM_XMM_XMMM128: int = 2955
"""
``VPMINUW xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.WIG 3A /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPMINUW_YMM_YMM_YMMM256: int = 2956
"""
``VPMINUW ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.WIG 3A /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPMINUW_XMM_K1Z_XMM_XMMM128: int = 2957
"""
``VPMINUW xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F38.WIG 3A /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMINUW_YMM_K1Z_YMM_YMMM256: int = 2958
"""
``VPMINUW ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F38.WIG 3A /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMINUW_ZMM_K1Z_ZMM_ZMMM512: int = 2959
"""
``VPMINUW zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F38.WIG 3A /r``
``AVX512BW``
``16/32/64-bit``
"""
EVEX_VPBROADCASTMW2D_XMM_KR: int = 2960
"""
``VPBROADCASTMW2D xmm1, k1``
``EVEX.128.F3.0F38.W0 3A /r``
``AVX512VL and AVX512CD``
``16/32/64-bit``
"""
EVEX_VPBROADCASTMW2D_YMM_KR: int = 2961
"""
``VPBROADCASTMW2D ymm1, k1``
``EVEX.256.F3.0F38.W0 3A /r``
``AVX512VL and AVX512CD``
``16/32/64-bit``
"""
EVEX_VPBROADCASTMW2D_ZMM_KR: int = 2962
"""
``VPBROADCASTMW2D zmm1, k1``
``EVEX.512.F3.0F38.W0 3A /r``
``AVX512CD``
``16/32/64-bit``
"""
PMINUD_XMM_XMMM128: int = 2963
"""
``PMINUD xmm1, xmm2/m128``
``66 0F 38 3B /r``
``SSE4.1``
``16/32/64-bit``
"""
VEX_VPMINUD_XMM_XMM_XMMM128: int = 2964
"""
``VPMINUD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.WIG 3B /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPMINUD_YMM_YMM_YMMM256: int = 2965
"""
``VPMINUD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.WIG 3B /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPMINUD_XMM_K1Z_XMM_XMMM128B32: int = 2966
"""
``VPMINUD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 3B /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMINUD_YMM_K1Z_YMM_YMMM256B32: int = 2967
"""
``VPMINUD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 3B /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMINUD_ZMM_K1Z_ZMM_ZMMM512B32: int = 2968
"""
``VPMINUD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.66.0F38.W0 3B /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPMINUQ_XMM_K1Z_XMM_XMMM128B64: int = 2969
"""
``VPMINUQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 3B /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMINUQ_YMM_K1Z_YMM_YMMM256B64: int = 2970
"""
``VPMINUQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 3B /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMINUQ_ZMM_K1Z_ZMM_ZMMM512B64: int = 2971
"""
``VPMINUQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F38.W1 3B /r``
``AVX512F``
``16/32/64-bit``
"""
PMAXSB_XMM_XMMM128: int = 2972
"""
``PMAXSB xmm1, xmm2/m128``
``66 0F 38 3C /r``
``SSE4.1``
``16/32/64-bit``
"""
VEX_VPMAXSB_XMM_XMM_XMMM128: int = 2973
"""
``VPMAXSB xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.WIG 3C /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPMAXSB_YMM_YMM_YMMM256: int = 2974
"""
``VPMAXSB ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.WIG 3C /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPMAXSB_XMM_K1Z_XMM_XMMM128: int = 2975
"""
``VPMAXSB xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F38.WIG 3C /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMAXSB_YMM_K1Z_YMM_YMMM256: int = 2976
"""
``VPMAXSB ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F38.WIG 3C /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMAXSB_ZMM_K1Z_ZMM_ZMMM512: int = 2977
"""
``VPMAXSB zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F38.WIG 3C /r``
``AVX512BW``
``16/32/64-bit``
"""
PMAXSD_XMM_XMMM128: int = 2978
"""
``PMAXSD xmm1, xmm2/m128``
``66 0F 38 3D /r``
``SSE4.1``
``16/32/64-bit``
"""
VEX_VPMAXSD_XMM_XMM_XMMM128: int = 2979
"""
``VPMAXSD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.WIG 3D /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPMAXSD_YMM_YMM_YMMM256: int = 2980
"""
``VPMAXSD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.WIG 3D /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPMAXSD_XMM_K1Z_XMM_XMMM128B32: int = 2981
"""
``VPMAXSD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 3D /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMAXSD_YMM_K1Z_YMM_YMMM256B32: int = 2982
"""
``VPMAXSD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 3D /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMAXSD_ZMM_K1Z_ZMM_ZMMM512B32: int = 2983
"""
``VPMAXSD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.66.0F38.W0 3D /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPMAXSQ_XMM_K1Z_XMM_XMMM128B64: int = 2984
"""
``VPMAXSQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 3D /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMAXSQ_YMM_K1Z_YMM_YMMM256B64: int = 2985
"""
``VPMAXSQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 3D /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMAXSQ_ZMM_K1Z_ZMM_ZMMM512B64: int = 2986
"""
``VPMAXSQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F38.W1 3D /r``
``AVX512F``
``16/32/64-bit``
"""
PMAXUW_XMM_XMMM128: int = 2987
"""
``PMAXUW xmm1, xmm2/m128``
``66 0F 38 3E /r``
``SSE4.1``
``16/32/64-bit``
"""
VEX_VPMAXUW_XMM_XMM_XMMM128: int = 2988
"""
``VPMAXUW xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.WIG 3E /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPMAXUW_YMM_YMM_YMMM256: int = 2989
"""
``VPMAXUW ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.WIG 3E /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPMAXUW_XMM_K1Z_XMM_XMMM128: int = 2990
"""
``VPMAXUW xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F38.WIG 3E /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMAXUW_YMM_K1Z_YMM_YMMM256: int = 2991
"""
``VPMAXUW ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F38.WIG 3E /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPMAXUW_ZMM_K1Z_ZMM_ZMMM512: int = 2992
"""
``VPMAXUW zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F38.WIG 3E /r``
``AVX512BW``
``16/32/64-bit``
"""
PMAXUD_XMM_XMMM128: int = 2993
"""
``PMAXUD xmm1, xmm2/m128``
``66 0F 38 3F /r``
``SSE4.1``
``16/32/64-bit``
"""
VEX_VPMAXUD_XMM_XMM_XMMM128: int = 2994
"""
``VPMAXUD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.WIG 3F /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPMAXUD_YMM_YMM_YMMM256: int = 2995
"""
``VPMAXUD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.WIG 3F /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPMAXUD_XMM_K1Z_XMM_XMMM128B32: int = 2996
"""
``VPMAXUD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 3F /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMAXUD_YMM_K1Z_YMM_YMMM256B32: int = 2997
"""
``VPMAXUD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 3F /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMAXUD_ZMM_K1Z_ZMM_ZMMM512B32: int = 2998
"""
``VPMAXUD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.66.0F38.W0 3F /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPMAXUQ_XMM_K1Z_XMM_XMMM128B64: int = 2999
"""
``VPMAXUQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 3F /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMAXUQ_YMM_K1Z_YMM_YMMM256B64: int = 3000
"""
``VPMAXUQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 3F /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMAXUQ_ZMM_K1Z_ZMM_ZMMM512B64: int = 3001
"""
``VPMAXUQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F38.W1 3F /r``
``AVX512F``
``16/32/64-bit``
"""
PMULLD_XMM_XMMM128: int = 3002
"""
``PMULLD xmm1, xmm2/m128``
``66 0F 38 40 /r``
``SSE4.1``
``16/32/64-bit``
"""
VEX_VPMULLD_XMM_XMM_XMMM128: int = 3003
"""
``VPMULLD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.WIG 40 /r``
``AVX``
``16/32/64-bit``
"""
VEX_VPMULLD_YMM_YMM_YMMM256: int = 3004
"""
``VPMULLD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.WIG 40 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPMULLD_XMM_K1Z_XMM_XMMM128B32: int = 3005
"""
``VPMULLD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 40 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMULLD_YMM_K1Z_YMM_YMMM256B32: int = 3006
"""
``VPMULLD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 40 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPMULLD_ZMM_K1Z_ZMM_ZMMM512B32: int = 3007
"""
``VPMULLD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.66.0F38.W0 40 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPMULLQ_XMM_K1Z_XMM_XMMM128B64: int = 3008
"""
``VPMULLQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 40 /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VPMULLQ_YMM_K1Z_YMM_YMMM256B64: int = 3009
"""
``VPMULLQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 40 /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VPMULLQ_ZMM_K1Z_ZMM_ZMMM512B64: int = 3010
"""
``VPMULLQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F38.W1 40 /r``
``AVX512DQ``
``16/32/64-bit``
"""
PHMINPOSUW_XMM_XMMM128: int = 3011
"""
``PHMINPOSUW xmm1, xmm2/m128``
``66 0F 38 41 /r``
``SSE4.1``
``16/32/64-bit``
"""
VEX_VPHMINPOSUW_XMM_XMMM128: int = 3012
"""
``VPHMINPOSUW xmm1, xmm2/m128``
``VEX.128.66.0F38.WIG 41 /r``
``AVX``
``16/32/64-bit``
"""
EVEX_VGETEXPPS_XMM_K1Z_XMMM128B32: int = 3013
"""
``VGETEXPPS xmm1 {k1}{z}, xmm2/m128/m32bcst``
``EVEX.128.66.0F38.W0 42 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VGETEXPPS_YMM_K1Z_YMMM256B32: int = 3014
"""
``VGETEXPPS ymm1 {k1}{z}, ymm2/m256/m32bcst``
``EVEX.256.66.0F38.W0 42 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VGETEXPPS_ZMM_K1Z_ZMMM512B32_SAE: int = 3015
"""
``VGETEXPPS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}``
``EVEX.512.66.0F38.W0 42 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VGETEXPPD_XMM_K1Z_XMMM128B64: int = 3016
"""
``VGETEXPPD xmm1 {k1}{z}, xmm2/m128/m64bcst``
``EVEX.128.66.0F38.W1 42 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VGETEXPPD_YMM_K1Z_YMMM256B64: int = 3017
"""
``VGETEXPPD ymm1 {k1}{z}, ymm2/m256/m64bcst``
``EVEX.256.66.0F38.W1 42 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VGETEXPPD_ZMM_K1Z_ZMMM512B64_SAE: int = 3018
"""
``VGETEXPPD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}``
``EVEX.512.66.0F38.W1 42 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VGETEXPSS_XMM_K1Z_XMM_XMMM32_SAE: int = 3019
"""
``VGETEXPSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}``
``EVEX.LIG.66.0F38.W0 43 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VGETEXPSD_XMM_K1Z_XMM_XMMM64_SAE: int = 3020
"""
``VGETEXPSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}``
``EVEX.LIG.66.0F38.W1 43 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPLZCNTD_XMM_K1Z_XMMM128B32: int = 3021
"""
``VPLZCNTD xmm1 {k1}{z}, xmm2/m128/m32bcst``
``EVEX.128.66.0F38.W0 44 /r``
``AVX512VL and AVX512CD``
``16/32/64-bit``
"""
EVEX_VPLZCNTD_YMM_K1Z_YMMM256B32: int = 3022
"""
``VPLZCNTD ymm1 {k1}{z}, ymm2/m256/m32bcst``
``EVEX.256.66.0F38.W0 44 /r``
``AVX512VL and AVX512CD``
``16/32/64-bit``
"""
EVEX_VPLZCNTD_ZMM_K1Z_ZMMM512B32: int = 3023
"""
``VPLZCNTD zmm1 {k1}{z}, zmm2/m512/m32bcst``
``EVEX.512.66.0F38.W0 44 /r``
``AVX512CD``
``16/32/64-bit``
"""
EVEX_VPLZCNTQ_XMM_K1Z_XMMM128B64: int = 3024
"""
``VPLZCNTQ xmm1 {k1}{z}, xmm2/m128/m64bcst``
``EVEX.128.66.0F38.W1 44 /r``
``AVX512VL and AVX512CD``
``16/32/64-bit``
"""
EVEX_VPLZCNTQ_YMM_K1Z_YMMM256B64: int = 3025
"""
``VPLZCNTQ ymm1 {k1}{z}, ymm2/m256/m64bcst``
``EVEX.256.66.0F38.W1 44 /r``
``AVX512VL and AVX512CD``
``16/32/64-bit``
"""
EVEX_VPLZCNTQ_ZMM_K1Z_ZMMM512B64: int = 3026
"""
``VPLZCNTQ zmm1 {k1}{z}, zmm2/m512/m64bcst``
``EVEX.512.66.0F38.W1 44 /r``
``AVX512CD``
``16/32/64-bit``
"""
VEX_VPSRLVD_XMM_XMM_XMMM128: int = 3027
"""
``VPSRLVD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W0 45 /r``
``AVX2``
``16/32/64-bit``
"""
VEX_VPSRLVD_YMM_YMM_YMMM256: int = 3028
"""
``VPSRLVD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W0 45 /r``
``AVX2``
``16/32/64-bit``
"""
VEX_VPSRLVQ_XMM_XMM_XMMM128: int = 3029
"""
``VPSRLVQ xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W1 45 /r``
``AVX2``
``16/32/64-bit``
"""
VEX_VPSRLVQ_YMM_YMM_YMMM256: int = 3030
"""
``VPSRLVQ ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W1 45 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPSRLVD_XMM_K1Z_XMM_XMMM128B32: int = 3031
"""
``VPSRLVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 45 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSRLVD_YMM_K1Z_YMM_YMMM256B32: int = 3032
"""
``VPSRLVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 45 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSRLVD_ZMM_K1Z_ZMM_ZMMM512B32: int = 3033
"""
``VPSRLVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.66.0F38.W0 45 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPSRLVQ_XMM_K1Z_XMM_XMMM128B64: int = 3034
"""
``VPSRLVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 45 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSRLVQ_YMM_K1Z_YMM_YMMM256B64: int = 3035
"""
``VPSRLVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 45 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSRLVQ_ZMM_K1Z_ZMM_ZMMM512B64: int = 3036
"""
``VPSRLVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F38.W1 45 /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_VPSRAVD_XMM_XMM_XMMM128: int = 3037
"""
``VPSRAVD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W0 46 /r``
``AVX2``
``16/32/64-bit``
"""
VEX_VPSRAVD_YMM_YMM_YMMM256: int = 3038
"""
``VPSRAVD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W0 46 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPSRAVD_XMM_K1Z_XMM_XMMM128B32: int = 3039
"""
``VPSRAVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 46 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSRAVD_YMM_K1Z_YMM_YMMM256B32: int = 3040
"""
``VPSRAVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 46 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSRAVD_ZMM_K1Z_ZMM_ZMMM512B32: int = 3041
"""
``VPSRAVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.66.0F38.W0 46 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPSRAVQ_XMM_K1Z_XMM_XMMM128B64: int = 3042
"""
``VPSRAVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 46 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSRAVQ_YMM_K1Z_YMM_YMMM256B64: int = 3043
"""
``VPSRAVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 46 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSRAVQ_ZMM_K1Z_ZMM_ZMMM512B64: int = 3044
"""
``VPSRAVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F38.W1 46 /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_VPSLLVD_XMM_XMM_XMMM128: int = 3045
"""
``VPSLLVD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W0 47 /r``
``AVX2``
``16/32/64-bit``
"""
VEX_VPSLLVD_YMM_YMM_YMMM256: int = 3046
"""
``VPSLLVD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W0 47 /r``
``AVX2``
``16/32/64-bit``
"""
VEX_VPSLLVQ_XMM_XMM_XMMM128: int = 3047
"""
``VPSLLVQ xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W1 47 /r``
``AVX2``
``16/32/64-bit``
"""
VEX_VPSLLVQ_YMM_YMM_YMMM256: int = 3048
"""
``VPSLLVQ ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W1 47 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPSLLVD_XMM_K1Z_XMM_XMMM128B32: int = 3049
"""
``VPSLLVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 47 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSLLVD_YMM_K1Z_YMM_YMMM256B32: int = 3050
"""
``VPSLLVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 47 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSLLVD_ZMM_K1Z_ZMM_ZMMM512B32: int = 3051
"""
``VPSLLVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.66.0F38.W0 47 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPSLLVQ_XMM_K1Z_XMM_XMMM128B64: int = 3052
"""
``VPSLLVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 47 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSLLVQ_YMM_K1Z_YMM_YMMM256B64: int = 3053
"""
``VPSLLVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 47 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSLLVQ_ZMM_K1Z_ZMM_ZMMM512B64: int = 3054
"""
``VPSLLVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F38.W1 47 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VRCP14PS_XMM_K1Z_XMMM128B32: int = 3055
"""
``VRCP14PS xmm1 {k1}{z}, xmm2/m128/m32bcst``
``EVEX.128.66.0F38.W0 4C /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VRCP14PS_YMM_K1Z_YMMM256B32: int = 3056
"""
``VRCP14PS ymm1 {k1}{z}, ymm2/m256/m32bcst``
``EVEX.256.66.0F38.W0 4C /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VRCP14PS_ZMM_K1Z_ZMMM512B32: int = 3057
"""
``VRCP14PS zmm1 {k1}{z}, zmm2/m512/m32bcst``
``EVEX.512.66.0F38.W0 4C /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VRCP14PD_XMM_K1Z_XMMM128B64: int = 3058
"""
``VRCP14PD xmm1 {k1}{z}, xmm2/m128/m64bcst``
``EVEX.128.66.0F38.W1 4C /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VRCP14PD_YMM_K1Z_YMMM256B64: int = 3059
"""
``VRCP14PD ymm1 {k1}{z}, ymm2/m256/m64bcst``
``EVEX.256.66.0F38.W1 4C /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VRCP14PD_ZMM_K1Z_ZMMM512B64: int = 3060
"""
``VRCP14PD zmm1 {k1}{z}, zmm2/m512/m64bcst``
``EVEX.512.66.0F38.W1 4C /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VRCP14SS_XMM_K1Z_XMM_XMMM32: int = 3061
"""
``VRCP14SS xmm1 {k1}{z}, xmm2, xmm3/m32``
``EVEX.LIG.66.0F38.W0 4D /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VRCP14SD_XMM_K1Z_XMM_XMMM64: int = 3062
"""
``VRCP14SD xmm1 {k1}{z}, xmm2, xmm3/m64``
``EVEX.LIG.66.0F38.W1 4D /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VRSQRT14PS_XMM_K1Z_XMMM128B32: int = 3063
"""
``VRSQRT14PS xmm1 {k1}{z}, xmm2/m128/m32bcst``
``EVEX.128.66.0F38.W0 4E /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VRSQRT14PS_YMM_K1Z_YMMM256B32: int = 3064
"""
``VRSQRT14PS ymm1 {k1}{z}, ymm2/m256/m32bcst``
``EVEX.256.66.0F38.W0 4E /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VRSQRT14PS_ZMM_K1Z_ZMMM512B32: int = 3065
"""
``VRSQRT14PS zmm1 {k1}{z}, zmm2/m512/m32bcst``
``EVEX.512.66.0F38.W0 4E /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VRSQRT14PD_XMM_K1Z_XMMM128B64: int = 3066
"""
``VRSQRT14PD xmm1 {k1}{z}, xmm2/m128/m64bcst``
``EVEX.128.66.0F38.W1 4E /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VRSQRT14PD_YMM_K1Z_YMMM256B64: int = 3067
"""
``VRSQRT14PD ymm1 {k1}{z}, ymm2/m256/m64bcst``
``EVEX.256.66.0F38.W1 4E /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VRSQRT14PD_ZMM_K1Z_ZMMM512B64: int = 3068
"""
``VRSQRT14PD zmm1 {k1}{z}, zmm2/m512/m64bcst``
``EVEX.512.66.0F38.W1 4E /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VRSQRT14SS_XMM_K1Z_XMM_XMMM32: int = 3069
"""
``VRSQRT14SS xmm1 {k1}{z}, xmm2, xmm3/m32``
``EVEX.LIG.66.0F38.W0 4F /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VRSQRT14SD_XMM_K1Z_XMM_XMMM64: int = 3070
"""
``VRSQRT14SD xmm1 {k1}{z}, xmm2, xmm3/m64``
``EVEX.LIG.66.0F38.W1 4F /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPDPBUSD_XMM_K1Z_XMM_XMMM128B32: int = 3071
"""
``VPDPBUSD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 50 /r``
``AVX512VL and AVX512_VNNI``
``16/32/64-bit``
"""
EVEX_VPDPBUSD_YMM_K1Z_YMM_YMMM256B32: int = 3072
"""
``VPDPBUSD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 50 /r``
``AVX512VL and AVX512_VNNI``
``16/32/64-bit``
"""
EVEX_VPDPBUSD_ZMM_K1Z_ZMM_ZMMM512B32: int = 3073
"""
``VPDPBUSD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.66.0F38.W0 50 /r``
``AVX512_VNNI``
``16/32/64-bit``
"""
EVEX_VPDPBUSDS_XMM_K1Z_XMM_XMMM128B32: int = 3074
"""
``VPDPBUSDS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 51 /r``
``AVX512VL and AVX512_VNNI``
``16/32/64-bit``
"""
EVEX_VPDPBUSDS_YMM_K1Z_YMM_YMMM256B32: int = 3075
"""
``VPDPBUSDS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 51 /r``
``AVX512VL and AVX512_VNNI``
``16/32/64-bit``
"""
EVEX_VPDPBUSDS_ZMM_K1Z_ZMM_ZMMM512B32: int = 3076
"""
``VPDPBUSDS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.66.0F38.W0 51 /r``
``AVX512_VNNI``
``16/32/64-bit``
"""
EVEX_VPDPWSSD_XMM_K1Z_XMM_XMMM128B32: int = 3077
"""
``VPDPWSSD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 52 /r``
``AVX512VL and AVX512_VNNI``
``16/32/64-bit``
"""
EVEX_VPDPWSSD_YMM_K1Z_YMM_YMMM256B32: int = 3078
"""
``VPDPWSSD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 52 /r``
``AVX512VL and AVX512_VNNI``
``16/32/64-bit``
"""
EVEX_VPDPWSSD_ZMM_K1Z_ZMM_ZMMM512B32: int = 3079
"""
``VPDPWSSD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.66.0F38.W0 52 /r``
``AVX512_VNNI``
``16/32/64-bit``
"""
EVEX_VDPBF16PS_XMM_K1Z_XMM_XMMM128B32: int = 3080
"""
``VDPBF16PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.F3.0F38.W0 52 /r``
``AVX512VL and AVX512_BF16``
``16/32/64-bit``
"""
EVEX_VDPBF16PS_YMM_K1Z_YMM_YMMM256B32: int = 3081
"""
``VDPBF16PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.F3.0F38.W0 52 /r``
``AVX512VL and AVX512_BF16``
``16/32/64-bit``
"""
EVEX_VDPBF16PS_ZMM_K1Z_ZMM_ZMMM512B32: int = 3082
"""
``VDPBF16PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.F3.0F38.W0 52 /r``
``AVX512F and AVX512_BF16``
``16/32/64-bit``
"""
EVEX_VP4DPWSSD_ZMM_K1Z_ZMMP3_M128: int = 3083
"""
``VP4DPWSSD zmm1 {k1}{z}, zmm2+3, m128``
``EVEX.512.F2.0F38.W0 52 /r``
``AVX512_4VNNIW``
``16/32/64-bit``
"""
EVEX_VPDPWSSDS_XMM_K1Z_XMM_XMMM128B32: int = 3084
"""
``VPDPWSSDS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 53 /r``
``AVX512VL and AVX512_VNNI``
``16/32/64-bit``
"""
EVEX_VPDPWSSDS_YMM_K1Z_YMM_YMMM256B32: int = 3085
"""
``VPDPWSSDS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 53 /r``
``AVX512VL and AVX512_VNNI``
``16/32/64-bit``
"""
EVEX_VPDPWSSDS_ZMM_K1Z_ZMM_ZMMM512B32: int = 3086
"""
``VPDPWSSDS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.66.0F38.W0 53 /r``
``AVX512_VNNI``
``16/32/64-bit``
"""
EVEX_VP4DPWSSDS_ZMM_K1Z_ZMMP3_M128: int = 3087
"""
``VP4DPWSSDS zmm1 {k1}{z}, zmm2+3, m128``
``EVEX.512.F2.0F38.W0 53 /r``
``AVX512_4VNNIW``
``16/32/64-bit``
"""
EVEX_VPOPCNTB_XMM_K1Z_XMMM128: int = 3088
"""
``VPOPCNTB xmm1 {k1}{z}, xmm2/m128``
``EVEX.128.66.0F38.W0 54 /r``
``AVX512VL and AVX512_BITALG``
``16/32/64-bit``
"""
EVEX_VPOPCNTB_YMM_K1Z_YMMM256: int = 3089
"""
``VPOPCNTB ymm1 {k1}{z}, ymm2/m256``
``EVEX.256.66.0F38.W0 54 /r``
``AVX512VL and AVX512_BITALG``
``16/32/64-bit``
"""
EVEX_VPOPCNTB_ZMM_K1Z_ZMMM512: int = 3090
"""
``VPOPCNTB zmm1 {k1}{z}, zmm2/m512``
``EVEX.512.66.0F38.W0 54 /r``
``AVX512_BITALG``
``16/32/64-bit``
"""
EVEX_VPOPCNTW_XMM_K1Z_XMMM128: int = 3091
"""
``VPOPCNTW xmm1 {k1}{z}, xmm2/m128``
``EVEX.128.66.0F38.W1 54 /r``
``AVX512VL and AVX512_BITALG``
``16/32/64-bit``
"""
EVEX_VPOPCNTW_YMM_K1Z_YMMM256: int = 3092
"""
``VPOPCNTW ymm1 {k1}{z}, ymm2/m256``
``EVEX.256.66.0F38.W1 54 /r``
``AVX512VL and AVX512_BITALG``
``16/32/64-bit``
"""
EVEX_VPOPCNTW_ZMM_K1Z_ZMMM512: int = 3093
"""
``VPOPCNTW zmm1 {k1}{z}, zmm2/m512``
``EVEX.512.66.0F38.W1 54 /r``
``AVX512_BITALG``
``16/32/64-bit``
"""
EVEX_VPOPCNTD_XMM_K1Z_XMMM128B32: int = 3094
"""
``VPOPCNTD xmm1 {k1}{z}, xmm2/m128/m32bcst``
``EVEX.128.66.0F38.W0 55 /r``
``AVX512VL and AVX512_VPOPCNTDQ``
``16/32/64-bit``
"""
EVEX_VPOPCNTD_YMM_K1Z_YMMM256B32: int = 3095
"""
``VPOPCNTD ymm1 {k1}{z}, ymm2/m256/m32bcst``
``EVEX.256.66.0F38.W0 55 /r``
``AVX512VL and AVX512_VPOPCNTDQ``
``16/32/64-bit``
"""
EVEX_VPOPCNTD_ZMM_K1Z_ZMMM512B32: int = 3096
"""
``VPOPCNTD zmm1 {k1}{z}, zmm2/m512/m32bcst``
``EVEX.512.66.0F38.W0 55 /r``
``AVX512_VPOPCNTDQ``
``16/32/64-bit``
"""
EVEX_VPOPCNTQ_XMM_K1Z_XMMM128B64: int = 3097
"""
``VPOPCNTQ xmm1 {k1}{z}, xmm2/m128/m64bcst``
``EVEX.128.66.0F38.W1 55 /r``
``AVX512VL and AVX512_VPOPCNTDQ``
``16/32/64-bit``
"""
EVEX_VPOPCNTQ_YMM_K1Z_YMMM256B64: int = 3098
"""
``VPOPCNTQ ymm1 {k1}{z}, ymm2/m256/m64bcst``
``EVEX.256.66.0F38.W1 55 /r``
``AVX512VL and AVX512_VPOPCNTDQ``
``16/32/64-bit``
"""
EVEX_VPOPCNTQ_ZMM_K1Z_ZMMM512B64: int = 3099
"""
``VPOPCNTQ zmm1 {k1}{z}, zmm2/m512/m64bcst``
``EVEX.512.66.0F38.W1 55 /r``
``AVX512_VPOPCNTDQ``
``16/32/64-bit``
"""
VEX_VPBROADCASTD_XMM_XMMM32: int = 3100
"""
``VPBROADCASTD xmm1, xmm2/m32``
``VEX.128.66.0F38.W0 58 /r``
``AVX2``
``16/32/64-bit``
"""
VEX_VPBROADCASTD_YMM_XMMM32: int = 3101
"""
``VPBROADCASTD ymm1, xmm2/m32``
``VEX.256.66.0F38.W0 58 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPBROADCASTD_XMM_K1Z_XMMM32: int = 3102
"""
``VPBROADCASTD xmm1 {k1}{z}, xmm2/m32``
``EVEX.128.66.0F38.W0 58 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPBROADCASTD_YMM_K1Z_XMMM32: int = 3103
"""
``VPBROADCASTD ymm1 {k1}{z}, xmm2/m32``
``EVEX.256.66.0F38.W0 58 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPBROADCASTD_ZMM_K1Z_XMMM32: int = 3104
"""
``VPBROADCASTD zmm1 {k1}{z}, xmm2/m32``
``EVEX.512.66.0F38.W0 58 /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_VPBROADCASTQ_XMM_XMMM64: int = 3105
"""
``VPBROADCASTQ xmm1, xmm2/m64``
``VEX.128.66.0F38.W0 59 /r``
``AVX2``
``16/32/64-bit``
"""
VEX_VPBROADCASTQ_YMM_XMMM64: int = 3106
"""
``VPBROADCASTQ ymm1, xmm2/m64``
``VEX.256.66.0F38.W0 59 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VBROADCASTI32X2_XMM_K1Z_XMMM64: int = 3107
"""
``VBROADCASTI32X2 xmm1 {k1}{z}, xmm2/m64``
``EVEX.128.66.0F38.W0 59 /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VBROADCASTI32X2_YMM_K1Z_XMMM64: int = 3108
"""
``VBROADCASTI32X2 ymm1 {k1}{z}, xmm2/m64``
``EVEX.256.66.0F38.W0 59 /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VBROADCASTI32X2_ZMM_K1Z_XMMM64: int = 3109
"""
``VBROADCASTI32X2 zmm1 {k1}{z}, xmm2/m64``
``EVEX.512.66.0F38.W0 59 /r``
``AVX512DQ``
``16/32/64-bit``
"""
EVEX_VPBROADCASTQ_XMM_K1Z_XMMM64: int = 3110
"""
``VPBROADCASTQ xmm1 {k1}{z}, xmm2/m64``
``EVEX.128.66.0F38.W1 59 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPBROADCASTQ_YMM_K1Z_XMMM64: int = 3111
"""
``VPBROADCASTQ ymm1 {k1}{z}, xmm2/m64``
``EVEX.256.66.0F38.W1 59 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPBROADCASTQ_ZMM_K1Z_XMMM64: int = 3112
"""
``VPBROADCASTQ zmm1 {k1}{z}, xmm2/m64``
``EVEX.512.66.0F38.W1 59 /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_VBROADCASTI128_YMM_M128: int = 3113
"""
``VBROADCASTI128 ymm1, m128``
``VEX.256.66.0F38.W0 5A /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VBROADCASTI32X4_YMM_K1Z_M128: int = 3114
"""
``VBROADCASTI32X4 ymm1 {k1}{z}, m128``
``EVEX.256.66.0F38.W0 5A /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VBROADCASTI32X4_ZMM_K1Z_M128: int = 3115
"""
``VBROADCASTI32X4 zmm1 {k1}{z}, m128``
``EVEX.512.66.0F38.W0 5A /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VBROADCASTI64X2_YMM_K1Z_M128: int = 3116
"""
``VBROADCASTI64X2 ymm1 {k1}{z}, m128``
``EVEX.256.66.0F38.W1 5A /r``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VBROADCASTI64X2_ZMM_K1Z_M128: int = 3117
"""
``VBROADCASTI64X2 zmm1 {k1}{z}, m128``
``EVEX.512.66.0F38.W1 5A /r``
``AVX512DQ``
``16/32/64-bit``
"""
EVEX_VBROADCASTI32X8_ZMM_K1Z_M256: int = 3118
"""
``VBROADCASTI32X8 zmm1 {k1}{z}, m256``
``EVEX.512.66.0F38.W0 5B /r``
``AVX512DQ``
``16/32/64-bit``
"""
EVEX_VBROADCASTI64X4_ZMM_K1Z_M256: int = 3119
"""
``VBROADCASTI64X4 zmm1 {k1}{z}, m256``
``EVEX.512.66.0F38.W1 5B /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPEXPANDB_XMM_K1Z_XMMM128: int = 3120
"""
``VPEXPANDB xmm1 {k1}{z}, xmm2/m128``
``EVEX.128.66.0F38.W0 62 /r``
``AVX512VL and AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPEXPANDB_YMM_K1Z_YMMM256: int = 3121
"""
``VPEXPANDB ymm1 {k1}{z}, ymm2/m256``
``EVEX.256.66.0F38.W0 62 /r``
``AVX512VL and AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPEXPANDB_ZMM_K1Z_ZMMM512: int = 3122
"""
``VPEXPANDB zmm1 {k1}{z}, zmm2/m512``
``EVEX.512.66.0F38.W0 62 /r``
``AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPEXPANDW_XMM_K1Z_XMMM128: int = 3123
"""
``VPEXPANDW xmm1 {k1}{z}, xmm2/m128``
``EVEX.128.66.0F38.W1 62 /r``
``AVX512VL and AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPEXPANDW_YMM_K1Z_YMMM256: int = 3124
"""
``VPEXPANDW ymm1 {k1}{z}, ymm2/m256``
``EVEX.256.66.0F38.W1 62 /r``
``AVX512VL and AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPEXPANDW_ZMM_K1Z_ZMMM512: int = 3125
"""
``VPEXPANDW zmm1 {k1}{z}, zmm2/m512``
``EVEX.512.66.0F38.W1 62 /r``
``AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPCOMPRESSB_XMMM128_K1Z_XMM: int = 3126
"""
``VPCOMPRESSB xmm1/m128 {k1}{z}, xmm2``
``EVEX.128.66.0F38.W0 63 /r``
``AVX512VL and AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPCOMPRESSB_YMMM256_K1Z_YMM: int = 3127
"""
``VPCOMPRESSB ymm1/m256 {k1}{z}, ymm2``
``EVEX.256.66.0F38.W0 63 /r``
``AVX512VL and AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPCOMPRESSB_ZMMM512_K1Z_ZMM: int = 3128
"""
``VPCOMPRESSB zmm1/m512 {k1}{z}, zmm2``
``EVEX.512.66.0F38.W0 63 /r``
``AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPCOMPRESSW_XMMM128_K1Z_XMM: int = 3129
"""
``VPCOMPRESSW xmm1/m128 {k1}{z}, xmm2``
``EVEX.128.66.0F38.W1 63 /r``
``AVX512VL and AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPCOMPRESSW_YMMM256_K1Z_YMM: int = 3130
"""
``VPCOMPRESSW ymm1/m256 {k1}{z}, ymm2``
``EVEX.256.66.0F38.W1 63 /r``
``AVX512VL and AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPCOMPRESSW_ZMMM512_K1Z_ZMM: int = 3131
"""
``VPCOMPRESSW zmm1/m512 {k1}{z}, zmm2``
``EVEX.512.66.0F38.W1 63 /r``
``AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPBLENDMD_XMM_K1Z_XMM_XMMM128B32: int = 3132
"""
``VPBLENDMD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 64 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPBLENDMD_YMM_K1Z_YMM_YMMM256B32: int = 3133
"""
``VPBLENDMD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 64 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPBLENDMD_ZMM_K1Z_ZMM_ZMMM512B32: int = 3134
"""
``VPBLENDMD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.66.0F38.W0 64 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPBLENDMQ_XMM_K1Z_XMM_XMMM128B64: int = 3135
"""
``VPBLENDMQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 64 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPBLENDMQ_YMM_K1Z_YMM_YMMM256B64: int = 3136
"""
``VPBLENDMQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 64 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPBLENDMQ_ZMM_K1Z_ZMM_ZMMM512B64: int = 3137
"""
``VPBLENDMQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F38.W1 64 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VBLENDMPS_XMM_K1Z_XMM_XMMM128B32: int = 3138
"""
``VBLENDMPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 65 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VBLENDMPS_YMM_K1Z_YMM_YMMM256B32: int = 3139
"""
``VBLENDMPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 65 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VBLENDMPS_ZMM_K1Z_ZMM_ZMMM512B32: int = 3140
"""
``VBLENDMPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.66.0F38.W0 65 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VBLENDMPD_XMM_K1Z_XMM_XMMM128B64: int = 3141
"""
``VBLENDMPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 65 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VBLENDMPD_YMM_K1Z_YMM_YMMM256B64: int = 3142
"""
``VBLENDMPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 65 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VBLENDMPD_ZMM_K1Z_ZMM_ZMMM512B64: int = 3143
"""
``VBLENDMPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F38.W1 65 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPBLENDMB_XMM_K1Z_XMM_XMMM128: int = 3144
"""
``VPBLENDMB xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F38.W0 66 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPBLENDMB_YMM_K1Z_YMM_YMMM256: int = 3145
"""
``VPBLENDMB ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F38.W0 66 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPBLENDMB_ZMM_K1Z_ZMM_ZMMM512: int = 3146
"""
``VPBLENDMB zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F38.W0 66 /r``
``AVX512BW``
``16/32/64-bit``
"""
EVEX_VPBLENDMW_XMM_K1Z_XMM_XMMM128: int = 3147
"""
``VPBLENDMW xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F38.W1 66 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPBLENDMW_YMM_K1Z_YMM_YMMM256: int = 3148
"""
``VPBLENDMW ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F38.W1 66 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPBLENDMW_ZMM_K1Z_ZMM_ZMMM512: int = 3149
"""
``VPBLENDMW zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F38.W1 66 /r``
``AVX512BW``
``16/32/64-bit``
"""
EVEX_VP2INTERSECTD_KP1_XMM_XMMM128B32: int = 3150
"""
``VP2INTERSECTD k1+1, xmm2, xmm3/m128/m32bcst``
``EVEX.128.F2.0F38.W0 68 /r``
``AVX512VL and AVX512_VP2INTERSECT``
``16/32/64-bit``
"""
EVEX_VP2INTERSECTD_KP1_YMM_YMMM256B32: int = 3151
"""
``VP2INTERSECTD k1+1, ymm2, ymm3/m256/m32bcst``
``EVEX.256.F2.0F38.W0 68 /r``
``AVX512VL and AVX512_VP2INTERSECT``
``16/32/64-bit``
"""
EVEX_VP2INTERSECTD_KP1_ZMM_ZMMM512B32: int = 3152
"""
``VP2INTERSECTD k1+1, zmm2, zmm3/m512/m32bcst``
``EVEX.512.F2.0F38.W0 68 /r``
``AVX512F and AVX512_VP2INTERSECT``
``16/32/64-bit``
"""
EVEX_VP2INTERSECTQ_KP1_XMM_XMMM128B64: int = 3153
"""
``VP2INTERSECTQ k1+1, xmm2, xmm3/m128/m64bcst``
``EVEX.128.F2.0F38.W1 68 /r``
``AVX512VL and AVX512_VP2INTERSECT``
``16/32/64-bit``
"""
EVEX_VP2INTERSECTQ_KP1_YMM_YMMM256B64: int = 3154
"""
``VP2INTERSECTQ k1+1, ymm2, ymm3/m256/m64bcst``
``EVEX.256.F2.0F38.W1 68 /r``
``AVX512VL and AVX512_VP2INTERSECT``
``16/32/64-bit``
"""
EVEX_VP2INTERSECTQ_KP1_ZMM_ZMMM512B64: int = 3155
"""
``VP2INTERSECTQ k1+1, zmm2, zmm3/m512/m64bcst``
``EVEX.512.F2.0F38.W1 68 /r``
``AVX512F and AVX512_VP2INTERSECT``
``16/32/64-bit``
"""
EVEX_VPSHLDVW_XMM_K1Z_XMM_XMMM128: int = 3156
"""
``VPSHLDVW xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F38.W1 70 /r``
``AVX512VL and AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPSHLDVW_YMM_K1Z_YMM_YMMM256: int = 3157
"""
``VPSHLDVW ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F38.W1 70 /r``
``AVX512VL and AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPSHLDVW_ZMM_K1Z_ZMM_ZMMM512: int = 3158
"""
``VPSHLDVW zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F38.W1 70 /r``
``AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPSHLDVD_XMM_K1Z_XMM_XMMM128B32: int = 3159
"""
``VPSHLDVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 71 /r``
``AVX512VL and AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPSHLDVD_YMM_K1Z_YMM_YMMM256B32: int = 3160
"""
``VPSHLDVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 71 /r``
``AVX512VL and AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPSHLDVD_ZMM_K1Z_ZMM_ZMMM512B32: int = 3161
"""
``VPSHLDVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.66.0F38.W0 71 /r``
``AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPSHLDVQ_XMM_K1Z_XMM_XMMM128B64: int = 3162
"""
``VPSHLDVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 71 /r``
``AVX512VL and AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPSHLDVQ_YMM_K1Z_YMM_YMMM256B64: int = 3163
"""
``VPSHLDVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 71 /r``
``AVX512VL and AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPSHLDVQ_ZMM_K1Z_ZMM_ZMMM512B64: int = 3164
"""
``VPSHLDVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F38.W1 71 /r``
``AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPSHRDVW_XMM_K1Z_XMM_XMMM128: int = 3165
"""
``VPSHRDVW xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F38.W1 72 /r``
``AVX512VL and AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPSHRDVW_YMM_K1Z_YMM_YMMM256: int = 3166
"""
``VPSHRDVW ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F38.W1 72 /r``
``AVX512VL and AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPSHRDVW_ZMM_K1Z_ZMM_ZMMM512: int = 3167
"""
``VPSHRDVW zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F38.W1 72 /r``
``AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VCVTNEPS2BF16_XMM_K1Z_XMMM128B32: int = 3168
"""
``VCVTNEPS2BF16 xmm1 {k1}{z}, xmm2/m128/m32bcst``
``EVEX.128.F3.0F38.W0 72 /r``
``AVX512VL and AVX512_BF16``
``16/32/64-bit``
"""
EVEX_VCVTNEPS2BF16_XMM_K1Z_YMMM256B32: int = 3169
"""
``VCVTNEPS2BF16 xmm1 {k1}{z}, ymm2/m256/m32bcst``
``EVEX.256.F3.0F38.W0 72 /r``
``AVX512VL and AVX512_BF16``
``16/32/64-bit``
"""
EVEX_VCVTNEPS2BF16_YMM_K1Z_ZMMM512B32: int = 3170
"""
``VCVTNEPS2BF16 ymm1 {k1}{z}, zmm2/m512/m32bcst``
``EVEX.512.F3.0F38.W0 72 /r``
``AVX512F and AVX512_BF16``
``16/32/64-bit``
"""
EVEX_VCVTNE2PS2BF16_XMM_K1Z_XMM_XMMM128B32: int = 3171
"""
``VCVTNE2PS2BF16 xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.F2.0F38.W0 72 /r``
``AVX512VL and AVX512_BF16``
``16/32/64-bit``
"""
EVEX_VCVTNE2PS2BF16_YMM_K1Z_YMM_YMMM256B32: int = 3172
"""
``VCVTNE2PS2BF16 ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.F2.0F38.W0 72 /r``
``AVX512VL and AVX512_BF16``
``16/32/64-bit``
"""
EVEX_VCVTNE2PS2BF16_ZMM_K1Z_ZMM_ZMMM512B32: int = 3173
"""
``VCVTNE2PS2BF16 zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.F2.0F38.W0 72 /r``
``AVX512F and AVX512_BF16``
``16/32/64-bit``
"""
EVEX_VPSHRDVD_XMM_K1Z_XMM_XMMM128B32: int = 3174
"""
``VPSHRDVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 73 /r``
``AVX512VL and AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPSHRDVD_YMM_K1Z_YMM_YMMM256B32: int = 3175
"""
``VPSHRDVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 73 /r``
``AVX512VL and AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPSHRDVD_ZMM_K1Z_ZMM_ZMMM512B32: int = 3176
"""
``VPSHRDVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.66.0F38.W0 73 /r``
``AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPSHRDVQ_XMM_K1Z_XMM_XMMM128B64: int = 3177
"""
``VPSHRDVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 73 /r``
``AVX512VL and AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPSHRDVQ_YMM_K1Z_YMM_YMMM256B64: int = 3178
"""
``VPSHRDVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 73 /r``
``AVX512VL and AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPSHRDVQ_ZMM_K1Z_ZMM_ZMMM512B64: int = 3179
"""
``VPSHRDVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F38.W1 73 /r``
``AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPERMI2B_XMM_K1Z_XMM_XMMM128: int = 3180
"""
``VPERMI2B xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F38.W0 75 /r``
``AVX512VL and AVX512_VBMI``
``16/32/64-bit``
"""
EVEX_VPERMI2B_YMM_K1Z_YMM_YMMM256: int = 3181
"""
``VPERMI2B ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F38.W0 75 /r``
``AVX512VL and AVX512_VBMI``
``16/32/64-bit``
"""
EVEX_VPERMI2B_ZMM_K1Z_ZMM_ZMMM512: int = 3182
"""
``VPERMI2B zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F38.W0 75 /r``
``AVX512_VBMI``
``16/32/64-bit``
"""
EVEX_VPERMI2W_XMM_K1Z_XMM_XMMM128: int = 3183
"""
``VPERMI2W xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F38.W1 75 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPERMI2W_YMM_K1Z_YMM_YMMM256: int = 3184
"""
``VPERMI2W ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F38.W1 75 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPERMI2W_ZMM_K1Z_ZMM_ZMMM512: int = 3185
"""
``VPERMI2W zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F38.W1 75 /r``
``AVX512BW``
``16/32/64-bit``
"""
EVEX_VPERMI2D_XMM_K1Z_XMM_XMMM128B32: int = 3186
"""
``VPERMI2D xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 76 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPERMI2D_YMM_K1Z_YMM_YMMM256B32: int = 3187
"""
``VPERMI2D ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 76 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPERMI2D_ZMM_K1Z_ZMM_ZMMM512B32: int = 3188
"""
``VPERMI2D zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.66.0F38.W0 76 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPERMI2Q_XMM_K1Z_XMM_XMMM128B64: int = 3189
"""
``VPERMI2Q xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 76 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPERMI2Q_YMM_K1Z_YMM_YMMM256B64: int = 3190
"""
``VPERMI2Q ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 76 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPERMI2Q_ZMM_K1Z_ZMM_ZMMM512B64: int = 3191
"""
``VPERMI2Q zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F38.W1 76 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPERMI2PS_XMM_K1Z_XMM_XMMM128B32: int = 3192
"""
``VPERMI2PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 77 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPERMI2PS_YMM_K1Z_YMM_YMMM256B32: int = 3193
"""
``VPERMI2PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 77 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPERMI2PS_ZMM_K1Z_ZMM_ZMMM512B32: int = 3194
"""
``VPERMI2PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.66.0F38.W0 77 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPERMI2PD_XMM_K1Z_XMM_XMMM128B64: int = 3195
"""
``VPERMI2PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 77 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPERMI2PD_YMM_K1Z_YMM_YMMM256B64: int = 3196
"""
``VPERMI2PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 77 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPERMI2PD_ZMM_K1Z_ZMM_ZMMM512B64: int = 3197
"""
``VPERMI2PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F38.W1 77 /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_VPBROADCASTB_XMM_XMMM8: int = 3198
"""
``VPBROADCASTB xmm1, xmm2/m8``
``VEX.128.66.0F38.W0 78 /r``
``AVX2``
``16/32/64-bit``
"""
VEX_VPBROADCASTB_YMM_XMMM8: int = 3199
"""
``VPBROADCASTB ymm1, xmm2/m8``
``VEX.256.66.0F38.W0 78 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPBROADCASTB_XMM_K1Z_XMMM8: int = 3200
"""
``VPBROADCASTB xmm1 {k1}{z}, xmm2/m8``
``EVEX.128.66.0F38.W0 78 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPBROADCASTB_YMM_K1Z_XMMM8: int = 3201
"""
``VPBROADCASTB ymm1 {k1}{z}, xmm2/m8``
``EVEX.256.66.0F38.W0 78 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPBROADCASTB_ZMM_K1Z_XMMM8: int = 3202
"""
``VPBROADCASTB zmm1 {k1}{z}, xmm2/m8``
``EVEX.512.66.0F38.W0 78 /r``
``AVX512BW``
``16/32/64-bit``
"""
VEX_VPBROADCASTW_XMM_XMMM16: int = 3203
"""
``VPBROADCASTW xmm1, xmm2/m16``
``VEX.128.66.0F38.W0 79 /r``
``AVX2``
``16/32/64-bit``
"""
VEX_VPBROADCASTW_YMM_XMMM16: int = 3204
"""
``VPBROADCASTW ymm1, xmm2/m16``
``VEX.256.66.0F38.W0 79 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPBROADCASTW_XMM_K1Z_XMMM16: int = 3205
"""
``VPBROADCASTW xmm1 {k1}{z}, xmm2/m16``
``EVEX.128.66.0F38.W0 79 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPBROADCASTW_YMM_K1Z_XMMM16: int = 3206
"""
``VPBROADCASTW ymm1 {k1}{z}, xmm2/m16``
``EVEX.256.66.0F38.W0 79 /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPBROADCASTW_ZMM_K1Z_XMMM16: int = 3207
"""
``VPBROADCASTW zmm1 {k1}{z}, xmm2/m16``
``EVEX.512.66.0F38.W0 79 /r``
``AVX512BW``
``16/32/64-bit``
"""
EVEX_VPBROADCASTB_XMM_K1Z_R32: int = 3208
"""
``VPBROADCASTB xmm1 {k1}{z}, r32``
``EVEX.128.66.0F38.W0 7A /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPBROADCASTB_YMM_K1Z_R32: int = 3209
"""
``VPBROADCASTB ymm1 {k1}{z}, r32``
``EVEX.256.66.0F38.W0 7A /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPBROADCASTB_ZMM_K1Z_R32: int = 3210
"""
``VPBROADCASTB zmm1 {k1}{z}, r32``
``EVEX.512.66.0F38.W0 7A /r``
``AVX512BW``
``16/32/64-bit``
"""
EVEX_VPBROADCASTW_XMM_K1Z_R32: int = 3211
"""
``VPBROADCASTW xmm1 {k1}{z}, r32``
``EVEX.128.66.0F38.W0 7B /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPBROADCASTW_YMM_K1Z_R32: int = 3212
"""
``VPBROADCASTW ymm1 {k1}{z}, r32``
``EVEX.256.66.0F38.W0 7B /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPBROADCASTW_ZMM_K1Z_R32: int = 3213
"""
``VPBROADCASTW zmm1 {k1}{z}, r32``
``EVEX.512.66.0F38.W0 7B /r``
``AVX512BW``
``16/32/64-bit``
"""
EVEX_VPBROADCASTD_XMM_K1Z_R32: int = 3214
"""
``VPBROADCASTD xmm1 {k1}{z}, r32``
``EVEX.128.66.0F38.W0 7C /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPBROADCASTD_YMM_K1Z_R32: int = 3215
"""
``VPBROADCASTD ymm1 {k1}{z}, r32``
``EVEX.256.66.0F38.W0 7C /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPBROADCASTD_ZMM_K1Z_R32: int = 3216
"""
``VPBROADCASTD zmm1 {k1}{z}, r32``
``EVEX.512.66.0F38.W0 7C /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPBROADCASTQ_XMM_K1Z_R64: int = 3217
"""
``VPBROADCASTQ xmm1 {k1}{z}, r64``
``EVEX.128.66.0F38.W1 7C /r``
``AVX512VL and AVX512F``
``64-bit``
"""
EVEX_VPBROADCASTQ_YMM_K1Z_R64: int = 3218
"""
``VPBROADCASTQ ymm1 {k1}{z}, r64``
``EVEX.256.66.0F38.W1 7C /r``
``AVX512VL and AVX512F``
``64-bit``
"""
EVEX_VPBROADCASTQ_ZMM_K1Z_R64: int = 3219
"""
``VPBROADCASTQ zmm1 {k1}{z}, r64``
``EVEX.512.66.0F38.W1 7C /r``
``AVX512F``
``64-bit``
"""
EVEX_VPERMT2B_XMM_K1Z_XMM_XMMM128: int = 3220
"""
``VPERMT2B xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F38.W0 7D /r``
``AVX512VL and AVX512_VBMI``
``16/32/64-bit``
"""
EVEX_VPERMT2B_YMM_K1Z_YMM_YMMM256: int = 3221
"""
``VPERMT2B ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F38.W0 7D /r``
``AVX512VL and AVX512_VBMI``
``16/32/64-bit``
"""
EVEX_VPERMT2B_ZMM_K1Z_ZMM_ZMMM512: int = 3222
"""
``VPERMT2B zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F38.W0 7D /r``
``AVX512_VBMI``
``16/32/64-bit``
"""
EVEX_VPERMT2W_XMM_K1Z_XMM_XMMM128: int = 3223
"""
``VPERMT2W xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F38.W1 7D /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPERMT2W_YMM_K1Z_YMM_YMMM256: int = 3224
"""
``VPERMT2W ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F38.W1 7D /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPERMT2W_ZMM_K1Z_ZMM_ZMMM512: int = 3225
"""
``VPERMT2W zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F38.W1 7D /r``
``AVX512BW``
``16/32/64-bit``
"""
EVEX_VPERMT2D_XMM_K1Z_XMM_XMMM128B32: int = 3226
"""
``VPERMT2D xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 7E /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPERMT2D_YMM_K1Z_YMM_YMMM256B32: int = 3227
"""
``VPERMT2D ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 7E /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPERMT2D_ZMM_K1Z_ZMM_ZMMM512B32: int = 3228
"""
``VPERMT2D zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.66.0F38.W0 7E /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPERMT2Q_XMM_K1Z_XMM_XMMM128B64: int = 3229
"""
``VPERMT2Q xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 7E /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPERMT2Q_YMM_K1Z_YMM_YMMM256B64: int = 3230
"""
``VPERMT2Q ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 7E /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPERMT2Q_ZMM_K1Z_ZMM_ZMMM512B64: int = 3231
"""
``VPERMT2Q zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F38.W1 7E /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPERMT2PS_XMM_K1Z_XMM_XMMM128B32: int = 3232
"""
``VPERMT2PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 7F /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPERMT2PS_YMM_K1Z_YMM_YMMM256B32: int = 3233
"""
``VPERMT2PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 7F /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPERMT2PS_ZMM_K1Z_ZMM_ZMMM512B32: int = 3234
"""
``VPERMT2PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst``
``EVEX.512.66.0F38.W0 7F /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPERMT2PD_XMM_K1Z_XMM_XMMM128B64: int = 3235
"""
``VPERMT2PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 7F /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPERMT2PD_YMM_K1Z_YMM_YMMM256B64: int = 3236
"""
``VPERMT2PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 7F /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPERMT2PD_ZMM_K1Z_ZMM_ZMMM512B64: int = 3237
"""
``VPERMT2PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F38.W1 7F /r``
``AVX512F``
``16/32/64-bit``
"""
INVEPT_R32_M128: int = 3238
"""
``INVEPT r32, m128``
``66 0F 38 80 /r``
``VMX and IA32_VMX_EPT_VPID_CAP[bit 20]``
``16/32-bit``
"""
INVEPT_R64_M128: int = 3239
"""
``INVEPT r64, m128``
``66 0F 38 80 /r``
``VMX and IA32_VMX_EPT_VPID_CAP[bit 20]``
``64-bit``
"""
INVVPID_R32_M128: int = 3240
"""
``INVVPID r32, m128``
``66 0F 38 81 /r``
``VMX and IA32_VMX_EPT_VPID_CAP[bit 32]``
``16/32-bit``
"""
INVVPID_R64_M128: int = 3241
"""
``INVVPID r64, m128``
``66 0F 38 81 /r``
``VMX and IA32_VMX_EPT_VPID_CAP[bit 32]``
``64-bit``
"""
INVPCID_R32_M128: int = 3242
"""
``INVPCID r32, m128``
``66 0F 38 82 /r``
``INVPCID``
``16/32-bit``
"""
INVPCID_R64_M128: int = 3243
"""
``INVPCID r64, m128``
``66 0F 38 82 /r``
``INVPCID``
``64-bit``
"""
EVEX_VPMULTISHIFTQB_XMM_K1Z_XMM_XMMM128B64: int = 3244
"""
``VPMULTISHIFTQB xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 83 /r``
``AVX512VL and AVX512_VBMI``
``16/32/64-bit``
"""
EVEX_VPMULTISHIFTQB_YMM_K1Z_YMM_YMMM256B64: int = 3245
"""
``VPMULTISHIFTQB ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 83 /r``
``AVX512VL and AVX512_VBMI``
``16/32/64-bit``
"""
EVEX_VPMULTISHIFTQB_ZMM_K1Z_ZMM_ZMMM512B64: int = 3246
"""
``VPMULTISHIFTQB zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F38.W1 83 /r``
``AVX512_VBMI``
``16/32/64-bit``
"""
EVEX_VEXPANDPS_XMM_K1Z_XMMM128: int = 3247
"""
``VEXPANDPS xmm1 {k1}{z}, xmm2/m128``
``EVEX.128.66.0F38.W0 88 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VEXPANDPS_YMM_K1Z_YMMM256: int = 3248
"""
``VEXPANDPS ymm1 {k1}{z}, ymm2/m256``
``EVEX.256.66.0F38.W0 88 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VEXPANDPS_ZMM_K1Z_ZMMM512: int = 3249
"""
``VEXPANDPS zmm1 {k1}{z}, zmm2/m512``
``EVEX.512.66.0F38.W0 88 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VEXPANDPD_XMM_K1Z_XMMM128: int = 3250
"""
``VEXPANDPD xmm1 {k1}{z}, xmm2/m128``
``EVEX.128.66.0F38.W1 88 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VEXPANDPD_YMM_K1Z_YMMM256: int = 3251
"""
``VEXPANDPD ymm1 {k1}{z}, ymm2/m256``
``EVEX.256.66.0F38.W1 88 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VEXPANDPD_ZMM_K1Z_ZMMM512: int = 3252
"""
``VEXPANDPD zmm1 {k1}{z}, zmm2/m512``
``EVEX.512.66.0F38.W1 88 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPEXPANDD_XMM_K1Z_XMMM128: int = 3253
"""
``VPEXPANDD xmm1 {k1}{z}, xmm2/m128``
``EVEX.128.66.0F38.W0 89 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPEXPANDD_YMM_K1Z_YMMM256: int = 3254
"""
``VPEXPANDD ymm1 {k1}{z}, ymm2/m256``
``EVEX.256.66.0F38.W0 89 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPEXPANDD_ZMM_K1Z_ZMMM512: int = 3255
"""
``VPEXPANDD zmm1 {k1}{z}, zmm2/m512``
``EVEX.512.66.0F38.W0 89 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPEXPANDQ_XMM_K1Z_XMMM128: int = 3256
"""
``VPEXPANDQ xmm1 {k1}{z}, xmm2/m128``
``EVEX.128.66.0F38.W1 89 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPEXPANDQ_YMM_K1Z_YMMM256: int = 3257
"""
``VPEXPANDQ ymm1 {k1}{z}, ymm2/m256``
``EVEX.256.66.0F38.W1 89 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPEXPANDQ_ZMM_K1Z_ZMMM512: int = 3258
"""
``VPEXPANDQ zmm1 {k1}{z}, zmm2/m512``
``EVEX.512.66.0F38.W1 89 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VCOMPRESSPS_XMMM128_K1Z_XMM: int = 3259
"""
``VCOMPRESSPS xmm1/m128 {k1}{z}, xmm2``
``EVEX.128.66.0F38.W0 8A /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VCOMPRESSPS_YMMM256_K1Z_YMM: int = 3260
"""
``VCOMPRESSPS ymm1/m256 {k1}{z}, ymm2``
``EVEX.256.66.0F38.W0 8A /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VCOMPRESSPS_ZMMM512_K1Z_ZMM: int = 3261
"""
``VCOMPRESSPS zmm1/m512 {k1}{z}, zmm2``
``EVEX.512.66.0F38.W0 8A /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VCOMPRESSPD_XMMM128_K1Z_XMM: int = 3262
"""
``VCOMPRESSPD xmm1/m128 {k1}{z}, xmm2``
``EVEX.128.66.0F38.W1 8A /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VCOMPRESSPD_YMMM256_K1Z_YMM: int = 3263
"""
``VCOMPRESSPD ymm1/m256 {k1}{z}, ymm2``
``EVEX.256.66.0F38.W1 8A /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VCOMPRESSPD_ZMMM512_K1Z_ZMM: int = 3264
"""
``VCOMPRESSPD zmm1/m512 {k1}{z}, zmm2``
``EVEX.512.66.0F38.W1 8A /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPCOMPRESSD_XMMM128_K1Z_XMM: int = 3265
"""
``VPCOMPRESSD xmm1/m128 {k1}{z}, xmm2``
``EVEX.128.66.0F38.W0 8B /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPCOMPRESSD_YMMM256_K1Z_YMM: int = 3266
"""
``VPCOMPRESSD ymm1/m256 {k1}{z}, ymm2``
``EVEX.256.66.0F38.W0 8B /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPCOMPRESSD_ZMMM512_K1Z_ZMM: int = 3267
"""
``VPCOMPRESSD zmm1/m512 {k1}{z}, zmm2``
``EVEX.512.66.0F38.W0 8B /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPCOMPRESSQ_XMMM128_K1Z_XMM: int = 3268
"""
``VPCOMPRESSQ xmm1/m128 {k1}{z}, xmm2``
``EVEX.128.66.0F38.W1 8B /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPCOMPRESSQ_YMMM256_K1Z_YMM: int = 3269
"""
``VPCOMPRESSQ ymm1/m256 {k1}{z}, ymm2``
``EVEX.256.66.0F38.W1 8B /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPCOMPRESSQ_ZMMM512_K1Z_ZMM: int = 3270
"""
``VPCOMPRESSQ zmm1/m512 {k1}{z}, zmm2``
``EVEX.512.66.0F38.W1 8B /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_VPMASKMOVD_XMM_XMM_M128: int = 3271
"""
``VPMASKMOVD xmm1, xmm2, m128``
``VEX.128.66.0F38.W0 8C /r``
``AVX2``
``16/32/64-bit``
"""
VEX_VPMASKMOVD_YMM_YMM_M256: int = 3272
"""
``VPMASKMOVD ymm1, ymm2, m256``
``VEX.256.66.0F38.W0 8C /r``
``AVX2``
``16/32/64-bit``
"""
VEX_VPMASKMOVQ_XMM_XMM_M128: int = 3273
"""
``VPMASKMOVQ xmm1, xmm2, m128``
``VEX.128.66.0F38.W1 8C /r``
``AVX2``
``16/32/64-bit``
"""
VEX_VPMASKMOVQ_YMM_YMM_M256: int = 3274
"""
``VPMASKMOVQ ymm1, ymm2, m256``
``VEX.256.66.0F38.W1 8C /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPERMB_XMM_K1Z_XMM_XMMM128: int = 3275
"""
``VPERMB xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F38.W0 8D /r``
``AVX512VL and AVX512_VBMI``
``16/32/64-bit``
"""
EVEX_VPERMB_YMM_K1Z_YMM_YMMM256: int = 3276
"""
``VPERMB ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F38.W0 8D /r``
``AVX512VL and AVX512_VBMI``
``16/32/64-bit``
"""
EVEX_VPERMB_ZMM_K1Z_ZMM_ZMMM512: int = 3277
"""
``VPERMB zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F38.W0 8D /r``
``AVX512_VBMI``
``16/32/64-bit``
"""
EVEX_VPERMW_XMM_K1Z_XMM_XMMM128: int = 3278
"""
``VPERMW xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F38.W1 8D /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPERMW_YMM_K1Z_YMM_YMMM256: int = 3279
"""
``VPERMW ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F38.W1 8D /r``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPERMW_ZMM_K1Z_ZMM_ZMMM512: int = 3280
"""
``VPERMW zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F38.W1 8D /r``
``AVX512BW``
``16/32/64-bit``
"""
VEX_VPMASKMOVD_M128_XMM_XMM: int = 3281
"""
``VPMASKMOVD m128, xmm1, xmm2``
``VEX.128.66.0F38.W0 8E /r``
``AVX2``
``16/32/64-bit``
"""
VEX_VPMASKMOVD_M256_YMM_YMM: int = 3282
"""
``VPMASKMOVD m256, ymm1, ymm2``
``VEX.256.66.0F38.W0 8E /r``
``AVX2``
``16/32/64-bit``
"""
VEX_VPMASKMOVQ_M128_XMM_XMM: int = 3283
"""
``VPMASKMOVQ m128, xmm1, xmm2``
``VEX.128.66.0F38.W1 8E /r``
``AVX2``
``16/32/64-bit``
"""
VEX_VPMASKMOVQ_M256_YMM_YMM: int = 3284
"""
``VPMASKMOVQ m256, ymm1, ymm2``
``VEX.256.66.0F38.W1 8E /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPSHUFBITQMB_KR_K1_XMM_XMMM128: int = 3285
"""
``VPSHUFBITQMB k1 {k2}, xmm2, xmm3/m128``
``EVEX.128.66.0F38.W0 8F /r``
``AVX512VL and AVX512_BITALG``
``16/32/64-bit``
"""
EVEX_VPSHUFBITQMB_KR_K1_YMM_YMMM256: int = 3286
"""
``VPSHUFBITQMB k1 {k2}, ymm2, ymm3/m256``
``EVEX.256.66.0F38.W0 8F /r``
``AVX512VL and AVX512_BITALG``
``16/32/64-bit``
"""
EVEX_VPSHUFBITQMB_KR_K1_ZMM_ZMMM512: int = 3287
"""
``VPSHUFBITQMB k1 {k2}, zmm2, zmm3/m512``
``EVEX.512.66.0F38.W0 8F /r``
``AVX512_BITALG``
``16/32/64-bit``
"""
VEX_VPGATHERDD_XMM_VM32X_XMM: int = 3288
"""
``VPGATHERDD xmm1, vm32x, xmm2``
``VEX.128.66.0F38.W0 90 /r``
``AVX2``
``16/32/64-bit``
"""
VEX_VPGATHERDD_YMM_VM32Y_YMM: int = 3289
"""
``VPGATHERDD ymm1, vm32y, ymm2``
``VEX.256.66.0F38.W0 90 /r``
``AVX2``
``16/32/64-bit``
"""
VEX_VPGATHERDQ_XMM_VM32X_XMM: int = 3290
"""
``VPGATHERDQ xmm1, vm32x, xmm2``
``VEX.128.66.0F38.W1 90 /r``
``AVX2``
``16/32/64-bit``
"""
VEX_VPGATHERDQ_YMM_VM32X_YMM: int = 3291
"""
``VPGATHERDQ ymm1, vm32x, ymm2``
``VEX.256.66.0F38.W1 90 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPGATHERDD_XMM_K1_VM32X: int = 3292
"""
``VPGATHERDD xmm1 {k1}, vm32x``
``EVEX.128.66.0F38.W0 90 /vsib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPGATHERDD_YMM_K1_VM32Y: int = 3293
"""
``VPGATHERDD ymm1 {k1}, vm32y``
``EVEX.256.66.0F38.W0 90 /vsib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPGATHERDD_ZMM_K1_VM32Z: int = 3294
"""
``VPGATHERDD zmm1 {k1}, vm32z``
``EVEX.512.66.0F38.W0 90 /vsib``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPGATHERDQ_XMM_K1_VM32X: int = 3295
"""
``VPGATHERDQ xmm1 {k1}, vm32x``
``EVEX.128.66.0F38.W1 90 /vsib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPGATHERDQ_YMM_K1_VM32X: int = 3296
"""
``VPGATHERDQ ymm1 {k1}, vm32x``
``EVEX.256.66.0F38.W1 90 /vsib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPGATHERDQ_ZMM_K1_VM32Y: int = 3297
"""
``VPGATHERDQ zmm1 {k1}, vm32y``
``EVEX.512.66.0F38.W1 90 /vsib``
``AVX512F``
``16/32/64-bit``
"""
VEX_VPGATHERQD_XMM_VM64X_XMM: int = 3298
"""
``VPGATHERQD xmm1, vm64x, xmm2``
``VEX.128.66.0F38.W0 91 /r``
``AVX2``
``16/32/64-bit``
"""
VEX_VPGATHERQD_XMM_VM64Y_XMM: int = 3299
"""
``VPGATHERQD xmm1, vm64y, xmm2``
``VEX.256.66.0F38.W0 91 /r``
``AVX2``
``16/32/64-bit``
"""
VEX_VPGATHERQQ_XMM_VM64X_XMM: int = 3300
"""
``VPGATHERQQ xmm1, vm64x, xmm2``
``VEX.128.66.0F38.W1 91 /r``
``AVX2``
``16/32/64-bit``
"""
VEX_VPGATHERQQ_YMM_VM64Y_YMM: int = 3301
"""
``VPGATHERQQ ymm1, vm64y, ymm2``
``VEX.256.66.0F38.W1 91 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPGATHERQD_XMM_K1_VM64X: int = 3302
"""
``VPGATHERQD xmm1 {k1}, vm64x``
``EVEX.128.66.0F38.W0 91 /vsib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPGATHERQD_XMM_K1_VM64Y: int = 3303
"""
``VPGATHERQD xmm1 {k1}, vm64y``
``EVEX.256.66.0F38.W0 91 /vsib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPGATHERQD_YMM_K1_VM64Z: int = 3304
"""
``VPGATHERQD ymm1 {k1}, vm64z``
``EVEX.512.66.0F38.W0 91 /vsib``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPGATHERQQ_XMM_K1_VM64X: int = 3305
"""
``VPGATHERQQ xmm1 {k1}, vm64x``
``EVEX.128.66.0F38.W1 91 /vsib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPGATHERQQ_YMM_K1_VM64Y: int = 3306
"""
``VPGATHERQQ ymm1 {k1}, vm64y``
``EVEX.256.66.0F38.W1 91 /vsib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPGATHERQQ_ZMM_K1_VM64Z: int = 3307
"""
``VPGATHERQQ zmm1 {k1}, vm64z``
``EVEX.512.66.0F38.W1 91 /vsib``
``AVX512F``
``16/32/64-bit``
"""
VEX_VGATHERDPS_XMM_VM32X_XMM: int = 3308
"""
``VGATHERDPS xmm1, vm32x, xmm2``
``VEX.128.66.0F38.W0 92 /r``
``AVX2``
``16/32/64-bit``
"""
VEX_VGATHERDPS_YMM_VM32Y_YMM: int = 3309
"""
``VGATHERDPS ymm1, vm32y, ymm2``
``VEX.256.66.0F38.W0 92 /r``
``AVX2``
``16/32/64-bit``
"""
VEX_VGATHERDPD_XMM_VM32X_XMM: int = 3310
"""
``VGATHERDPD xmm1, vm32x, xmm2``
``VEX.128.66.0F38.W1 92 /r``
``AVX2``
``16/32/64-bit``
"""
VEX_VGATHERDPD_YMM_VM32X_YMM: int = 3311
"""
``VGATHERDPD ymm1, vm32x, ymm2``
``VEX.256.66.0F38.W1 92 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VGATHERDPS_XMM_K1_VM32X: int = 3312
"""
``VGATHERDPS xmm1 {k1}, vm32x``
``EVEX.128.66.0F38.W0 92 /vsib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VGATHERDPS_YMM_K1_VM32Y: int = 3313
"""
``VGATHERDPS ymm1 {k1}, vm32y``
``EVEX.256.66.0F38.W0 92 /vsib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VGATHERDPS_ZMM_K1_VM32Z: int = 3314
"""
``VGATHERDPS zmm1 {k1}, vm32z``
``EVEX.512.66.0F38.W0 92 /vsib``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VGATHERDPD_XMM_K1_VM32X: int = 3315
"""
``VGATHERDPD xmm1 {k1}, vm32x``
``EVEX.128.66.0F38.W1 92 /vsib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VGATHERDPD_YMM_K1_VM32X: int = 3316
"""
``VGATHERDPD ymm1 {k1}, vm32x``
``EVEX.256.66.0F38.W1 92 /vsib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VGATHERDPD_ZMM_K1_VM32Y: int = 3317
"""
``VGATHERDPD zmm1 {k1}, vm32y``
``EVEX.512.66.0F38.W1 92 /vsib``
``AVX512F``
``16/32/64-bit``
"""
VEX_VGATHERQPS_XMM_VM64X_XMM: int = 3318
"""
``VGATHERQPS xmm1, vm64x, xmm2``
``VEX.128.66.0F38.W0 93 /r``
``AVX2``
``16/32/64-bit``
"""
VEX_VGATHERQPS_XMM_VM64Y_XMM: int = 3319
"""
``VGATHERQPS xmm1, vm64y, xmm2``
``VEX.256.66.0F38.W0 93 /r``
``AVX2``
``16/32/64-bit``
"""
VEX_VGATHERQPD_XMM_VM64X_XMM: int = 3320
"""
``VGATHERQPD xmm1, vm64x, xmm2``
``VEX.128.66.0F38.W1 93 /r``
``AVX2``
``16/32/64-bit``
"""
VEX_VGATHERQPD_YMM_VM64Y_YMM: int = 3321
"""
``VGATHERQPD ymm1, vm64y, ymm2``
``VEX.256.66.0F38.W1 93 /r``
``AVX2``
``16/32/64-bit``
"""
EVEX_VGATHERQPS_XMM_K1_VM64X: int = 3322
"""
``VGATHERQPS xmm1 {k1}, vm64x``
``EVEX.128.66.0F38.W0 93 /vsib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VGATHERQPS_XMM_K1_VM64Y: int = 3323
"""
``VGATHERQPS xmm1 {k1}, vm64y``
``EVEX.256.66.0F38.W0 93 /vsib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VGATHERQPS_YMM_K1_VM64Z: int = 3324
"""
``VGATHERQPS ymm1 {k1}, vm64z``
``EVEX.512.66.0F38.W0 93 /vsib``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VGATHERQPD_XMM_K1_VM64X: int = 3325
"""
``VGATHERQPD xmm1 {k1}, vm64x``
``EVEX.128.66.0F38.W1 93 /vsib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VGATHERQPD_YMM_K1_VM64Y: int = 3326
"""
``VGATHERQPD ymm1 {k1}, vm64y``
``EVEX.256.66.0F38.W1 93 /vsib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VGATHERQPD_ZMM_K1_VM64Z: int = 3327
"""
``VGATHERQPD zmm1 {k1}, vm64z``
``EVEX.512.66.0F38.W1 93 /vsib``
``AVX512F``
``16/32/64-bit``
"""
VEX_VFMADDSUB132PS_XMM_XMM_XMMM128: int = 3328
"""
``VFMADDSUB132PS xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W0 96 /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFMADDSUB132PS_YMM_YMM_YMMM256: int = 3329
"""
``VFMADDSUB132PS ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W0 96 /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFMADDSUB132PD_XMM_XMM_XMMM128: int = 3330
"""
``VFMADDSUB132PD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W1 96 /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFMADDSUB132PD_YMM_YMM_YMMM256: int = 3331
"""
``VFMADDSUB132PD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W1 96 /r``
``FMA``
``16/32/64-bit``
"""
EVEX_VFMADDSUB132PS_XMM_K1Z_XMM_XMMM128B32: int = 3332
"""
``VFMADDSUB132PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 96 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMADDSUB132PS_YMM_K1Z_YMM_YMMM256B32: int = 3333
"""
``VFMADDSUB132PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 96 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMADDSUB132PS_ZMM_K1Z_ZMM_ZMMM512B32_ER: int = 3334
"""
``VFMADDSUB132PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}``
``EVEX.512.66.0F38.W0 96 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VFMADDSUB132PD_XMM_K1Z_XMM_XMMM128B64: int = 3335
"""
``VFMADDSUB132PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 96 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMADDSUB132PD_YMM_K1Z_YMM_YMMM256B64: int = 3336
"""
``VFMADDSUB132PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 96 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMADDSUB132PD_ZMM_K1Z_ZMM_ZMMM512B64_ER: int = 3337
"""
``VFMADDSUB132PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}``
``EVEX.512.66.0F38.W1 96 /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_VFMSUBADD132PS_XMM_XMM_XMMM128: int = 3338
"""
``VFMSUBADD132PS xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W0 97 /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFMSUBADD132PS_YMM_YMM_YMMM256: int = 3339
"""
``VFMSUBADD132PS ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W0 97 /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFMSUBADD132PD_XMM_XMM_XMMM128: int = 3340
"""
``VFMSUBADD132PD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W1 97 /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFMSUBADD132PD_YMM_YMM_YMMM256: int = 3341
"""
``VFMSUBADD132PD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W1 97 /r``
``FMA``
``16/32/64-bit``
"""
EVEX_VFMSUBADD132PS_XMM_K1Z_XMM_XMMM128B32: int = 3342
"""
``VFMSUBADD132PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 97 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMSUBADD132PS_YMM_K1Z_YMM_YMMM256B32: int = 3343
"""
``VFMSUBADD132PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 97 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMSUBADD132PS_ZMM_K1Z_ZMM_ZMMM512B32_ER: int = 3344
"""
``VFMSUBADD132PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}``
``EVEX.512.66.0F38.W0 97 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VFMSUBADD132PD_XMM_K1Z_XMM_XMMM128B64: int = 3345
"""
``VFMSUBADD132PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 97 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMSUBADD132PD_YMM_K1Z_YMM_YMMM256B64: int = 3346
"""
``VFMSUBADD132PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 97 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMSUBADD132PD_ZMM_K1Z_ZMM_ZMMM512B64_ER: int = 3347
"""
``VFMSUBADD132PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}``
``EVEX.512.66.0F38.W1 97 /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_VFMADD132PS_XMM_XMM_XMMM128: int = 3348
"""
``VFMADD132PS xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W0 98 /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFMADD132PS_YMM_YMM_YMMM256: int = 3349
"""
``VFMADD132PS ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W0 98 /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFMADD132PD_XMM_XMM_XMMM128: int = 3350
"""
``VFMADD132PD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W1 98 /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFMADD132PD_YMM_YMM_YMMM256: int = 3351
"""
``VFMADD132PD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W1 98 /r``
``FMA``
``16/32/64-bit``
"""
EVEX_VFMADD132PS_XMM_K1Z_XMM_XMMM128B32: int = 3352
"""
``VFMADD132PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 98 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMADD132PS_YMM_K1Z_YMM_YMMM256B32: int = 3353
"""
``VFMADD132PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 98 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMADD132PS_ZMM_K1Z_ZMM_ZMMM512B32_ER: int = 3354
"""
``VFMADD132PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}``
``EVEX.512.66.0F38.W0 98 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VFMADD132PD_XMM_K1Z_XMM_XMMM128B64: int = 3355
"""
``VFMADD132PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 98 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMADD132PD_YMM_K1Z_YMM_YMMM256B64: int = 3356
"""
``VFMADD132PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 98 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMADD132PD_ZMM_K1Z_ZMM_ZMMM512B64_ER: int = 3357
"""
``VFMADD132PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}``
``EVEX.512.66.0F38.W1 98 /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_VFMADD132SS_XMM_XMM_XMMM32: int = 3358
"""
``VFMADD132SS xmm1, xmm2, xmm3/m32``
``VEX.LIG.66.0F38.W0 99 /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFMADD132SD_XMM_XMM_XMMM64: int = 3359
"""
``VFMADD132SD xmm1, xmm2, xmm3/m64``
``VEX.LIG.66.0F38.W1 99 /r``
``FMA``
``16/32/64-bit``
"""
EVEX_VFMADD132SS_XMM_K1Z_XMM_XMMM32_ER: int = 3360
"""
``VFMADD132SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}``
``EVEX.LIG.66.0F38.W0 99 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VFMADD132SD_XMM_K1Z_XMM_XMMM64_ER: int = 3361
"""
``VFMADD132SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}``
``EVEX.LIG.66.0F38.W1 99 /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_VFMSUB132PS_XMM_XMM_XMMM128: int = 3362
"""
``VFMSUB132PS xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W0 9A /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFMSUB132PS_YMM_YMM_YMMM256: int = 3363
"""
``VFMSUB132PS ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W0 9A /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFMSUB132PD_XMM_XMM_XMMM128: int = 3364
"""
``VFMSUB132PD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W1 9A /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFMSUB132PD_YMM_YMM_YMMM256: int = 3365
"""
``VFMSUB132PD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W1 9A /r``
``FMA``
``16/32/64-bit``
"""
EVEX_VFMSUB132PS_XMM_K1Z_XMM_XMMM128B32: int = 3366
"""
``VFMSUB132PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 9A /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMSUB132PS_YMM_K1Z_YMM_YMMM256B32: int = 3367
"""
``VFMSUB132PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 9A /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMSUB132PS_ZMM_K1Z_ZMM_ZMMM512B32_ER: int = 3368
"""
``VFMSUB132PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}``
``EVEX.512.66.0F38.W0 9A /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VFMSUB132PD_XMM_K1Z_XMM_XMMM128B64: int = 3369
"""
``VFMSUB132PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 9A /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMSUB132PD_YMM_K1Z_YMM_YMMM256B64: int = 3370
"""
``VFMSUB132PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 9A /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMSUB132PD_ZMM_K1Z_ZMM_ZMMM512B64_ER: int = 3371
"""
``VFMSUB132PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}``
``EVEX.512.66.0F38.W1 9A /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_V4FMADDPS_ZMM_K1Z_ZMMP3_M128: int = 3372
"""
``V4FMADDPS zmm1 {k1}{z}, zmm2+3, m128``
``EVEX.512.F2.0F38.W0 9A /r``
``AVX512_4FMAPS``
``16/32/64-bit``
"""
VEX_VFMSUB132SS_XMM_XMM_XMMM32: int = 3373
"""
``VFMSUB132SS xmm1, xmm2, xmm3/m32``
``VEX.LIG.66.0F38.W0 9B /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFMSUB132SD_XMM_XMM_XMMM64: int = 3374
"""
``VFMSUB132SD xmm1, xmm2, xmm3/m64``
``VEX.LIG.66.0F38.W1 9B /r``
``FMA``
``16/32/64-bit``
"""
EVEX_VFMSUB132SS_XMM_K1Z_XMM_XMMM32_ER: int = 3375
"""
``VFMSUB132SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}``
``EVEX.LIG.66.0F38.W0 9B /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VFMSUB132SD_XMM_K1Z_XMM_XMMM64_ER: int = 3376
"""
``VFMSUB132SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}``
``EVEX.LIG.66.0F38.W1 9B /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_V4FMADDSS_XMM_K1Z_XMMP3_M128: int = 3377
"""
``V4FMADDSS xmm1 {k1}{z}, xmm2+3, m128``
``EVEX.LIG.F2.0F38.W0 9B /r``
``AVX512_4FMAPS``
``16/32/64-bit``
"""
VEX_VFNMADD132PS_XMM_XMM_XMMM128: int = 3378
"""
``VFNMADD132PS xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W0 9C /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFNMADD132PS_YMM_YMM_YMMM256: int = 3379
"""
``VFNMADD132PS ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W0 9C /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFNMADD132PD_XMM_XMM_XMMM128: int = 3380
"""
``VFNMADD132PD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W1 9C /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFNMADD132PD_YMM_YMM_YMMM256: int = 3381
"""
``VFNMADD132PD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W1 9C /r``
``FMA``
``16/32/64-bit``
"""
EVEX_VFNMADD132PS_XMM_K1Z_XMM_XMMM128B32: int = 3382
"""
``VFNMADD132PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 9C /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFNMADD132PS_YMM_K1Z_YMM_YMMM256B32: int = 3383
"""
``VFNMADD132PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 9C /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFNMADD132PS_ZMM_K1Z_ZMM_ZMMM512B32_ER: int = 3384
"""
``VFNMADD132PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}``
``EVEX.512.66.0F38.W0 9C /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VFNMADD132PD_XMM_K1Z_XMM_XMMM128B64: int = 3385
"""
``VFNMADD132PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 9C /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFNMADD132PD_YMM_K1Z_YMM_YMMM256B64: int = 3386
"""
``VFNMADD132PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 9C /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFNMADD132PD_ZMM_K1Z_ZMM_ZMMM512B64_ER: int = 3387
"""
``VFNMADD132PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}``
``EVEX.512.66.0F38.W1 9C /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_VFNMADD132SS_XMM_XMM_XMMM32: int = 3388
"""
``VFNMADD132SS xmm1, xmm2, xmm3/m32``
``VEX.LIG.66.0F38.W0 9D /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFNMADD132SD_XMM_XMM_XMMM64: int = 3389
"""
``VFNMADD132SD xmm1, xmm2, xmm3/m64``
``VEX.LIG.66.0F38.W1 9D /r``
``FMA``
``16/32/64-bit``
"""
EVEX_VFNMADD132SS_XMM_K1Z_XMM_XMMM32_ER: int = 3390
"""
``VFNMADD132SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}``
``EVEX.LIG.66.0F38.W0 9D /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VFNMADD132SD_XMM_K1Z_XMM_XMMM64_ER: int = 3391
"""
``VFNMADD132SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}``
``EVEX.LIG.66.0F38.W1 9D /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_VFNMSUB132PS_XMM_XMM_XMMM128: int = 3392
"""
``VFNMSUB132PS xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W0 9E /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFNMSUB132PS_YMM_YMM_YMMM256: int = 3393
"""
``VFNMSUB132PS ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W0 9E /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFNMSUB132PD_XMM_XMM_XMMM128: int = 3394
"""
``VFNMSUB132PD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W1 9E /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFNMSUB132PD_YMM_YMM_YMMM256: int = 3395
"""
``VFNMSUB132PD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W1 9E /r``
``FMA``
``16/32/64-bit``
"""
EVEX_VFNMSUB132PS_XMM_K1Z_XMM_XMMM128B32: int = 3396
"""
``VFNMSUB132PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 9E /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFNMSUB132PS_YMM_K1Z_YMM_YMMM256B32: int = 3397
"""
``VFNMSUB132PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 9E /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFNMSUB132PS_ZMM_K1Z_ZMM_ZMMM512B32_ER: int = 3398
"""
``VFNMSUB132PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}``
``EVEX.512.66.0F38.W0 9E /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VFNMSUB132PD_XMM_K1Z_XMM_XMMM128B64: int = 3399
"""
``VFNMSUB132PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 9E /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFNMSUB132PD_YMM_K1Z_YMM_YMMM256B64: int = 3400
"""
``VFNMSUB132PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 9E /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFNMSUB132PD_ZMM_K1Z_ZMM_ZMMM512B64_ER: int = 3401
"""
``VFNMSUB132PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}``
``EVEX.512.66.0F38.W1 9E /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_VFNMSUB132SS_XMM_XMM_XMMM32: int = 3402
"""
``VFNMSUB132SS xmm1, xmm2, xmm3/m32``
``VEX.LIG.66.0F38.W0 9F /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFNMSUB132SD_XMM_XMM_XMMM64: int = 3403
"""
``VFNMSUB132SD xmm1, xmm2, xmm3/m64``
``VEX.LIG.66.0F38.W1 9F /r``
``FMA``
``16/32/64-bit``
"""
EVEX_VFNMSUB132SS_XMM_K1Z_XMM_XMMM32_ER: int = 3404
"""
``VFNMSUB132SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}``
``EVEX.LIG.66.0F38.W0 9F /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VFNMSUB132SD_XMM_K1Z_XMM_XMMM64_ER: int = 3405
"""
``VFNMSUB132SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}``
``EVEX.LIG.66.0F38.W1 9F /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPSCATTERDD_VM32X_K1_XMM: int = 3406
"""
``VPSCATTERDD vm32x {k1}, xmm1``
``EVEX.128.66.0F38.W0 A0 /vsib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSCATTERDD_VM32Y_K1_YMM: int = 3407
"""
``VPSCATTERDD vm32y {k1}, ymm1``
``EVEX.256.66.0F38.W0 A0 /vsib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSCATTERDD_VM32Z_K1_ZMM: int = 3408
"""
``VPSCATTERDD vm32z {k1}, zmm1``
``EVEX.512.66.0F38.W0 A0 /vsib``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPSCATTERDQ_VM32X_K1_XMM: int = 3409
"""
``VPSCATTERDQ vm32x {k1}, xmm1``
``EVEX.128.66.0F38.W1 A0 /vsib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSCATTERDQ_VM32X_K1_YMM: int = 3410
"""
``VPSCATTERDQ vm32x {k1}, ymm1``
``EVEX.256.66.0F38.W1 A0 /vsib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSCATTERDQ_VM32Y_K1_ZMM: int = 3411
"""
``VPSCATTERDQ vm32y {k1}, zmm1``
``EVEX.512.66.0F38.W1 A0 /vsib``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPSCATTERQD_VM64X_K1_XMM: int = 3412
"""
``VPSCATTERQD vm64x {k1}, xmm1``
``EVEX.128.66.0F38.W0 A1 /vsib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSCATTERQD_VM64Y_K1_XMM: int = 3413
"""
``VPSCATTERQD vm64y {k1}, xmm1``
``EVEX.256.66.0F38.W0 A1 /vsib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSCATTERQD_VM64Z_K1_YMM: int = 3414
"""
``VPSCATTERQD vm64z {k1}, ymm1``
``EVEX.512.66.0F38.W0 A1 /vsib``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPSCATTERQQ_VM64X_K1_XMM: int = 3415
"""
``VPSCATTERQQ vm64x {k1}, xmm1``
``EVEX.128.66.0F38.W1 A1 /vsib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSCATTERQQ_VM64Y_K1_YMM: int = 3416
"""
``VPSCATTERQQ vm64y {k1}, ymm1``
``EVEX.256.66.0F38.W1 A1 /vsib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPSCATTERQQ_VM64Z_K1_ZMM: int = 3417
"""
``VPSCATTERQQ vm64z {k1}, zmm1``
``EVEX.512.66.0F38.W1 A1 /vsib``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VSCATTERDPS_VM32X_K1_XMM: int = 3418
"""
``VSCATTERDPS vm32x {k1}, xmm1``
``EVEX.128.66.0F38.W0 A2 /vsib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VSCATTERDPS_VM32Y_K1_YMM: int = 3419
"""
``VSCATTERDPS vm32y {k1}, ymm1``
``EVEX.256.66.0F38.W0 A2 /vsib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VSCATTERDPS_VM32Z_K1_ZMM: int = 3420
"""
``VSCATTERDPS vm32z {k1}, zmm1``
``EVEX.512.66.0F38.W0 A2 /vsib``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VSCATTERDPD_VM32X_K1_XMM: int = 3421
"""
``VSCATTERDPD vm32x {k1}, xmm1``
``EVEX.128.66.0F38.W1 A2 /vsib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VSCATTERDPD_VM32X_K1_YMM: int = 3422
"""
``VSCATTERDPD vm32x {k1}, ymm1``
``EVEX.256.66.0F38.W1 A2 /vsib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VSCATTERDPD_VM32Y_K1_ZMM: int = 3423
"""
``VSCATTERDPD vm32y {k1}, zmm1``
``EVEX.512.66.0F38.W1 A2 /vsib``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VSCATTERQPS_VM64X_K1_XMM: int = 3424
"""
``VSCATTERQPS vm64x {k1}, xmm1``
``EVEX.128.66.0F38.W0 A3 /vsib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VSCATTERQPS_VM64Y_K1_XMM: int = 3425
"""
``VSCATTERQPS vm64y {k1}, xmm1``
``EVEX.256.66.0F38.W0 A3 /vsib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VSCATTERQPS_VM64Z_K1_YMM: int = 3426
"""
``VSCATTERQPS vm64z {k1}, ymm1``
``EVEX.512.66.0F38.W0 A3 /vsib``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VSCATTERQPD_VM64X_K1_XMM: int = 3427
"""
``VSCATTERQPD vm64x {k1}, xmm1``
``EVEX.128.66.0F38.W1 A3 /vsib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VSCATTERQPD_VM64Y_K1_YMM: int = 3428
"""
``VSCATTERQPD vm64y {k1}, ymm1``
``EVEX.256.66.0F38.W1 A3 /vsib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VSCATTERQPD_VM64Z_K1_ZMM: int = 3429
"""
``VSCATTERQPD vm64z {k1}, zmm1``
``EVEX.512.66.0F38.W1 A3 /vsib``
``AVX512F``
``16/32/64-bit``
"""
VEX_VFMADDSUB213PS_XMM_XMM_XMMM128: int = 3430
"""
``VFMADDSUB213PS xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W0 A6 /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFMADDSUB213PS_YMM_YMM_YMMM256: int = 3431
"""
``VFMADDSUB213PS ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W0 A6 /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFMADDSUB213PD_XMM_XMM_XMMM128: int = 3432
"""
``VFMADDSUB213PD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W1 A6 /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFMADDSUB213PD_YMM_YMM_YMMM256: int = 3433
"""
``VFMADDSUB213PD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W1 A6 /r``
``FMA``
``16/32/64-bit``
"""
EVEX_VFMADDSUB213PS_XMM_K1Z_XMM_XMMM128B32: int = 3434
"""
``VFMADDSUB213PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 A6 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMADDSUB213PS_YMM_K1Z_YMM_YMMM256B32: int = 3435
"""
``VFMADDSUB213PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 A6 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMADDSUB213PS_ZMM_K1Z_ZMM_ZMMM512B32_ER: int = 3436
"""
``VFMADDSUB213PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}``
``EVEX.512.66.0F38.W0 A6 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VFMADDSUB213PD_XMM_K1Z_XMM_XMMM128B64: int = 3437
"""
``VFMADDSUB213PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 A6 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMADDSUB213PD_YMM_K1Z_YMM_YMMM256B64: int = 3438
"""
``VFMADDSUB213PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 A6 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMADDSUB213PD_ZMM_K1Z_ZMM_ZMMM512B64_ER: int = 3439
"""
``VFMADDSUB213PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}``
``EVEX.512.66.0F38.W1 A6 /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_VFMSUBADD213PS_XMM_XMM_XMMM128: int = 3440
"""
``VFMSUBADD213PS xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W0 A7 /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFMSUBADD213PS_YMM_YMM_YMMM256: int = 3441
"""
``VFMSUBADD213PS ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W0 A7 /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFMSUBADD213PD_XMM_XMM_XMMM128: int = 3442
"""
``VFMSUBADD213PD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W1 A7 /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFMSUBADD213PD_YMM_YMM_YMMM256: int = 3443
"""
``VFMSUBADD213PD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W1 A7 /r``
``FMA``
``16/32/64-bit``
"""
EVEX_VFMSUBADD213PS_XMM_K1Z_XMM_XMMM128B32: int = 3444
"""
``VFMSUBADD213PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 A7 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMSUBADD213PS_YMM_K1Z_YMM_YMMM256B32: int = 3445
"""
``VFMSUBADD213PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 A7 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMSUBADD213PS_ZMM_K1Z_ZMM_ZMMM512B32_ER: int = 3446
"""
``VFMSUBADD213PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}``
``EVEX.512.66.0F38.W0 A7 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VFMSUBADD213PD_XMM_K1Z_XMM_XMMM128B64: int = 3447
"""
``VFMSUBADD213PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 A7 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMSUBADD213PD_YMM_K1Z_YMM_YMMM256B64: int = 3448
"""
``VFMSUBADD213PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 A7 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMSUBADD213PD_ZMM_K1Z_ZMM_ZMMM512B64_ER: int = 3449
"""
``VFMSUBADD213PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}``
``EVEX.512.66.0F38.W1 A7 /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_VFMADD213PS_XMM_XMM_XMMM128: int = 3450
"""
``VFMADD213PS xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W0 A8 /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFMADD213PS_YMM_YMM_YMMM256: int = 3451
"""
``VFMADD213PS ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W0 A8 /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFMADD213PD_XMM_XMM_XMMM128: int = 3452
"""
``VFMADD213PD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W1 A8 /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFMADD213PD_YMM_YMM_YMMM256: int = 3453
"""
``VFMADD213PD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W1 A8 /r``
``FMA``
``16/32/64-bit``
"""
EVEX_VFMADD213PS_XMM_K1Z_XMM_XMMM128B32: int = 3454
"""
``VFMADD213PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 A8 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMADD213PS_YMM_K1Z_YMM_YMMM256B32: int = 3455
"""
``VFMADD213PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 A8 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMADD213PS_ZMM_K1Z_ZMM_ZMMM512B32_ER: int = 3456
"""
``VFMADD213PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}``
``EVEX.512.66.0F38.W0 A8 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VFMADD213PD_XMM_K1Z_XMM_XMMM128B64: int = 3457
"""
``VFMADD213PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 A8 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMADD213PD_YMM_K1Z_YMM_YMMM256B64: int = 3458
"""
``VFMADD213PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 A8 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMADD213PD_ZMM_K1Z_ZMM_ZMMM512B64_ER: int = 3459
"""
``VFMADD213PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}``
``EVEX.512.66.0F38.W1 A8 /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_VFMADD213SS_XMM_XMM_XMMM32: int = 3460
"""
``VFMADD213SS xmm1, xmm2, xmm3/m32``
``VEX.LIG.66.0F38.W0 A9 /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFMADD213SD_XMM_XMM_XMMM64: int = 3461
"""
``VFMADD213SD xmm1, xmm2, xmm3/m64``
``VEX.LIG.66.0F38.W1 A9 /r``
``FMA``
``16/32/64-bit``
"""
EVEX_VFMADD213SS_XMM_K1Z_XMM_XMMM32_ER: int = 3462
"""
``VFMADD213SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}``
``EVEX.LIG.66.0F38.W0 A9 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VFMADD213SD_XMM_K1Z_XMM_XMMM64_ER: int = 3463
"""
``VFMADD213SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}``
``EVEX.LIG.66.0F38.W1 A9 /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_VFMSUB213PS_XMM_XMM_XMMM128: int = 3464
"""
``VFMSUB213PS xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W0 AA /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFMSUB213PS_YMM_YMM_YMMM256: int = 3465
"""
``VFMSUB213PS ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W0 AA /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFMSUB213PD_XMM_XMM_XMMM128: int = 3466
"""
``VFMSUB213PD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W1 AA /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFMSUB213PD_YMM_YMM_YMMM256: int = 3467
"""
``VFMSUB213PD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W1 AA /r``
``FMA``
``16/32/64-bit``
"""
EVEX_VFMSUB213PS_XMM_K1Z_XMM_XMMM128B32: int = 3468
"""
``VFMSUB213PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 AA /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMSUB213PS_YMM_K1Z_YMM_YMMM256B32: int = 3469
"""
``VFMSUB213PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 AA /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMSUB213PS_ZMM_K1Z_ZMM_ZMMM512B32_ER: int = 3470
"""
``VFMSUB213PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}``
``EVEX.512.66.0F38.W0 AA /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VFMSUB213PD_XMM_K1Z_XMM_XMMM128B64: int = 3471
"""
``VFMSUB213PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 AA /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMSUB213PD_YMM_K1Z_YMM_YMMM256B64: int = 3472
"""
``VFMSUB213PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 AA /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMSUB213PD_ZMM_K1Z_ZMM_ZMMM512B64_ER: int = 3473
"""
``VFMSUB213PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}``
``EVEX.512.66.0F38.W1 AA /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_V4FNMADDPS_ZMM_K1Z_ZMMP3_M128: int = 3474
"""
``V4FNMADDPS zmm1 {k1}{z}, zmm2+3, m128``
``EVEX.512.F2.0F38.W0 AA /r``
``AVX512_4FMAPS``
``16/32/64-bit``
"""
VEX_VFMSUB213SS_XMM_XMM_XMMM32: int = 3475
"""
``VFMSUB213SS xmm1, xmm2, xmm3/m32``
``VEX.LIG.66.0F38.W0 AB /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFMSUB213SD_XMM_XMM_XMMM64: int = 3476
"""
``VFMSUB213SD xmm1, xmm2, xmm3/m64``
``VEX.LIG.66.0F38.W1 AB /r``
``FMA``
``16/32/64-bit``
"""
EVEX_VFMSUB213SS_XMM_K1Z_XMM_XMMM32_ER: int = 3477
"""
``VFMSUB213SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}``
``EVEX.LIG.66.0F38.W0 AB /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VFMSUB213SD_XMM_K1Z_XMM_XMMM64_ER: int = 3478
"""
``VFMSUB213SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}``
``EVEX.LIG.66.0F38.W1 AB /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_V4FNMADDSS_XMM_K1Z_XMMP3_M128: int = 3479
"""
``V4FNMADDSS xmm1 {k1}{z}, xmm2+3, m128``
``EVEX.LIG.F2.0F38.W0 AB /r``
``AVX512_4FMAPS``
``16/32/64-bit``
"""
VEX_VFNMADD213PS_XMM_XMM_XMMM128: int = 3480
"""
``VFNMADD213PS xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W0 AC /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFNMADD213PS_YMM_YMM_YMMM256: int = 3481
"""
``VFNMADD213PS ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W0 AC /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFNMADD213PD_XMM_XMM_XMMM128: int = 3482
"""
``VFNMADD213PD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W1 AC /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFNMADD213PD_YMM_YMM_YMMM256: int = 3483
"""
``VFNMADD213PD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W1 AC /r``
``FMA``
``16/32/64-bit``
"""
EVEX_VFNMADD213PS_XMM_K1Z_XMM_XMMM128B32: int = 3484
"""
``VFNMADD213PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 AC /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFNMADD213PS_YMM_K1Z_YMM_YMMM256B32: int = 3485
"""
``VFNMADD213PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 AC /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFNMADD213PS_ZMM_K1Z_ZMM_ZMMM512B32_ER: int = 3486
"""
``VFNMADD213PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}``
``EVEX.512.66.0F38.W0 AC /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VFNMADD213PD_XMM_K1Z_XMM_XMMM128B64: int = 3487
"""
``VFNMADD213PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 AC /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFNMADD213PD_YMM_K1Z_YMM_YMMM256B64: int = 3488
"""
``VFNMADD213PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 AC /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFNMADD213PD_ZMM_K1Z_ZMM_ZMMM512B64_ER: int = 3489
"""
``VFNMADD213PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}``
``EVEX.512.66.0F38.W1 AC /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_VFNMADD213SS_XMM_XMM_XMMM32: int = 3490
"""
``VFNMADD213SS xmm1, xmm2, xmm3/m32``
``VEX.LIG.66.0F38.W0 AD /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFNMADD213SD_XMM_XMM_XMMM64: int = 3491
"""
``VFNMADD213SD xmm1, xmm2, xmm3/m64``
``VEX.LIG.66.0F38.W1 AD /r``
``FMA``
``16/32/64-bit``
"""
EVEX_VFNMADD213SS_XMM_K1Z_XMM_XMMM32_ER: int = 3492
"""
``VFNMADD213SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}``
``EVEX.LIG.66.0F38.W0 AD /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VFNMADD213SD_XMM_K1Z_XMM_XMMM64_ER: int = 3493
"""
``VFNMADD213SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}``
``EVEX.LIG.66.0F38.W1 AD /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_VFNMSUB213PS_XMM_XMM_XMMM128: int = 3494
"""
``VFNMSUB213PS xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W0 AE /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFNMSUB213PS_YMM_YMM_YMMM256: int = 3495
"""
``VFNMSUB213PS ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W0 AE /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFNMSUB213PD_XMM_XMM_XMMM128: int = 3496
"""
``VFNMSUB213PD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W1 AE /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFNMSUB213PD_YMM_YMM_YMMM256: int = 3497
"""
``VFNMSUB213PD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W1 AE /r``
``FMA``
``16/32/64-bit``
"""
EVEX_VFNMSUB213PS_XMM_K1Z_XMM_XMMM128B32: int = 3498
"""
``VFNMSUB213PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 AE /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFNMSUB213PS_YMM_K1Z_YMM_YMMM256B32: int = 3499
"""
``VFNMSUB213PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 AE /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFNMSUB213PS_ZMM_K1Z_ZMM_ZMMM512B32_ER: int = 3500
"""
``VFNMSUB213PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}``
``EVEX.512.66.0F38.W0 AE /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VFNMSUB213PD_XMM_K1Z_XMM_XMMM128B64: int = 3501
"""
``VFNMSUB213PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 AE /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFNMSUB213PD_YMM_K1Z_YMM_YMMM256B64: int = 3502
"""
``VFNMSUB213PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 AE /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFNMSUB213PD_ZMM_K1Z_ZMM_ZMMM512B64_ER: int = 3503
"""
``VFNMSUB213PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}``
``EVEX.512.66.0F38.W1 AE /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_VFNMSUB213SS_XMM_XMM_XMMM32: int = 3504
"""
``VFNMSUB213SS xmm1, xmm2, xmm3/m32``
``VEX.LIG.66.0F38.W0 AF /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFNMSUB213SD_XMM_XMM_XMMM64: int = 3505
"""
``VFNMSUB213SD xmm1, xmm2, xmm3/m64``
``VEX.LIG.66.0F38.W1 AF /r``
``FMA``
``16/32/64-bit``
"""
EVEX_VFNMSUB213SS_XMM_K1Z_XMM_XMMM32_ER: int = 3506
"""
``VFNMSUB213SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}``
``EVEX.LIG.66.0F38.W0 AF /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VFNMSUB213SD_XMM_K1Z_XMM_XMMM64_ER: int = 3507
"""
``VFNMSUB213SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}``
``EVEX.LIG.66.0F38.W1 AF /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPMADD52LUQ_XMM_K1Z_XMM_XMMM128B64: int = 3508
"""
``VPMADD52LUQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 B4 /r``
``AVX512VL and AVX512_IFMA``
``16/32/64-bit``
"""
EVEX_VPMADD52LUQ_YMM_K1Z_YMM_YMMM256B64: int = 3509
"""
``VPMADD52LUQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 B4 /r``
``AVX512VL and AVX512_IFMA``
``16/32/64-bit``
"""
EVEX_VPMADD52LUQ_ZMM_K1Z_ZMM_ZMMM512B64: int = 3510
"""
``VPMADD52LUQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F38.W1 B4 /r``
``AVX512_IFMA``
``16/32/64-bit``
"""
EVEX_VPMADD52HUQ_XMM_K1Z_XMM_XMMM128B64: int = 3511
"""
``VPMADD52HUQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 B5 /r``
``AVX512VL and AVX512_IFMA``
``16/32/64-bit``
"""
EVEX_VPMADD52HUQ_YMM_K1Z_YMM_YMMM256B64: int = 3512
"""
``VPMADD52HUQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 B5 /r``
``AVX512VL and AVX512_IFMA``
``16/32/64-bit``
"""
EVEX_VPMADD52HUQ_ZMM_K1Z_ZMM_ZMMM512B64: int = 3513
"""
``VPMADD52HUQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst``
``EVEX.512.66.0F38.W1 B5 /r``
``AVX512_IFMA``
``16/32/64-bit``
"""
VEX_VFMADDSUB231PS_XMM_XMM_XMMM128: int = 3514
"""
``VFMADDSUB231PS xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W0 B6 /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFMADDSUB231PS_YMM_YMM_YMMM256: int = 3515
"""
``VFMADDSUB231PS ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W0 B6 /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFMADDSUB231PD_XMM_XMM_XMMM128: int = 3516
"""
``VFMADDSUB231PD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W1 B6 /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFMADDSUB231PD_YMM_YMM_YMMM256: int = 3517
"""
``VFMADDSUB231PD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W1 B6 /r``
``FMA``
``16/32/64-bit``
"""
EVEX_VFMADDSUB231PS_XMM_K1Z_XMM_XMMM128B32: int = 3518
"""
``VFMADDSUB231PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 B6 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMADDSUB231PS_YMM_K1Z_YMM_YMMM256B32: int = 3519
"""
``VFMADDSUB231PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 B6 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMADDSUB231PS_ZMM_K1Z_ZMM_ZMMM512B32_ER: int = 3520
"""
``VFMADDSUB231PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}``
``EVEX.512.66.0F38.W0 B6 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VFMADDSUB231PD_XMM_K1Z_XMM_XMMM128B64: int = 3521
"""
``VFMADDSUB231PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 B6 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMADDSUB231PD_YMM_K1Z_YMM_YMMM256B64: int = 3522
"""
``VFMADDSUB231PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 B6 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMADDSUB231PD_ZMM_K1Z_ZMM_ZMMM512B64_ER: int = 3523
"""
``VFMADDSUB231PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}``
``EVEX.512.66.0F38.W1 B6 /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_VFMSUBADD231PS_XMM_XMM_XMMM128: int = 3524
"""
``VFMSUBADD231PS xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W0 B7 /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFMSUBADD231PS_YMM_YMM_YMMM256: int = 3525
"""
``VFMSUBADD231PS ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W0 B7 /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFMSUBADD231PD_XMM_XMM_XMMM128: int = 3526
"""
``VFMSUBADD231PD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W1 B7 /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFMSUBADD231PD_YMM_YMM_YMMM256: int = 3527
"""
``VFMSUBADD231PD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W1 B7 /r``
``FMA``
``16/32/64-bit``
"""
EVEX_VFMSUBADD231PS_XMM_K1Z_XMM_XMMM128B32: int = 3528
"""
``VFMSUBADD231PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 B7 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMSUBADD231PS_YMM_K1Z_YMM_YMMM256B32: int = 3529
"""
``VFMSUBADD231PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 B7 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMSUBADD231PS_ZMM_K1Z_ZMM_ZMMM512B32_ER: int = 3530
"""
``VFMSUBADD231PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}``
``EVEX.512.66.0F38.W0 B7 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VFMSUBADD231PD_XMM_K1Z_XMM_XMMM128B64: int = 3531
"""
``VFMSUBADD231PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 B7 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMSUBADD231PD_YMM_K1Z_YMM_YMMM256B64: int = 3532
"""
``VFMSUBADD231PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 B7 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMSUBADD231PD_ZMM_K1Z_ZMM_ZMMM512B64_ER: int = 3533
"""
``VFMSUBADD231PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}``
``EVEX.512.66.0F38.W1 B7 /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_VFMADD231PS_XMM_XMM_XMMM128: int = 3534
"""
``VFMADD231PS xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W0 B8 /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFMADD231PS_YMM_YMM_YMMM256: int = 3535
"""
``VFMADD231PS ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W0 B8 /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFMADD231PD_XMM_XMM_XMMM128: int = 3536
"""
``VFMADD231PD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W1 B8 /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFMADD231PD_YMM_YMM_YMMM256: int = 3537
"""
``VFMADD231PD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W1 B8 /r``
``FMA``
``16/32/64-bit``
"""
EVEX_VFMADD231PS_XMM_K1Z_XMM_XMMM128B32: int = 3538
"""
``VFMADD231PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 B8 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMADD231PS_YMM_K1Z_YMM_YMMM256B32: int = 3539
"""
``VFMADD231PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 B8 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMADD231PS_ZMM_K1Z_ZMM_ZMMM512B32_ER: int = 3540
"""
``VFMADD231PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}``
``EVEX.512.66.0F38.W0 B8 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VFMADD231PD_XMM_K1Z_XMM_XMMM128B64: int = 3541
"""
``VFMADD231PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 B8 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMADD231PD_YMM_K1Z_YMM_YMMM256B64: int = 3542
"""
``VFMADD231PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 B8 /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMADD231PD_ZMM_K1Z_ZMM_ZMMM512B64_ER: int = 3543
"""
``VFMADD231PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}``
``EVEX.512.66.0F38.W1 B8 /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_VFMADD231SS_XMM_XMM_XMMM32: int = 3544
"""
``VFMADD231SS xmm1, xmm2, xmm3/m32``
``VEX.LIG.66.0F38.W0 B9 /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFMADD231SD_XMM_XMM_XMMM64: int = 3545
"""
``VFMADD231SD xmm1, xmm2, xmm3/m64``
``VEX.LIG.66.0F38.W1 B9 /r``
``FMA``
``16/32/64-bit``
"""
EVEX_VFMADD231SS_XMM_K1Z_XMM_XMMM32_ER: int = 3546
"""
``VFMADD231SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}``
``EVEX.LIG.66.0F38.W0 B9 /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VFMADD231SD_XMM_K1Z_XMM_XMMM64_ER: int = 3547
"""
``VFMADD231SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}``
``EVEX.LIG.66.0F38.W1 B9 /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_VFMSUB231PS_XMM_XMM_XMMM128: int = 3548
"""
``VFMSUB231PS xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W0 BA /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFMSUB231PS_YMM_YMM_YMMM256: int = 3549
"""
``VFMSUB231PS ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W0 BA /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFMSUB231PD_XMM_XMM_XMMM128: int = 3550
"""
``VFMSUB231PD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W1 BA /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFMSUB231PD_YMM_YMM_YMMM256: int = 3551
"""
``VFMSUB231PD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W1 BA /r``
``FMA``
``16/32/64-bit``
"""
EVEX_VFMSUB231PS_XMM_K1Z_XMM_XMMM128B32: int = 3552
"""
``VFMSUB231PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 BA /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMSUB231PS_YMM_K1Z_YMM_YMMM256B32: int = 3553
"""
``VFMSUB231PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 BA /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMSUB231PS_ZMM_K1Z_ZMM_ZMMM512B32_ER: int = 3554
"""
``VFMSUB231PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}``
``EVEX.512.66.0F38.W0 BA /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VFMSUB231PD_XMM_K1Z_XMM_XMMM128B64: int = 3555
"""
``VFMSUB231PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 BA /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMSUB231PD_YMM_K1Z_YMM_YMMM256B64: int = 3556
"""
``VFMSUB231PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 BA /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFMSUB231PD_ZMM_K1Z_ZMM_ZMMM512B64_ER: int = 3557
"""
``VFMSUB231PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}``
``EVEX.512.66.0F38.W1 BA /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_VFMSUB231SS_XMM_XMM_XMMM32: int = 3558
"""
``VFMSUB231SS xmm1, xmm2, xmm3/m32``
``VEX.LIG.66.0F38.W0 BB /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFMSUB231SD_XMM_XMM_XMMM64: int = 3559
"""
``VFMSUB231SD xmm1, xmm2, xmm3/m64``
``VEX.LIG.66.0F38.W1 BB /r``
``FMA``
``16/32/64-bit``
"""
EVEX_VFMSUB231SS_XMM_K1Z_XMM_XMMM32_ER: int = 3560
"""
``VFMSUB231SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}``
``EVEX.LIG.66.0F38.W0 BB /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VFMSUB231SD_XMM_K1Z_XMM_XMMM64_ER: int = 3561
"""
``VFMSUB231SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}``
``EVEX.LIG.66.0F38.W1 BB /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_VFNMADD231PS_XMM_XMM_XMMM128: int = 3562
"""
``VFNMADD231PS xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W0 BC /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFNMADD231PS_YMM_YMM_YMMM256: int = 3563
"""
``VFNMADD231PS ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W0 BC /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFNMADD231PD_XMM_XMM_XMMM128: int = 3564
"""
``VFNMADD231PD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W1 BC /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFNMADD231PD_YMM_YMM_YMMM256: int = 3565
"""
``VFNMADD231PD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W1 BC /r``
``FMA``
``16/32/64-bit``
"""
EVEX_VFNMADD231PS_XMM_K1Z_XMM_XMMM128B32: int = 3566
"""
``VFNMADD231PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 BC /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFNMADD231PS_YMM_K1Z_YMM_YMMM256B32: int = 3567
"""
``VFNMADD231PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 BC /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFNMADD231PS_ZMM_K1Z_ZMM_ZMMM512B32_ER: int = 3568
"""
``VFNMADD231PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}``
``EVEX.512.66.0F38.W0 BC /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VFNMADD231PD_XMM_K1Z_XMM_XMMM128B64: int = 3569
"""
``VFNMADD231PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 BC /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFNMADD231PD_YMM_K1Z_YMM_YMMM256B64: int = 3570
"""
``VFNMADD231PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 BC /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFNMADD231PD_ZMM_K1Z_ZMM_ZMMM512B64_ER: int = 3571
"""
``VFNMADD231PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}``
``EVEX.512.66.0F38.W1 BC /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_VFNMADD231SS_XMM_XMM_XMMM32: int = 3572
"""
``VFNMADD231SS xmm1, xmm2, xmm3/m32``
``VEX.LIG.66.0F38.W0 BD /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFNMADD231SD_XMM_XMM_XMMM64: int = 3573
"""
``VFNMADD231SD xmm1, xmm2, xmm3/m64``
``VEX.LIG.66.0F38.W1 BD /r``
``FMA``
``16/32/64-bit``
"""
EVEX_VFNMADD231SS_XMM_K1Z_XMM_XMMM32_ER: int = 3574
"""
``VFNMADD231SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}``
``EVEX.LIG.66.0F38.W0 BD /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VFNMADD231SD_XMM_K1Z_XMM_XMMM64_ER: int = 3575
"""
``VFNMADD231SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}``
``EVEX.LIG.66.0F38.W1 BD /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_VFNMSUB231PS_XMM_XMM_XMMM128: int = 3576
"""
``VFNMSUB231PS xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W0 BE /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFNMSUB231PS_YMM_YMM_YMMM256: int = 3577
"""
``VFNMSUB231PS ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W0 BE /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFNMSUB231PD_XMM_XMM_XMMM128: int = 3578
"""
``VFNMSUB231PD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W1 BE /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFNMSUB231PD_YMM_YMM_YMMM256: int = 3579
"""
``VFNMSUB231PD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W1 BE /r``
``FMA``
``16/32/64-bit``
"""
EVEX_VFNMSUB231PS_XMM_K1Z_XMM_XMMM128B32: int = 3580
"""
``VFNMSUB231PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.66.0F38.W0 BE /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFNMSUB231PS_YMM_K1Z_YMM_YMMM256B32: int = 3581
"""
``VFNMSUB231PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.66.0F38.W0 BE /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFNMSUB231PS_ZMM_K1Z_ZMM_ZMMM512B32_ER: int = 3582
"""
``VFNMSUB231PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}``
``EVEX.512.66.0F38.W0 BE /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VFNMSUB231PD_XMM_K1Z_XMM_XMMM128B64: int = 3583
"""
``VFNMSUB231PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst``
``EVEX.128.66.0F38.W1 BE /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFNMSUB231PD_YMM_K1Z_YMM_YMMM256B64: int = 3584
"""
``VFNMSUB231PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst``
``EVEX.256.66.0F38.W1 BE /r``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFNMSUB231PD_ZMM_K1Z_ZMM_ZMMM512B64_ER: int = 3585
"""
``VFNMSUB231PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}``
``EVEX.512.66.0F38.W1 BE /r``
``AVX512F``
``16/32/64-bit``
"""
VEX_VFNMSUB231SS_XMM_XMM_XMMM32: int = 3586
"""
``VFNMSUB231SS xmm1, xmm2, xmm3/m32``
``VEX.LIG.66.0F38.W0 BF /r``
``FMA``
``16/32/64-bit``
"""
VEX_VFNMSUB231SD_XMM_XMM_XMMM64: int = 3587
"""
``VFNMSUB231SD xmm1, xmm2, xmm3/m64``
``VEX.LIG.66.0F38.W1 BF /r``
``FMA``
``16/32/64-bit``
"""
EVEX_VFNMSUB231SS_XMM_K1Z_XMM_XMMM32_ER: int = 3588
"""
``VFNMSUB231SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}``
``EVEX.LIG.66.0F38.W0 BF /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VFNMSUB231SD_XMM_K1Z_XMM_XMMM64_ER: int = 3589
"""
``VFNMSUB231SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}``
``EVEX.LIG.66.0F38.W1 BF /r``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPCONFLICTD_XMM_K1Z_XMMM128B32: int = 3590
"""
``VPCONFLICTD xmm1 {k1}{z}, xmm2/m128/m32bcst``
``EVEX.128.66.0F38.W0 C4 /r``
``AVX512VL and AVX512CD``
``16/32/64-bit``
"""
EVEX_VPCONFLICTD_YMM_K1Z_YMMM256B32: int = 3591
"""
``VPCONFLICTD ymm1 {k1}{z}, ymm2/m256/m32bcst``
``EVEX.256.66.0F38.W0 C4 /r``
``AVX512VL and AVX512CD``
``16/32/64-bit``
"""
EVEX_VPCONFLICTD_ZMM_K1Z_ZMMM512B32: int = 3592
"""
``VPCONFLICTD zmm1 {k1}{z}, zmm2/m512/m32bcst``
``EVEX.512.66.0F38.W0 C4 /r``
``AVX512CD``
``16/32/64-bit``
"""
EVEX_VPCONFLICTQ_XMM_K1Z_XMMM128B64: int = 3593
"""
``VPCONFLICTQ xmm1 {k1}{z}, xmm2/m128/m64bcst``
``EVEX.128.66.0F38.W1 C4 /r``
``AVX512VL and AVX512CD``
``16/32/64-bit``
"""
EVEX_VPCONFLICTQ_YMM_K1Z_YMMM256B64: int = 3594
"""
``VPCONFLICTQ ymm1 {k1}{z}, ymm2/m256/m64bcst``
``EVEX.256.66.0F38.W1 C4 /r``
``AVX512VL and AVX512CD``
``16/32/64-bit``
"""
EVEX_VPCONFLICTQ_ZMM_K1Z_ZMMM512B64: int = 3595
"""
``VPCONFLICTQ zmm1 {k1}{z}, zmm2/m512/m64bcst``
``EVEX.512.66.0F38.W1 C4 /r``
``AVX512CD``
``16/32/64-bit``
"""
EVEX_VGATHERPF0DPS_VM32Z_K1: int = 3596
"""
``VGATHERPF0DPS vm32z {k1}``
``EVEX.512.66.0F38.W0 C6 /1 /vsib``
``AVX512PF``
``16/32/64-bit``
"""
EVEX_VGATHERPF0DPD_VM32Y_K1: int = 3597
"""
``VGATHERPF0DPD vm32y {k1}``
``EVEX.512.66.0F38.W1 C6 /1 /vsib``
``AVX512PF``
``16/32/64-bit``
"""
EVEX_VGATHERPF1DPS_VM32Z_K1: int = 3598
"""
``VGATHERPF1DPS vm32z {k1}``
``EVEX.512.66.0F38.W0 C6 /2 /vsib``
``AVX512PF``
``16/32/64-bit``
"""
EVEX_VGATHERPF1DPD_VM32Y_K1: int = 3599
"""
``VGATHERPF1DPD vm32y {k1}``
``EVEX.512.66.0F38.W1 C6 /2 /vsib``
``AVX512PF``
``16/32/64-bit``
"""
EVEX_VSCATTERPF0DPS_VM32Z_K1: int = 3600
"""
``VSCATTERPF0DPS vm32z {k1}``
``EVEX.512.66.0F38.W0 C6 /5 /vsib``
``AVX512PF``
``16/32/64-bit``
"""
EVEX_VSCATTERPF0DPD_VM32Y_K1: int = 3601
"""
``VSCATTERPF0DPD vm32y {k1}``
``EVEX.512.66.0F38.W1 C6 /5 /vsib``
``AVX512PF``
``16/32/64-bit``
"""
EVEX_VSCATTERPF1DPS_VM32Z_K1: int = 3602
"""
``VSCATTERPF1DPS vm32z {k1}``
``EVEX.512.66.0F38.W0 C6 /6 /vsib``
``AVX512PF``
``16/32/64-bit``
"""
EVEX_VSCATTERPF1DPD_VM32Y_K1: int = 3603
"""
``VSCATTERPF1DPD vm32y {k1}``
``EVEX.512.66.0F38.W1 C6 /6 /vsib``
``AVX512PF``
``16/32/64-bit``
"""
EVEX_VGATHERPF0QPS_VM64Z_K1: int = 3604
"""
``VGATHERPF0QPS vm64z {k1}``
``EVEX.512.66.0F38.W0 C7 /1 /vsib``
``AVX512PF``
``16/32/64-bit``
"""
EVEX_VGATHERPF0QPD_VM64Z_K1: int = 3605
"""
``VGATHERPF0QPD vm64z {k1}``
``EVEX.512.66.0F38.W1 C7 /1 /vsib``
``AVX512PF``
``16/32/64-bit``
"""
EVEX_VGATHERPF1QPS_VM64Z_K1: int = 3606
"""
``VGATHERPF1QPS vm64z {k1}``
``EVEX.512.66.0F38.W0 C7 /2 /vsib``
``AVX512PF``
``16/32/64-bit``
"""
EVEX_VGATHERPF1QPD_VM64Z_K1: int = 3607
"""
``VGATHERPF1QPD vm64z {k1}``
``EVEX.512.66.0F38.W1 C7 /2 /vsib``
``AVX512PF``
``16/32/64-bit``
"""
EVEX_VSCATTERPF0QPS_VM64Z_K1: int = 3608
"""
``VSCATTERPF0QPS vm64z {k1}``
``EVEX.512.66.0F38.W0 C7 /5 /vsib``
``AVX512PF``
``16/32/64-bit``
"""
EVEX_VSCATTERPF0QPD_VM64Z_K1: int = 3609
"""
``VSCATTERPF0QPD vm64z {k1}``
``EVEX.512.66.0F38.W1 C7 /5 /vsib``
``AVX512PF``
``16/32/64-bit``
"""
EVEX_VSCATTERPF1QPS_VM64Z_K1: int = 3610
"""
``VSCATTERPF1QPS vm64z {k1}``
``EVEX.512.66.0F38.W0 C7 /6 /vsib``
``AVX512PF``
``16/32/64-bit``
"""
EVEX_VSCATTERPF1QPD_VM64Z_K1: int = 3611
"""
``VSCATTERPF1QPD vm64z {k1}``
``EVEX.512.66.0F38.W1 C7 /6 /vsib``
``AVX512PF``
``16/32/64-bit``
"""
SHA1NEXTE_XMM_XMMM128: int = 3612
"""
``SHA1NEXTE xmm1, xmm2/m128``
``NP 0F 38 C8 /r``
``SHA``
``16/32/64-bit``
"""
EVEX_VEXP2PS_ZMM_K1Z_ZMMM512B32_SAE: int = 3613
"""
``VEXP2PS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}``
``EVEX.512.66.0F38.W0 C8 /r``
``AVX512ER``
``16/32/64-bit``
"""
EVEX_VEXP2PD_ZMM_K1Z_ZMMM512B64_SAE: int = 3614
"""
``VEXP2PD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}``
``EVEX.512.66.0F38.W1 C8 /r``
``AVX512ER``
``16/32/64-bit``
"""
SHA1MSG1_XMM_XMMM128: int = 3615
"""
``SHA1MSG1 xmm1, xmm2/m128``
``NP 0F 38 C9 /r``
``SHA``
``16/32/64-bit``
"""
SHA1MSG2_XMM_XMMM128: int = 3616
"""
``SHA1MSG2 xmm1, xmm2/m128``
``NP 0F 38 CA /r``
``SHA``
``16/32/64-bit``
"""
EVEX_VRCP28PS_ZMM_K1Z_ZMMM512B32_SAE: int = 3617
"""
``VRCP28PS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}``
``EVEX.512.66.0F38.W0 CA /r``
``AVX512ER``
``16/32/64-bit``
"""
EVEX_VRCP28PD_ZMM_K1Z_ZMMM512B64_SAE: int = 3618
"""
``VRCP28PD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}``
``EVEX.512.66.0F38.W1 CA /r``
``AVX512ER``
``16/32/64-bit``
"""
SHA256RNDS2_XMM_XMMM128: int = 3619
"""
``SHA256RNDS2 xmm1, xmm2/m128, <XMM0>``
``NP 0F 38 CB /r``
``SHA``
``16/32/64-bit``
"""
EVEX_VRCP28SS_XMM_K1Z_XMM_XMMM32_SAE: int = 3620
"""
``VRCP28SS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}``
``EVEX.LIG.66.0F38.W0 CB /r``
``AVX512ER``
``16/32/64-bit``
"""
EVEX_VRCP28SD_XMM_K1Z_XMM_XMMM64_SAE: int = 3621
"""
``VRCP28SD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}``
``EVEX.LIG.66.0F38.W1 CB /r``
``AVX512ER``
``16/32/64-bit``
"""
SHA256MSG1_XMM_XMMM128: int = 3622
"""
``SHA256MSG1 xmm1, xmm2/m128``
``NP 0F 38 CC /r``
``SHA``
``16/32/64-bit``
"""
EVEX_VRSQRT28PS_ZMM_K1Z_ZMMM512B32_SAE: int = 3623
"""
``VRSQRT28PS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}``
``EVEX.512.66.0F38.W0 CC /r``
``AVX512ER``
``16/32/64-bit``
"""
EVEX_VRSQRT28PD_ZMM_K1Z_ZMMM512B64_SAE: int = 3624
"""
``VRSQRT28PD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}``
``EVEX.512.66.0F38.W1 CC /r``
``AVX512ER``
``16/32/64-bit``
"""
SHA256MSG2_XMM_XMMM128: int = 3625
"""
``SHA256MSG2 xmm1, xmm2/m128``
``NP 0F 38 CD /r``
``SHA``
``16/32/64-bit``
"""
EVEX_VRSQRT28SS_XMM_K1Z_XMM_XMMM32_SAE: int = 3626
"""
``VRSQRT28SS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}``
``EVEX.LIG.66.0F38.W0 CD /r``
``AVX512ER``
``16/32/64-bit``
"""
EVEX_VRSQRT28SD_XMM_K1Z_XMM_XMMM64_SAE: int = 3627
"""
``VRSQRT28SD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}``
``EVEX.LIG.66.0F38.W1 CD /r``
``AVX512ER``
``16/32/64-bit``
"""
GF2P8MULB_XMM_XMMM128: int = 3628
"""
``GF2P8MULB xmm1, xmm2/m128``
``66 0F 38 CF /r``
``GFNI``
``16/32/64-bit``
"""
VEX_VGF2P8MULB_XMM_XMM_XMMM128: int = 3629
"""
``VGF2P8MULB xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W0 CF /r``
``AVX and GFNI``
``16/32/64-bit``
"""
VEX_VGF2P8MULB_YMM_YMM_YMMM256: int = 3630
"""
``VGF2P8MULB ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W0 CF /r``
``AVX and GFNI``
``16/32/64-bit``
"""
EVEX_VGF2P8MULB_XMM_K1Z_XMM_XMMM128: int = 3631
"""
``VGF2P8MULB xmm1 {k1}{z}, xmm2, xmm3/m128``
``EVEX.128.66.0F38.W0 CF /r``
``AVX512VL and GFNI``
``16/32/64-bit``
"""
EVEX_VGF2P8MULB_YMM_K1Z_YMM_YMMM256: int = 3632
"""
``VGF2P8MULB ymm1 {k1}{z}, ymm2, ymm3/m256``
``EVEX.256.66.0F38.W0 CF /r``
``AVX512VL and GFNI``
``16/32/64-bit``
"""
EVEX_VGF2P8MULB_ZMM_K1Z_ZMM_ZMMM512: int = 3633
"""
``VGF2P8MULB zmm1 {k1}{z}, zmm2, zmm3/m512``
``EVEX.512.66.0F38.W0 CF /r``
``AVX512F and GFNI``
``16/32/64-bit``
"""
AESIMC_XMM_XMMM128: int = 3634
"""
``AESIMC xmm1, xmm2/m128``
``66 0F 38 DB /r``
``AES``
``16/32/64-bit``
"""
VEX_VAESIMC_XMM_XMMM128: int = 3635
"""
``VAESIMC xmm1, xmm2/m128``
``VEX.128.66.0F38.WIG DB /r``
``AES and AVX``
``16/32/64-bit``
"""
AESENC_XMM_XMMM128: int = 3636
"""
``AESENC xmm1, xmm2/m128``
``66 0F 38 DC /r``
``AES``
``16/32/64-bit``
"""
VEX_VAESENC_XMM_XMM_XMMM128: int = 3637
"""
``VAESENC xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.WIG DC /r``
``AES and AVX``
``16/32/64-bit``
"""
VEX_VAESENC_YMM_YMM_YMMM256: int = 3638
"""
``VAESENC ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.WIG DC /r``
``VAES``
``16/32/64-bit``
"""
EVEX_VAESENC_XMM_XMM_XMMM128: int = 3639
"""
``VAESENC xmm1, xmm2, xmm3/m128``
``EVEX.128.66.0F38.WIG DC /r``
``AVX512VL and VAES``
``16/32/64-bit``
"""
EVEX_VAESENC_YMM_YMM_YMMM256: int = 3640
"""
``VAESENC ymm1, ymm2, ymm3/m256``
``EVEX.256.66.0F38.WIG DC /r``
``AVX512VL and VAES``
``16/32/64-bit``
"""
EVEX_VAESENC_ZMM_ZMM_ZMMM512: int = 3641
"""
``VAESENC zmm1, zmm2, zmm3/m512``
``EVEX.512.66.0F38.WIG DC /r``
``AVX512F and VAES``
``16/32/64-bit``
"""
AESENCLAST_XMM_XMMM128: int = 3642
"""
``AESENCLAST xmm1, xmm2/m128``
``66 0F 38 DD /r``
``AES``
``16/32/64-bit``
"""
VEX_VAESENCLAST_XMM_XMM_XMMM128: int = 3643
"""
``VAESENCLAST xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.WIG DD /r``
``AES and AVX``
``16/32/64-bit``
"""
VEX_VAESENCLAST_YMM_YMM_YMMM256: int = 3644
"""
``VAESENCLAST ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.WIG DD /r``
``VAES``
``16/32/64-bit``
"""
EVEX_VAESENCLAST_XMM_XMM_XMMM128: int = 3645
"""
``VAESENCLAST xmm1, xmm2, xmm3/m128``
``EVEX.128.66.0F38.WIG DD /r``
``AVX512VL and VAES``
``16/32/64-bit``
"""
EVEX_VAESENCLAST_YMM_YMM_YMMM256: int = 3646
"""
``VAESENCLAST ymm1, ymm2, ymm3/m256``
``EVEX.256.66.0F38.WIG DD /r``
``AVX512VL and VAES``
``16/32/64-bit``
"""
EVEX_VAESENCLAST_ZMM_ZMM_ZMMM512: int = 3647
"""
``VAESENCLAST zmm1, zmm2, zmm3/m512``
``EVEX.512.66.0F38.WIG DD /r``
``AVX512F and VAES``
``16/32/64-bit``
"""
AESDEC_XMM_XMMM128: int = 3648
"""
``AESDEC xmm1, xmm2/m128``
``66 0F 38 DE /r``
``AES``
``16/32/64-bit``
"""
VEX_VAESDEC_XMM_XMM_XMMM128: int = 3649
"""
``VAESDEC xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.WIG DE /r``
``AES and AVX``
``16/32/64-bit``
"""
VEX_VAESDEC_YMM_YMM_YMMM256: int = 3650
"""
``VAESDEC ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.WIG DE /r``
``VAES``
``16/32/64-bit``
"""
EVEX_VAESDEC_XMM_XMM_XMMM128: int = 3651
"""
``VAESDEC xmm1, xmm2, xmm3/m128``
``EVEX.128.66.0F38.WIG DE /r``
``AVX512VL and VAES``
``16/32/64-bit``
"""
EVEX_VAESDEC_YMM_YMM_YMMM256: int = 3652
"""
``VAESDEC ymm1, ymm2, ymm3/m256``
``EVEX.256.66.0F38.WIG DE /r``
``AVX512VL and VAES``
``16/32/64-bit``
"""
EVEX_VAESDEC_ZMM_ZMM_ZMMM512: int = 3653
"""
``VAESDEC zmm1, zmm2, zmm3/m512``
``EVEX.512.66.0F38.WIG DE /r``
``AVX512F and VAES``
``16/32/64-bit``
"""
AESDECLAST_XMM_XMMM128: int = 3654
"""
``AESDECLAST xmm1, xmm2/m128``
``66 0F 38 DF /r``
``AES``
``16/32/64-bit``
"""
VEX_VAESDECLAST_XMM_XMM_XMMM128: int = 3655
"""
``VAESDECLAST xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.WIG DF /r``
``AES and AVX``
``16/32/64-bit``
"""
VEX_VAESDECLAST_YMM_YMM_YMMM256: int = 3656
"""
``VAESDECLAST ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.WIG DF /r``
``VAES``
``16/32/64-bit``
"""
EVEX_VAESDECLAST_XMM_XMM_XMMM128: int = 3657
"""
``VAESDECLAST xmm1, xmm2, xmm3/m128``
``EVEX.128.66.0F38.WIG DF /r``
``AVX512VL and VAES``
``16/32/64-bit``
"""
EVEX_VAESDECLAST_YMM_YMM_YMMM256: int = 3658
"""
``VAESDECLAST ymm1, ymm2, ymm3/m256``
``EVEX.256.66.0F38.WIG DF /r``
``AVX512VL and VAES``
``16/32/64-bit``
"""
EVEX_VAESDECLAST_ZMM_ZMM_ZMMM512: int = 3659
"""
``VAESDECLAST zmm1, zmm2, zmm3/m512``
``EVEX.512.66.0F38.WIG DF /r``
``AVX512F and VAES``
``16/32/64-bit``
"""
MOVBE_R16_M16: int = 3660
"""
``MOVBE r16, m16``
``o16 0F 38 F0 /r``
``MOVBE``
``16/32/64-bit``
"""
MOVBE_R32_M32: int = 3661
"""
``MOVBE r32, m32``
``o32 0F 38 F0 /r``
``MOVBE``
``16/32/64-bit``
"""
MOVBE_R64_M64: int = 3662
"""
``MOVBE r64, m64``
``o64 0F 38 F0 /r``
``MOVBE``
``64-bit``
"""
CRC32_R32_RM8: int = 3663
"""
``CRC32 r32, r/m8``
``F2 0F 38 F0 /r``
``SSE4.2``
``16/32/64-bit``
"""
CRC32_R64_RM8: int = 3664
"""
``CRC32 r64, r/m8``
``F2 o64 0F 38 F0 /r``
``SSE4.2``
``64-bit``
"""
MOVBE_M16_R16: int = 3665
"""
``MOVBE m16, r16``
``o16 0F 38 F1 /r``
``MOVBE``
``16/32/64-bit``
"""
MOVBE_M32_R32: int = 3666
"""
``MOVBE m32, r32``
``o32 0F 38 F1 /r``
``MOVBE``
``16/32/64-bit``
"""
MOVBE_M64_R64: int = 3667
"""
``MOVBE m64, r64``
``o64 0F 38 F1 /r``
``MOVBE``
``64-bit``
"""
CRC32_R32_RM16: int = 3668
"""
``CRC32 r32, r/m16``
``o16 F2 0F 38 F1 /r``
``SSE4.2``
``16/32/64-bit``
"""
CRC32_R32_RM32: int = 3669
"""
``CRC32 r32, r/m32``
``o32 F2 0F 38 F1 /r``
``SSE4.2``
``16/32/64-bit``
"""
CRC32_R64_RM64: int = 3670
"""
``CRC32 r64, r/m64``
``F2 o64 0F 38 F1 /r``
``SSE4.2``
``64-bit``
"""
VEX_ANDN_R32_R32_RM32: int = 3671
"""
``ANDN r32a, r32b, r/m32``
``VEX.LZ.0F38.W0 F2 /r``
``BMI1``
``16/32/64-bit``
"""
VEX_ANDN_R64_R64_RM64: int = 3672
"""
``ANDN r64a, r64b, r/m64``
``VEX.LZ.0F38.W1 F2 /r``
``BMI1``
``64-bit``
"""
VEX_BLSR_R32_RM32: int = 3673
"""
``BLSR r32, r/m32``
``VEX.LZ.0F38.W0 F3 /1``
``BMI1``
``16/32/64-bit``
"""
VEX_BLSR_R64_RM64: int = 3674
"""
``BLSR r64, r/m64``
``VEX.LZ.0F38.W1 F3 /1``
``BMI1``
``64-bit``
"""
VEX_BLSMSK_R32_RM32: int = 3675
"""
``BLSMSK r32, r/m32``
``VEX.LZ.0F38.W0 F3 /2``
``BMI1``
``16/32/64-bit``
"""
VEX_BLSMSK_R64_RM64: int = 3676
"""
``BLSMSK r64, r/m64``
``VEX.LZ.0F38.W1 F3 /2``
``BMI1``
``64-bit``
"""
VEX_BLSI_R32_RM32: int = 3677
"""
``BLSI r32, r/m32``
``VEX.LZ.0F38.W0 F3 /3``
``BMI1``
``16/32/64-bit``
"""
VEX_BLSI_R64_RM64: int = 3678
"""
``BLSI r64, r/m64``
``VEX.LZ.0F38.W1 F3 /3``
``BMI1``
``64-bit``
"""
VEX_BZHI_R32_RM32_R32: int = 3679
"""
``BZHI r32a, r/m32, r32b``
``VEX.LZ.0F38.W0 F5 /r``
``BMI2``
``16/32/64-bit``
"""
VEX_BZHI_R64_RM64_R64: int = 3680
"""
``BZHI r64a, r/m64, r64b``
``VEX.LZ.0F38.W1 F5 /r``
``BMI2``
``64-bit``
"""
WRUSSD_M32_R32: int = 3681
"""
``WRUSSD m32, r32``
``66 0F 38 F5 /r``
``CET_SS``
``16/32/64-bit``
"""
WRUSSQ_M64_R64: int = 3682
"""
``WRUSSQ m64, r64``
``66 o64 0F 38 F5 /r``
``CET_SS``
``64-bit``
"""
VEX_PEXT_R32_R32_RM32: int = 3683
"""
``PEXT r32a, r32b, r/m32``
``VEX.LZ.F3.0F38.W0 F5 /r``
``BMI2``
``16/32/64-bit``
"""
VEX_PEXT_R64_R64_RM64: int = 3684
"""
``PEXT r64a, r64b, r/m64``
``VEX.LZ.F3.0F38.W1 F5 /r``
``BMI2``
``64-bit``
"""
VEX_PDEP_R32_R32_RM32: int = 3685
"""
``PDEP r32a, r32b, r/m32``
``VEX.LZ.F2.0F38.W0 F5 /r``
``BMI2``
``16/32/64-bit``
"""
VEX_PDEP_R64_R64_RM64: int = 3686
"""
``PDEP r64a, r64b, r/m64``
``VEX.LZ.F2.0F38.W1 F5 /r``
``BMI2``
``64-bit``
"""
WRSSD_M32_R32: int = 3687
"""
``WRSSD m32, r32``
``NP 0F 38 F6 /r``
``CET_SS``
``16/32/64-bit``
"""
WRSSQ_M64_R64: int = 3688
"""
``WRSSQ m64, r64``
``NP o64 0F 38 F6 /r``
``CET_SS``
``64-bit``
"""
ADCX_R32_RM32: int = 3689
"""
``ADCX r32, r/m32``
``66 0F 38 F6 /r``
``ADX``
``16/32/64-bit``
"""
ADCX_R64_RM64: int = 3690
"""
``ADCX r64, r/m64``
``66 o64 0F 38 F6 /r``
``ADX``
``64-bit``
"""
ADOX_R32_RM32: int = 3691
"""
``ADOX r32, r/m32``
``F3 0F 38 F6 /r``
``ADX``
``16/32/64-bit``
"""
ADOX_R64_RM64: int = 3692
"""
``ADOX r64, r/m64``
``F3 o64 0F 38 F6 /r``
``ADX``
``64-bit``
"""
VEX_MULX_R32_R32_RM32: int = 3693
"""
``MULX r32a, r32b, r/m32``
``VEX.LZ.F2.0F38.W0 F6 /r``
``BMI2``
``16/32/64-bit``
"""
VEX_MULX_R64_R64_RM64: int = 3694
"""
``MULX r64a, r64b, r/m64``
``VEX.LZ.F2.0F38.W1 F6 /r``
``BMI2``
``64-bit``
"""
VEX_BEXTR_R32_RM32_R32: int = 3695
"""
``BEXTR r32a, r/m32, r32b``
``VEX.LZ.0F38.W0 F7 /r``
``BMI1``
``16/32/64-bit``
"""
VEX_BEXTR_R64_RM64_R64: int = 3696
"""
``BEXTR r64a, r/m64, r64b``
``VEX.LZ.0F38.W1 F7 /r``
``BMI1``
``64-bit``
"""
VEX_SHLX_R32_RM32_R32: int = 3697
"""
``SHLX r32a, r/m32, r32b``
``VEX.LZ.66.0F38.W0 F7 /r``
``BMI2``
``16/32/64-bit``
"""
VEX_SHLX_R64_RM64_R64: int = 3698
"""
``SHLX r64a, r/m64, r64b``
``VEX.LZ.66.0F38.W1 F7 /r``
``BMI2``
``64-bit``
"""
VEX_SARX_R32_RM32_R32: int = 3699
"""
``SARX r32a, r/m32, r32b``
``VEX.LZ.F3.0F38.W0 F7 /r``
``BMI2``
``16/32/64-bit``
"""
VEX_SARX_R64_RM64_R64: int = 3700
"""
``SARX r64a, r/m64, r64b``
``VEX.LZ.F3.0F38.W1 F7 /r``
``BMI2``
``64-bit``
"""
VEX_SHRX_R32_RM32_R32: int = 3701
"""
``SHRX r32a, r/m32, r32b``
``VEX.LZ.F2.0F38.W0 F7 /r``
``BMI2``
``16/32/64-bit``
"""
VEX_SHRX_R64_RM64_R64: int = 3702
"""
``SHRX r64a, r/m64, r64b``
``VEX.LZ.F2.0F38.W1 F7 /r``
``BMI2``
``64-bit``
"""
MOVDIR64B_R16_M512: int = 3703
"""
``MOVDIR64B r16, m512``
``a16 66 0F 38 F8 /r``
``MOVDIR64B``
``16/32-bit``
"""
MOVDIR64B_R32_M512: int = 3704
"""
``MOVDIR64B r32, m512``
``a32 66 0F 38 F8 /r``
``MOVDIR64B``
``16/32/64-bit``
"""
MOVDIR64B_R64_M512: int = 3705
"""
``MOVDIR64B r64, m512``
``a64 66 0F 38 F8 /r``
``MOVDIR64B``
``64-bit``
"""
ENQCMDS_R16_M512: int = 3706
"""
``ENQCMDS r16, m512``
``a16 F3 0F 38 F8 !(11):rrr:bbb``
``ENQCMD``
``16/32-bit``
"""
ENQCMDS_R32_M512: int = 3707
"""
``ENQCMDS r32, m512``
``a32 F3 0F 38 F8 !(11):rrr:bbb``
``ENQCMD``
``16/32/64-bit``
"""
ENQCMDS_R64_M512: int = 3708
"""
``ENQCMDS r64, m512``
``a64 F3 0F 38 F8 !(11):rrr:bbb``
``ENQCMD``
``64-bit``
"""
ENQCMD_R16_M512: int = 3709
"""
``ENQCMD r16, m512``
``a16 F2 0F 38 F8 !(11):rrr:bbb``
``ENQCMD``
``16/32-bit``
"""
ENQCMD_R32_M512: int = 3710
"""
``ENQCMD r32, m512``
``a32 F2 0F 38 F8 !(11):rrr:bbb``
``ENQCMD``
``16/32/64-bit``
"""
ENQCMD_R64_M512: int = 3711
"""
``ENQCMD r64, m512``
``a64 F2 0F 38 F8 !(11):rrr:bbb``
``ENQCMD``
``64-bit``
"""
MOVDIRI_M32_R32: int = 3712
"""
``MOVDIRI m32, r32``
``NP 0F 38 F9 /r``
``MOVDIRI``
``16/32/64-bit``
"""
MOVDIRI_M64_R64: int = 3713
"""
``MOVDIRI m64, r64``
``NP o64 0F 38 F9 /r``
``MOVDIRI``
``64-bit``
"""
VEX_VPERMQ_YMM_YMMM256_IMM8: int = 3714
"""
``VPERMQ ymm1, ymm2/m256, imm8``
``VEX.256.66.0F3A.W1 00 /r ib``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPERMQ_YMM_K1Z_YMMM256B64_IMM8: int = 3715
"""
``VPERMQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8``
``EVEX.256.66.0F3A.W1 00 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPERMQ_ZMM_K1Z_ZMMM512B64_IMM8: int = 3716
"""
``VPERMQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8``
``EVEX.512.66.0F3A.W1 00 /r ib``
``AVX512F``
``16/32/64-bit``
"""
VEX_VPERMPD_YMM_YMMM256_IMM8: int = 3717
"""
``VPERMPD ymm1, ymm2/m256, imm8``
``VEX.256.66.0F3A.W1 01 /r ib``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPERMPD_YMM_K1Z_YMMM256B64_IMM8: int = 3718
"""
``VPERMPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8``
``EVEX.256.66.0F3A.W1 01 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPERMPD_ZMM_K1Z_ZMMM512B64_IMM8: int = 3719
"""
``VPERMPD zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8``
``EVEX.512.66.0F3A.W1 01 /r ib``
``AVX512F``
``16/32/64-bit``
"""
VEX_VPBLENDD_XMM_XMM_XMMM128_IMM8: int = 3720
"""
``VPBLENDD xmm1, xmm2, xmm3/m128, imm8``
``VEX.128.66.0F3A.W0 02 /r ib``
``AVX2``
``16/32/64-bit``
"""
VEX_VPBLENDD_YMM_YMM_YMMM256_IMM8: int = 3721
"""
``VPBLENDD ymm1, ymm2, ymm3/m256, imm8``
``VEX.256.66.0F3A.W0 02 /r ib``
``AVX2``
``16/32/64-bit``
"""
EVEX_VALIGND_XMM_K1Z_XMM_XMMM128B32_IMM8: int = 3722
"""
``VALIGND xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8``
``EVEX.128.66.0F3A.W0 03 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VALIGND_YMM_K1Z_YMM_YMMM256B32_IMM8: int = 3723
"""
``VALIGND ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8``
``EVEX.256.66.0F3A.W0 03 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VALIGND_ZMM_K1Z_ZMM_ZMMM512B32_IMM8: int = 3724
"""
``VALIGND zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8``
``EVEX.512.66.0F3A.W0 03 /r ib``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VALIGNQ_XMM_K1Z_XMM_XMMM128B64_IMM8: int = 3725
"""
``VALIGNQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8``
``EVEX.128.66.0F3A.W1 03 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VALIGNQ_YMM_K1Z_YMM_YMMM256B64_IMM8: int = 3726
"""
``VALIGNQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8``
``EVEX.256.66.0F3A.W1 03 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VALIGNQ_ZMM_K1Z_ZMM_ZMMM512B64_IMM8: int = 3727
"""
``VALIGNQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8``
``EVEX.512.66.0F3A.W1 03 /r ib``
``AVX512F``
``16/32/64-bit``
"""
VEX_VPERMILPS_XMM_XMMM128_IMM8: int = 3728
"""
``VPERMILPS xmm1, xmm2/m128, imm8``
``VEX.128.66.0F3A.W0 04 /r ib``
``AVX``
``16/32/64-bit``
"""
VEX_VPERMILPS_YMM_YMMM256_IMM8: int = 3729
"""
``VPERMILPS ymm1, ymm2/m256, imm8``
``VEX.256.66.0F3A.W0 04 /r ib``
``AVX``
``16/32/64-bit``
"""
EVEX_VPERMILPS_XMM_K1Z_XMMM128B32_IMM8: int = 3730
"""
``VPERMILPS xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8``
``EVEX.128.66.0F3A.W0 04 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPERMILPS_YMM_K1Z_YMMM256B32_IMM8: int = 3731
"""
``VPERMILPS ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8``
``EVEX.256.66.0F3A.W0 04 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPERMILPS_ZMM_K1Z_ZMMM512B32_IMM8: int = 3732
"""
``VPERMILPS zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8``
``EVEX.512.66.0F3A.W0 04 /r ib``
``AVX512F``
``16/32/64-bit``
"""
VEX_VPERMILPD_XMM_XMMM128_IMM8: int = 3733
"""
``VPERMILPD xmm1, xmm2/m128, imm8``
``VEX.128.66.0F3A.W0 05 /r ib``
``AVX``
``16/32/64-bit``
"""
VEX_VPERMILPD_YMM_YMMM256_IMM8: int = 3734
"""
``VPERMILPD ymm1, ymm2/m256, imm8``
``VEX.256.66.0F3A.W0 05 /r ib``
``AVX``
``16/32/64-bit``
"""
EVEX_VPERMILPD_XMM_K1Z_XMMM128B64_IMM8: int = 3735
"""
``VPERMILPD xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8``
``EVEX.128.66.0F3A.W1 05 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPERMILPD_YMM_K1Z_YMMM256B64_IMM8: int = 3736
"""
``VPERMILPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8``
``EVEX.256.66.0F3A.W1 05 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPERMILPD_ZMM_K1Z_ZMMM512B64_IMM8: int = 3737
"""
``VPERMILPD zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8``
``EVEX.512.66.0F3A.W1 05 /r ib``
``AVX512F``
``16/32/64-bit``
"""
VEX_VPERM2F128_YMM_YMM_YMMM256_IMM8: int = 3738
"""
``VPERM2F128 ymm1, ymm2, ymm3/m256, imm8``
``VEX.256.66.0F3A.W0 06 /r ib``
``AVX``
``16/32/64-bit``
"""
ROUNDPS_XMM_XMMM128_IMM8: int = 3739
"""
``ROUNDPS xmm1, xmm2/m128, imm8``
``66 0F 3A 08 /r ib``
``SSE4.1``
``16/32/64-bit``
"""
VEX_VROUNDPS_XMM_XMMM128_IMM8: int = 3740
"""
``VROUNDPS xmm1, xmm2/m128, imm8``
``VEX.128.66.0F3A.WIG 08 /r ib``
``AVX``
``16/32/64-bit``
"""
VEX_VROUNDPS_YMM_YMMM256_IMM8: int = 3741
"""
``VROUNDPS ymm1, ymm2/m256, imm8``
``VEX.256.66.0F3A.WIG 08 /r ib``
``AVX``
``16/32/64-bit``
"""
EVEX_VRNDSCALEPS_XMM_K1Z_XMMM128B32_IMM8: int = 3742
"""
``VRNDSCALEPS xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8``
``EVEX.128.66.0F3A.W0 08 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VRNDSCALEPS_YMM_K1Z_YMMM256B32_IMM8: int = 3743
"""
``VRNDSCALEPS ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8``
``EVEX.256.66.0F3A.W0 08 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VRNDSCALEPS_ZMM_K1Z_ZMMM512B32_IMM8_SAE: int = 3744
"""
``VRNDSCALEPS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}, imm8``
``EVEX.512.66.0F3A.W0 08 /r ib``
``AVX512F``
``16/32/64-bit``
"""
ROUNDPD_XMM_XMMM128_IMM8: int = 3745
"""
``ROUNDPD xmm1, xmm2/m128, imm8``
``66 0F 3A 09 /r ib``
``SSE4.1``
``16/32/64-bit``
"""
VEX_VROUNDPD_XMM_XMMM128_IMM8: int = 3746
"""
``VROUNDPD xmm1, xmm2/m128, imm8``
``VEX.128.66.0F3A.WIG 09 /r ib``
``AVX``
``16/32/64-bit``
"""
VEX_VROUNDPD_YMM_YMMM256_IMM8: int = 3747
"""
``VROUNDPD ymm1, ymm2/m256, imm8``
``VEX.256.66.0F3A.WIG 09 /r ib``
``AVX``
``16/32/64-bit``
"""
EVEX_VRNDSCALEPD_XMM_K1Z_XMMM128B64_IMM8: int = 3748
"""
``VRNDSCALEPD xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8``
``EVEX.128.66.0F3A.W1 09 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VRNDSCALEPD_YMM_K1Z_YMMM256B64_IMM8: int = 3749
"""
``VRNDSCALEPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8``
``EVEX.256.66.0F3A.W1 09 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VRNDSCALEPD_ZMM_K1Z_ZMMM512B64_IMM8_SAE: int = 3750
"""
``VRNDSCALEPD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}, imm8``
``EVEX.512.66.0F3A.W1 09 /r ib``
``AVX512F``
``16/32/64-bit``
"""
ROUNDSS_XMM_XMMM32_IMM8: int = 3751
"""
``ROUNDSS xmm1, xmm2/m32, imm8``
``66 0F 3A 0A /r ib``
``SSE4.1``
``16/32/64-bit``
"""
VEX_VROUNDSS_XMM_XMM_XMMM32_IMM8: int = 3752
"""
``VROUNDSS xmm1, xmm2, xmm3/m32, imm8``
``VEX.LIG.66.0F3A.WIG 0A /r ib``
``AVX``
``16/32/64-bit``
"""
EVEX_VRNDSCALESS_XMM_K1Z_XMM_XMMM32_IMM8_SAE: int = 3753
"""
``VRNDSCALESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8``
``EVEX.LIG.66.0F3A.W0 0A /r ib``
``AVX512F``
``16/32/64-bit``
"""
ROUNDSD_XMM_XMMM64_IMM8: int = 3754
"""
``ROUNDSD xmm1, xmm2/m64, imm8``
``66 0F 3A 0B /r ib``
``SSE4.1``
``16/32/64-bit``
"""
VEX_VROUNDSD_XMM_XMM_XMMM64_IMM8: int = 3755
"""
``VROUNDSD xmm1, xmm2, xmm3/m64, imm8``
``VEX.LIG.66.0F3A.WIG 0B /r ib``
``AVX``
``16/32/64-bit``
"""
EVEX_VRNDSCALESD_XMM_K1Z_XMM_XMMM64_IMM8_SAE: int = 3756
"""
``VRNDSCALESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8``
``EVEX.LIG.66.0F3A.W1 0B /r ib``
``AVX512F``
``16/32/64-bit``
"""
BLENDPS_XMM_XMMM128_IMM8: int = 3757
"""
``BLENDPS xmm1, xmm2/m128, imm8``
``66 0F 3A 0C /r ib``
``SSE4.1``
``16/32/64-bit``
"""
VEX_VBLENDPS_XMM_XMM_XMMM128_IMM8: int = 3758
"""
``VBLENDPS xmm1, xmm2, xmm3/m128, imm8``
``VEX.128.66.0F3A.WIG 0C /r ib``
``AVX``
``16/32/64-bit``
"""
VEX_VBLENDPS_YMM_YMM_YMMM256_IMM8: int = 3759
"""
``VBLENDPS ymm1, ymm2, ymm3/m256, imm8``
``VEX.256.66.0F3A.WIG 0C /r ib``
``AVX``
``16/32/64-bit``
"""
BLENDPD_XMM_XMMM128_IMM8: int = 3760
"""
``BLENDPD xmm1, xmm2/m128, imm8``
``66 0F 3A 0D /r ib``
``SSE4.1``
``16/32/64-bit``
"""
VEX_VBLENDPD_XMM_XMM_XMMM128_IMM8: int = 3761
"""
``VBLENDPD xmm1, xmm2, xmm3/m128, imm8``
``VEX.128.66.0F3A.WIG 0D /r ib``
``AVX``
``16/32/64-bit``
"""
VEX_VBLENDPD_YMM_YMM_YMMM256_IMM8: int = 3762
"""
``VBLENDPD ymm1, ymm2, ymm3/m256, imm8``
``VEX.256.66.0F3A.WIG 0D /r ib``
``AVX``
``16/32/64-bit``
"""
PBLENDW_XMM_XMMM128_IMM8: int = 3763
"""
``PBLENDW xmm1, xmm2/m128, imm8``
``66 0F 3A 0E /r ib``
``SSE4.1``
``16/32/64-bit``
"""
VEX_VPBLENDW_XMM_XMM_XMMM128_IMM8: int = 3764
"""
``VPBLENDW xmm1, xmm2, xmm3/m128, imm8``
``VEX.128.66.0F3A.WIG 0E /r ib``
``AVX``
``16/32/64-bit``
"""
VEX_VPBLENDW_YMM_YMM_YMMM256_IMM8: int = 3765
"""
``VPBLENDW ymm1, ymm2, ymm3/m256, imm8``
``VEX.256.66.0F3A.WIG 0E /r ib``
``AVX2``
``16/32/64-bit``
"""
PALIGNR_MM_MMM64_IMM8: int = 3766
"""
``PALIGNR mm1, mm2/m64, imm8``
``NP 0F 3A 0F /r ib``
``SSSE3``
``16/32/64-bit``
"""
PALIGNR_XMM_XMMM128_IMM8: int = 3767
"""
``PALIGNR xmm1, xmm2/m128, imm8``
``66 0F 3A 0F /r ib``
``SSSE3``
``16/32/64-bit``
"""
VEX_VPALIGNR_XMM_XMM_XMMM128_IMM8: int = 3768
"""
``VPALIGNR xmm1, xmm2, xmm3/m128, imm8``
``VEX.128.66.0F3A.WIG 0F /r ib``
``AVX``
``16/32/64-bit``
"""
VEX_VPALIGNR_YMM_YMM_YMMM256_IMM8: int = 3769
"""
``VPALIGNR ymm1, ymm2, ymm3/m256, imm8``
``VEX.256.66.0F3A.WIG 0F /r ib``
``AVX2``
``16/32/64-bit``
"""
EVEX_VPALIGNR_XMM_K1Z_XMM_XMMM128_IMM8: int = 3770
"""
``VPALIGNR xmm1 {k1}{z}, xmm2, xmm3/m128, imm8``
``EVEX.128.66.0F3A.WIG 0F /r ib``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPALIGNR_YMM_K1Z_YMM_YMMM256_IMM8: int = 3771
"""
``VPALIGNR ymm1 {k1}{z}, ymm2, ymm3/m256, imm8``
``EVEX.256.66.0F3A.WIG 0F /r ib``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPALIGNR_ZMM_K1Z_ZMM_ZMMM512_IMM8: int = 3772
"""
``VPALIGNR zmm1 {k1}{z}, zmm2, zmm3/m512, imm8``
``EVEX.512.66.0F3A.WIG 0F /r ib``
``AVX512BW``
``16/32/64-bit``
"""
PEXTRB_R32M8_XMM_IMM8: int = 3773
"""
``PEXTRB r32/m8, xmm2, imm8``
``66 0F 3A 14 /r ib``
``SSE4.1``
``16/32/64-bit``
"""
PEXTRB_R64M8_XMM_IMM8: int = 3774
"""
``PEXTRB r64/m8, xmm2, imm8``
``66 o64 0F 3A 14 /r ib``
``SSE4.1``
``64-bit``
"""
VEX_VPEXTRB_R32M8_XMM_IMM8: int = 3775
"""
``VPEXTRB r32/m8, xmm2, imm8``
``VEX.128.66.0F3A.W0 14 /r ib``
``AVX``
``16/32/64-bit``
"""
VEX_VPEXTRB_R64M8_XMM_IMM8: int = 3776
"""
``VPEXTRB r64/m8, xmm2, imm8``
``VEX.128.66.0F3A.W1 14 /r ib``
``AVX``
``64-bit``
"""
EVEX_VPEXTRB_R32M8_XMM_IMM8: int = 3777
"""
``VPEXTRB r32/m8, xmm2, imm8``
``EVEX.128.66.0F3A.W0 14 /r ib``
``AVX512BW``
``16/32/64-bit``
"""
EVEX_VPEXTRB_R64M8_XMM_IMM8: int = 3778
"""
``VPEXTRB r64/m8, xmm2, imm8``
``EVEX.128.66.0F3A.W1 14 /r ib``
``AVX512BW``
``64-bit``
"""
PEXTRW_R32M16_XMM_IMM8: int = 3779
"""
``PEXTRW r32/m16, xmm, imm8``
``66 0F 3A 15 /r ib``
``SSE4.1``
``16/32/64-bit``
"""
PEXTRW_R64M16_XMM_IMM8: int = 3780
"""
``PEXTRW r64/m16, xmm, imm8``
``66 o64 0F 3A 15 /r ib``
``SSE4.1``
``64-bit``
"""
VEX_VPEXTRW_R32M16_XMM_IMM8: int = 3781
"""
``VPEXTRW r32/m16, xmm2, imm8``
``VEX.128.66.0F3A.W0 15 /r ib``
``AVX``
``16/32/64-bit``
"""
VEX_VPEXTRW_R64M16_XMM_IMM8: int = 3782
"""
``VPEXTRW r64/m16, xmm2, imm8``
``VEX.128.66.0F3A.W1 15 /r ib``
``AVX``
``64-bit``
"""
EVEX_VPEXTRW_R32M16_XMM_IMM8: int = 3783
"""
``VPEXTRW r32/m16, xmm2, imm8``
``EVEX.128.66.0F3A.W0 15 /r ib``
``AVX512BW``
``16/32/64-bit``
"""
EVEX_VPEXTRW_R64M16_XMM_IMM8: int = 3784
"""
``VPEXTRW r64/m16, xmm2, imm8``
``EVEX.128.66.0F3A.W1 15 /r ib``
``AVX512BW``
``64-bit``
"""
PEXTRD_RM32_XMM_IMM8: int = 3785
"""
``PEXTRD r/m32, xmm2, imm8``
``66 0F 3A 16 /r ib``
``SSE4.1``
``16/32/64-bit``
"""
PEXTRQ_RM64_XMM_IMM8: int = 3786
"""
``PEXTRQ r/m64, xmm2, imm8``
``66 o64 0F 3A 16 /r ib``
``SSE4.1``
``64-bit``
"""
VEX_VPEXTRD_RM32_XMM_IMM8: int = 3787
"""
``VPEXTRD r/m32, xmm2, imm8``
``VEX.128.66.0F3A.W0 16 /r ib``
``AVX``
``16/32/64-bit``
"""
VEX_VPEXTRQ_RM64_XMM_IMM8: int = 3788
"""
``VPEXTRQ r/m64, xmm2, imm8``
``VEX.128.66.0F3A.W1 16 /r ib``
``AVX``
``64-bit``
"""
EVEX_VPEXTRD_RM32_XMM_IMM8: int = 3789
"""
``VPEXTRD r/m32, xmm2, imm8``
``EVEX.128.66.0F3A.W0 16 /r ib``
``AVX512DQ``
``16/32/64-bit``
"""
EVEX_VPEXTRQ_RM64_XMM_IMM8: int = 3790
"""
``VPEXTRQ r/m64, xmm2, imm8``
``EVEX.128.66.0F3A.W1 16 /r ib``
``AVX512DQ``
``64-bit``
"""
EXTRACTPS_RM32_XMM_IMM8: int = 3791
"""
``EXTRACTPS r/m32, xmm1, imm8``
``66 0F 3A 17 /r ib``
``SSE4.1``
``16/32/64-bit``
"""
EXTRACTPS_R64M32_XMM_IMM8: int = 3792
"""
``EXTRACTPS r64/m32, xmm1, imm8``
``66 o64 0F 3A 17 /r ib``
``SSE4.1``
``64-bit``
"""
VEX_VEXTRACTPS_RM32_XMM_IMM8: int = 3793
"""
``VEXTRACTPS r/m32, xmm1, imm8``
``VEX.128.66.0F3A.W0 17 /r ib``
``AVX``
``16/32/64-bit``
"""
VEX_VEXTRACTPS_R64M32_XMM_IMM8: int = 3794
"""
``VEXTRACTPS r64/m32, xmm1, imm8``
``VEX.128.66.0F3A.W1 17 /r ib``
``AVX``
``64-bit``
"""
EVEX_VEXTRACTPS_RM32_XMM_IMM8: int = 3795
"""
``VEXTRACTPS r/m32, xmm1, imm8``
``EVEX.128.66.0F3A.W0 17 /r ib``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VEXTRACTPS_R64M32_XMM_IMM8: int = 3796
"""
``VEXTRACTPS r64/m32, xmm1, imm8``
``EVEX.128.66.0F3A.W1 17 /r ib``
``AVX512F``
``64-bit``
"""
VEX_VINSERTF128_YMM_YMM_XMMM128_IMM8: int = 3797
"""
``VINSERTF128 ymm1, ymm2, xmm3/m128, imm8``
``VEX.256.66.0F3A.W0 18 /r ib``
``AVX``
``16/32/64-bit``
"""
EVEX_VINSERTF32X4_YMM_K1Z_YMM_XMMM128_IMM8: int = 3798
"""
``VINSERTF32X4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8``
``EVEX.256.66.0F3A.W0 18 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VINSERTF32X4_ZMM_K1Z_ZMM_XMMM128_IMM8: int = 3799
"""
``VINSERTF32X4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8``
``EVEX.512.66.0F3A.W0 18 /r ib``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VINSERTF64X2_YMM_K1Z_YMM_XMMM128_IMM8: int = 3800
"""
``VINSERTF64X2 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8``
``EVEX.256.66.0F3A.W1 18 /r ib``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VINSERTF64X2_ZMM_K1Z_ZMM_XMMM128_IMM8: int = 3801
"""
``VINSERTF64X2 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8``
``EVEX.512.66.0F3A.W1 18 /r ib``
``AVX512DQ``
``16/32/64-bit``
"""
VEX_VEXTRACTF128_XMMM128_YMM_IMM8: int = 3802
"""
``VEXTRACTF128 xmm1/m128, ymm2, imm8``
``VEX.256.66.0F3A.W0 19 /r ib``
``AVX``
``16/32/64-bit``
"""
EVEX_VEXTRACTF32X4_XMMM128_K1Z_YMM_IMM8: int = 3803
"""
``VEXTRACTF32X4 xmm1/m128 {k1}{z}, ymm2, imm8``
``EVEX.256.66.0F3A.W0 19 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VEXTRACTF32X4_XMMM128_K1Z_ZMM_IMM8: int = 3804
"""
``VEXTRACTF32X4 xmm1/m128 {k1}{z}, zmm2, imm8``
``EVEX.512.66.0F3A.W0 19 /r ib``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VEXTRACTF64X2_XMMM128_K1Z_YMM_IMM8: int = 3805
"""
``VEXTRACTF64X2 xmm1/m128 {k1}{z}, ymm2, imm8``
``EVEX.256.66.0F3A.W1 19 /r ib``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VEXTRACTF64X2_XMMM128_K1Z_ZMM_IMM8: int = 3806
"""
``VEXTRACTF64X2 xmm1/m128 {k1}{z}, zmm2, imm8``
``EVEX.512.66.0F3A.W1 19 /r ib``
``AVX512DQ``
``16/32/64-bit``
"""
EVEX_VINSERTF32X8_ZMM_K1Z_ZMM_YMMM256_IMM8: int = 3807
"""
``VINSERTF32X8 zmm1 {k1}{z}, zmm2, ymm3/m256, imm8``
``EVEX.512.66.0F3A.W0 1A /r ib``
``AVX512DQ``
``16/32/64-bit``
"""
EVEX_VINSERTF64X4_ZMM_K1Z_ZMM_YMMM256_IMM8: int = 3808
"""
``VINSERTF64X4 zmm1 {k1}{z}, zmm2, ymm3/m256, imm8``
``EVEX.512.66.0F3A.W1 1A /r ib``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VEXTRACTF32X8_YMMM256_K1Z_ZMM_IMM8: int = 3809
"""
``VEXTRACTF32X8 ymm1/m256 {k1}{z}, zmm2, imm8``
``EVEX.512.66.0F3A.W0 1B /r ib``
``AVX512DQ``
``16/32/64-bit``
"""
EVEX_VEXTRACTF64X4_YMMM256_K1Z_ZMM_IMM8: int = 3810
"""
``VEXTRACTF64X4 ymm1/m256 {k1}{z}, zmm2, imm8``
``EVEX.512.66.0F3A.W1 1B /r ib``
``AVX512F``
``16/32/64-bit``
"""
VEX_VCVTPS2PH_XMMM64_XMM_IMM8: int = 3811
"""
``VCVTPS2PH xmm1/m64, xmm2, imm8``
``VEX.128.66.0F3A.W0 1D /r ib``
``F16C``
``16/32/64-bit``
"""
VEX_VCVTPS2PH_XMMM128_YMM_IMM8: int = 3812
"""
``VCVTPS2PH xmm1/m128, ymm2, imm8``
``VEX.256.66.0F3A.W0 1D /r ib``
``F16C``
``16/32/64-bit``
"""
EVEX_VCVTPS2PH_XMMM64_K1Z_XMM_IMM8: int = 3813
"""
``VCVTPS2PH xmm1/m64 {k1}{z}, xmm2, imm8``
``EVEX.128.66.0F3A.W0 1D /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTPS2PH_XMMM128_K1Z_YMM_IMM8: int = 3814
"""
``VCVTPS2PH xmm1/m128 {k1}{z}, ymm2, imm8``
``EVEX.256.66.0F3A.W0 1D /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VCVTPS2PH_YMMM256_K1Z_ZMM_IMM8_SAE: int = 3815
"""
``VCVTPS2PH ymm1/m256 {k1}{z}, zmm2{sae}, imm8``
``EVEX.512.66.0F3A.W0 1D /r ib``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPCMPUD_KR_K1_XMM_XMMM128B32_IMM8: int = 3816
"""
``VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8``
``EVEX.128.66.0F3A.W0 1E /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPCMPUD_KR_K1_YMM_YMMM256B32_IMM8: int = 3817
"""
``VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8``
``EVEX.256.66.0F3A.W0 1E /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPCMPUD_KR_K1_ZMM_ZMMM512B32_IMM8: int = 3818
"""
``VPCMPUD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8``
``EVEX.512.66.0F3A.W0 1E /r ib``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPCMPUQ_KR_K1_XMM_XMMM128B64_IMM8: int = 3819
"""
``VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8``
``EVEX.128.66.0F3A.W1 1E /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPCMPUQ_KR_K1_YMM_YMMM256B64_IMM8: int = 3820
"""
``VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8``
``EVEX.256.66.0F3A.W1 1E /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPCMPUQ_KR_K1_ZMM_ZMMM512B64_IMM8: int = 3821
"""
``VPCMPUQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8``
``EVEX.512.66.0F3A.W1 1E /r ib``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPCMPD_KR_K1_XMM_XMMM128B32_IMM8: int = 3822
"""
``VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8``
``EVEX.128.66.0F3A.W0 1F /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPCMPD_KR_K1_YMM_YMMM256B32_IMM8: int = 3823
"""
``VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8``
``EVEX.256.66.0F3A.W0 1F /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPCMPD_KR_K1_ZMM_ZMMM512B32_IMM8: int = 3824
"""
``VPCMPD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8``
``EVEX.512.66.0F3A.W0 1F /r ib``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPCMPQ_KR_K1_XMM_XMMM128B64_IMM8: int = 3825
"""
``VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8``
``EVEX.128.66.0F3A.W1 1F /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPCMPQ_KR_K1_YMM_YMMM256B64_IMM8: int = 3826
"""
``VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8``
``EVEX.256.66.0F3A.W1 1F /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPCMPQ_KR_K1_ZMM_ZMMM512B64_IMM8: int = 3827
"""
``VPCMPQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8``
``EVEX.512.66.0F3A.W1 1F /r ib``
``AVX512F``
``16/32/64-bit``
"""
PINSRB_XMM_R32M8_IMM8: int = 3828
"""
``PINSRB xmm1, r32/m8, imm8``
``66 0F 3A 20 /r ib``
``SSE4.1``
``16/32/64-bit``
"""
PINSRB_XMM_R64M8_IMM8: int = 3829
"""
``PINSRB xmm1, r64/m8, imm8``
``66 o64 0F 3A 20 /r ib``
``SSE4.1``
``64-bit``
"""
VEX_VPINSRB_XMM_XMM_R32M8_IMM8: int = 3830
"""
``VPINSRB xmm1, xmm2, r32/m8, imm8``
``VEX.128.66.0F3A.W0 20 /r ib``
``AVX``
``16/32/64-bit``
"""
VEX_VPINSRB_XMM_XMM_R64M8_IMM8: int = 3831
"""
``VPINSRB xmm1, xmm2, r64/m8, imm8``
``VEX.128.66.0F3A.W1 20 /r ib``
``AVX``
``64-bit``
"""
EVEX_VPINSRB_XMM_XMM_R32M8_IMM8: int = 3832
"""
``VPINSRB xmm1, xmm2, r32/m8, imm8``
``EVEX.128.66.0F3A.W0 20 /r ib``
``AVX512BW``
``16/32/64-bit``
"""
EVEX_VPINSRB_XMM_XMM_R64M8_IMM8: int = 3833
"""
``VPINSRB xmm1, xmm2, r64/m8, imm8``
``EVEX.128.66.0F3A.W1 20 /r ib``
``AVX512BW``
``64-bit``
"""
INSERTPS_XMM_XMMM32_IMM8: int = 3834
"""
``INSERTPS xmm1, xmm2/m32, imm8``
``66 0F 3A 21 /r ib``
``SSE4.1``
``16/32/64-bit``
"""
VEX_VINSERTPS_XMM_XMM_XMMM32_IMM8: int = 3835
"""
``VINSERTPS xmm1, xmm2, xmm3/m32, imm8``
``VEX.128.66.0F3A.WIG 21 /r ib``
``AVX``
``16/32/64-bit``
"""
EVEX_VINSERTPS_XMM_XMM_XMMM32_IMM8: int = 3836
"""
``VINSERTPS xmm1, xmm2, xmm3/m32, imm8``
``EVEX.128.66.0F3A.W0 21 /r ib``
``AVX512F``
``16/32/64-bit``
"""
PINSRD_XMM_RM32_IMM8: int = 3837
"""
``PINSRD xmm1, r/m32, imm8``
``66 0F 3A 22 /r ib``
``SSE4.1``
``16/32/64-bit``
"""
PINSRQ_XMM_RM64_IMM8: int = 3838
"""
``PINSRQ xmm1, r/m64, imm8``
``66 o64 0F 3A 22 /r ib``
``SSE4.1``
``64-bit``
"""
VEX_VPINSRD_XMM_XMM_RM32_IMM8: int = 3839
"""
``VPINSRD xmm1, xmm2, r/m32, imm8``
``VEX.128.66.0F3A.W0 22 /r ib``
``AVX``
``16/32/64-bit``
"""
VEX_VPINSRQ_XMM_XMM_RM64_IMM8: int = 3840
"""
``VPINSRQ xmm1, xmm2, r/m64, imm8``
``VEX.128.66.0F3A.W1 22 /r ib``
``AVX``
``64-bit``
"""
EVEX_VPINSRD_XMM_XMM_RM32_IMM8: int = 3841
"""
``VPINSRD xmm1, xmm2, r/m32, imm8``
``EVEX.128.66.0F3A.W0 22 /r ib``
``AVX512DQ``
``16/32/64-bit``
"""
EVEX_VPINSRQ_XMM_XMM_RM64_IMM8: int = 3842
"""
``VPINSRQ xmm1, xmm2, r/m64, imm8``
``EVEX.128.66.0F3A.W1 22 /r ib``
``AVX512DQ``
``64-bit``
"""
EVEX_VSHUFF32X4_YMM_K1Z_YMM_YMMM256B32_IMM8: int = 3843
"""
``VSHUFF32X4 ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8``
``EVEX.256.66.0F3A.W0 23 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VSHUFF32X4_ZMM_K1Z_ZMM_ZMMM512B32_IMM8: int = 3844
"""
``VSHUFF32X4 zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8``
``EVEX.512.66.0F3A.W0 23 /r ib``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VSHUFF64X2_YMM_K1Z_YMM_YMMM256B64_IMM8: int = 3845
"""
``VSHUFF64X2 ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8``
``EVEX.256.66.0F3A.W1 23 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VSHUFF64X2_ZMM_K1Z_ZMM_ZMMM512B64_IMM8: int = 3846
"""
``VSHUFF64X2 zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8``
``EVEX.512.66.0F3A.W1 23 /r ib``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPTERNLOGD_XMM_K1Z_XMM_XMMM128B32_IMM8: int = 3847
"""
``VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8``
``EVEX.128.66.0F3A.W0 25 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPTERNLOGD_YMM_K1Z_YMM_YMMM256B32_IMM8: int = 3848
"""
``VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8``
``EVEX.256.66.0F3A.W0 25 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPTERNLOGD_ZMM_K1Z_ZMM_ZMMM512B32_IMM8: int = 3849
"""
``VPTERNLOGD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8``
``EVEX.512.66.0F3A.W0 25 /r ib``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPTERNLOGQ_XMM_K1Z_XMM_XMMM128B64_IMM8: int = 3850
"""
``VPTERNLOGQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8``
``EVEX.128.66.0F3A.W1 25 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPTERNLOGQ_YMM_K1Z_YMM_YMMM256B64_IMM8: int = 3851
"""
``VPTERNLOGQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8``
``EVEX.256.66.0F3A.W1 25 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VPTERNLOGQ_ZMM_K1Z_ZMM_ZMMM512B64_IMM8: int = 3852
"""
``VPTERNLOGQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8``
``EVEX.512.66.0F3A.W1 25 /r ib``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VGETMANTPS_XMM_K1Z_XMMM128B32_IMM8: int = 3853
"""
``VGETMANTPS xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8``
``EVEX.128.66.0F3A.W0 26 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VGETMANTPS_YMM_K1Z_YMMM256B32_IMM8: int = 3854
"""
``VGETMANTPS ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8``
``EVEX.256.66.0F3A.W0 26 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VGETMANTPS_ZMM_K1Z_ZMMM512B32_IMM8_SAE: int = 3855
"""
``VGETMANTPS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}, imm8``
``EVEX.512.66.0F3A.W0 26 /r ib``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VGETMANTPD_XMM_K1Z_XMMM128B64_IMM8: int = 3856
"""
``VGETMANTPD xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8``
``EVEX.128.66.0F3A.W1 26 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VGETMANTPD_YMM_K1Z_YMMM256B64_IMM8: int = 3857
"""
``VGETMANTPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8``
``EVEX.256.66.0F3A.W1 26 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VGETMANTPD_ZMM_K1Z_ZMMM512B64_IMM8_SAE: int = 3858
"""
``VGETMANTPD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}, imm8``
``EVEX.512.66.0F3A.W1 26 /r ib``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VGETMANTSS_XMM_K1Z_XMM_XMMM32_IMM8_SAE: int = 3859
"""
``VGETMANTSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8``
``EVEX.LIG.66.0F3A.W0 27 /r ib``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VGETMANTSD_XMM_K1Z_XMM_XMMM64_IMM8_SAE: int = 3860
"""
``VGETMANTSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8``
``EVEX.LIG.66.0F3A.W1 27 /r ib``
``AVX512F``
``16/32/64-bit``
"""
VEX_KSHIFTRB_KR_KR_IMM8: int = 3861
"""
``KSHIFTRB k1, k2, imm8``
``VEX.L0.66.0F3A.W0 30 /r ib``
``AVX512DQ``
``16/32/64-bit``
"""
VEX_KSHIFTRW_KR_KR_IMM8: int = 3862
"""
``KSHIFTRW k1, k2, imm8``
``VEX.L0.66.0F3A.W1 30 /r ib``
``AVX512F``
``16/32/64-bit``
"""
VEX_KSHIFTRD_KR_KR_IMM8: int = 3863
"""
``KSHIFTRD k1, k2, imm8``
``VEX.L0.66.0F3A.W0 31 /r ib``
``AVX512BW``
``16/32/64-bit``
"""
VEX_KSHIFTRQ_KR_KR_IMM8: int = 3864
"""
``KSHIFTRQ k1, k2, imm8``
``VEX.L0.66.0F3A.W1 31 /r ib``
``AVX512BW``
``16/32/64-bit``
"""
VEX_KSHIFTLB_KR_KR_IMM8: int = 3865
"""
``KSHIFTLB k1, k2, imm8``
``VEX.L0.66.0F3A.W0 32 /r ib``
``AVX512DQ``
``16/32/64-bit``
"""
VEX_KSHIFTLW_KR_KR_IMM8: int = 3866
"""
``KSHIFTLW k1, k2, imm8``
``VEX.L0.66.0F3A.W1 32 /r ib``
``AVX512F``
``16/32/64-bit``
"""
VEX_KSHIFTLD_KR_KR_IMM8: int = 3867
"""
``KSHIFTLD k1, k2, imm8``
``VEX.L0.66.0F3A.W0 33 /r ib``
``AVX512BW``
``16/32/64-bit``
"""
VEX_KSHIFTLQ_KR_KR_IMM8: int = 3868
"""
``KSHIFTLQ k1, k2, imm8``
``VEX.L0.66.0F3A.W1 33 /r ib``
``AVX512BW``
``16/32/64-bit``
"""
VEX_VINSERTI128_YMM_YMM_XMMM128_IMM8: int = 3869
"""
``VINSERTI128 ymm1, ymm2, xmm3/m128, imm8``
``VEX.256.66.0F3A.W0 38 /r ib``
``AVX2``
``16/32/64-bit``
"""
EVEX_VINSERTI32X4_YMM_K1Z_YMM_XMMM128_IMM8: int = 3870
"""
``VINSERTI32X4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8``
``EVEX.256.66.0F3A.W0 38 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VINSERTI32X4_ZMM_K1Z_ZMM_XMMM128_IMM8: int = 3871
"""
``VINSERTI32X4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8``
``EVEX.512.66.0F3A.W0 38 /r ib``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VINSERTI64X2_YMM_K1Z_YMM_XMMM128_IMM8: int = 3872
"""
``VINSERTI64X2 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8``
``EVEX.256.66.0F3A.W1 38 /r ib``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VINSERTI64X2_ZMM_K1Z_ZMM_XMMM128_IMM8: int = 3873
"""
``VINSERTI64X2 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8``
``EVEX.512.66.0F3A.W1 38 /r ib``
``AVX512DQ``
``16/32/64-bit``
"""
VEX_VEXTRACTI128_XMMM128_YMM_IMM8: int = 3874
"""
``VEXTRACTI128 xmm1/m128, ymm2, imm8``
``VEX.256.66.0F3A.W0 39 /r ib``
``AVX2``
``16/32/64-bit``
"""
EVEX_VEXTRACTI32X4_XMMM128_K1Z_YMM_IMM8: int = 3875
"""
``VEXTRACTI32X4 xmm1/m128 {k1}{z}, ymm2, imm8``
``EVEX.256.66.0F3A.W0 39 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VEXTRACTI32X4_XMMM128_K1Z_ZMM_IMM8: int = 3876
"""
``VEXTRACTI32X4 xmm1/m128 {k1}{z}, zmm2, imm8``
``EVEX.512.66.0F3A.W0 39 /r ib``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VEXTRACTI64X2_XMMM128_K1Z_YMM_IMM8: int = 3877
"""
``VEXTRACTI64X2 xmm1/m128 {k1}{z}, ymm2, imm8``
``EVEX.256.66.0F3A.W1 39 /r ib``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VEXTRACTI64X2_XMMM128_K1Z_ZMM_IMM8: int = 3878
"""
``VEXTRACTI64X2 xmm1/m128 {k1}{z}, zmm2, imm8``
``EVEX.512.66.0F3A.W1 39 /r ib``
``AVX512DQ``
``16/32/64-bit``
"""
EVEX_VINSERTI32X8_ZMM_K1Z_ZMM_YMMM256_IMM8: int = 3879
"""
``VINSERTI32X8 zmm1 {k1}{z}, zmm2, ymm3/m256, imm8``
``EVEX.512.66.0F3A.W0 3A /r ib``
``AVX512DQ``
``16/32/64-bit``
"""
EVEX_VINSERTI64X4_ZMM_K1Z_ZMM_YMMM256_IMM8: int = 3880
"""
``VINSERTI64X4 zmm1 {k1}{z}, zmm2, ymm3/m256, imm8``
``EVEX.512.66.0F3A.W1 3A /r ib``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VEXTRACTI32X8_YMMM256_K1Z_ZMM_IMM8: int = 3881
"""
``VEXTRACTI32X8 ymm1/m256 {k1}{z}, zmm2, imm8``
``EVEX.512.66.0F3A.W0 3B /r ib``
``AVX512DQ``
``16/32/64-bit``
"""
EVEX_VEXTRACTI64X4_YMMM256_K1Z_ZMM_IMM8: int = 3882
"""
``VEXTRACTI64X4 ymm1/m256 {k1}{z}, zmm2, imm8``
``EVEX.512.66.0F3A.W1 3B /r ib``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VPCMPUB_KR_K1_XMM_XMMM128_IMM8: int = 3883
"""
``VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8``
``EVEX.128.66.0F3A.W0 3E /r ib``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPCMPUB_KR_K1_YMM_YMMM256_IMM8: int = 3884
"""
``VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8``
``EVEX.256.66.0F3A.W0 3E /r ib``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPCMPUB_KR_K1_ZMM_ZMMM512_IMM8: int = 3885
"""
``VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8``
``EVEX.512.66.0F3A.W0 3E /r ib``
``AVX512BW``
``16/32/64-bit``
"""
EVEX_VPCMPUW_KR_K1_XMM_XMMM128_IMM8: int = 3886
"""
``VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8``
``EVEX.128.66.0F3A.W1 3E /r ib``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPCMPUW_KR_K1_YMM_YMMM256_IMM8: int = 3887
"""
``VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8``
``EVEX.256.66.0F3A.W1 3E /r ib``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPCMPUW_KR_K1_ZMM_ZMMM512_IMM8: int = 3888
"""
``VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8``
``EVEX.512.66.0F3A.W1 3E /r ib``
``AVX512BW``
``16/32/64-bit``
"""
EVEX_VPCMPB_KR_K1_XMM_XMMM128_IMM8: int = 3889
"""
``VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8``
``EVEX.128.66.0F3A.W0 3F /r ib``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPCMPB_KR_K1_YMM_YMMM256_IMM8: int = 3890
"""
``VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8``
``EVEX.256.66.0F3A.W0 3F /r ib``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPCMPB_KR_K1_ZMM_ZMMM512_IMM8: int = 3891
"""
``VPCMPB k1 {k2}, zmm2, zmm3/m512, imm8``
``EVEX.512.66.0F3A.W0 3F /r ib``
``AVX512BW``
``16/32/64-bit``
"""
EVEX_VPCMPW_KR_K1_XMM_XMMM128_IMM8: int = 3892
"""
``VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8``
``EVEX.128.66.0F3A.W1 3F /r ib``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPCMPW_KR_K1_YMM_YMMM256_IMM8: int = 3893
"""
``VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8``
``EVEX.256.66.0F3A.W1 3F /r ib``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VPCMPW_KR_K1_ZMM_ZMMM512_IMM8: int = 3894
"""
``VPCMPW k1 {k2}, zmm2, zmm3/m512, imm8``
``EVEX.512.66.0F3A.W1 3F /r ib``
``AVX512BW``
``16/32/64-bit``
"""
DPPS_XMM_XMMM128_IMM8: int = 3895
"""
``DPPS xmm1, xmm2/m128, imm8``
``66 0F 3A 40 /r ib``
``SSE4.1``
``16/32/64-bit``
"""
VEX_VDPPS_XMM_XMM_XMMM128_IMM8: int = 3896
"""
``VDPPS xmm1, xmm2, xmm3/m128, imm8``
``VEX.128.66.0F3A.WIG 40 /r ib``
``AVX``
``16/32/64-bit``
"""
VEX_VDPPS_YMM_YMM_YMMM256_IMM8: int = 3897
"""
``VDPPS ymm1, ymm2, ymm3/m256, imm8``
``VEX.256.66.0F3A.WIG 40 /r ib``
``AVX``
``16/32/64-bit``
"""
DPPD_XMM_XMMM128_IMM8: int = 3898
"""
``DPPD xmm1, xmm2/m128, imm8``
``66 0F 3A 41 /r ib``
``SSE4.1``
``16/32/64-bit``
"""
VEX_VDPPD_XMM_XMM_XMMM128_IMM8: int = 3899
"""
``VDPPD xmm1, xmm2, xmm3/m128, imm8``
``VEX.128.66.0F3A.WIG 41 /r ib``
``AVX``
``16/32/64-bit``
"""
MPSADBW_XMM_XMMM128_IMM8: int = 3900
"""
``MPSADBW xmm1, xmm2/m128, imm8``
``66 0F 3A 42 /r ib``
``SSE4.1``
``16/32/64-bit``
"""
VEX_VMPSADBW_XMM_XMM_XMMM128_IMM8: int = 3901
"""
``VMPSADBW xmm1, xmm2, xmm3/m128, imm8``
``VEX.128.66.0F3A.WIG 42 /r ib``
``AVX``
``16/32/64-bit``
"""
VEX_VMPSADBW_YMM_YMM_YMMM256_IMM8: int = 3902
"""
``VMPSADBW ymm1, ymm2, ymm3/m256, imm8``
``VEX.256.66.0F3A.WIG 42 /r ib``
``AVX2``
``16/32/64-bit``
"""
EVEX_VDBPSADBW_XMM_K1Z_XMM_XMMM128_IMM8: int = 3903
"""
``VDBPSADBW xmm1 {k1}{z}, xmm2, xmm3/m128, imm8``
``EVEX.128.66.0F3A.W0 42 /r ib``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VDBPSADBW_YMM_K1Z_YMM_YMMM256_IMM8: int = 3904
"""
``VDBPSADBW ymm1 {k1}{z}, ymm2, ymm3/m256, imm8``
``EVEX.256.66.0F3A.W0 42 /r ib``
``AVX512VL and AVX512BW``
``16/32/64-bit``
"""
EVEX_VDBPSADBW_ZMM_K1Z_ZMM_ZMMM512_IMM8: int = 3905
"""
``VDBPSADBW zmm1 {k1}{z}, zmm2, zmm3/m512, imm8``
``EVEX.512.66.0F3A.W0 42 /r ib``
``AVX512BW``
``16/32/64-bit``
"""
EVEX_VSHUFI32X4_YMM_K1Z_YMM_YMMM256B32_IMM8: int = 3906
"""
``VSHUFI32X4 ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8``
``EVEX.256.66.0F3A.W0 43 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VSHUFI32X4_ZMM_K1Z_ZMM_ZMMM512B32_IMM8: int = 3907
"""
``VSHUFI32X4 zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8``
``EVEX.512.66.0F3A.W0 43 /r ib``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VSHUFI64X2_YMM_K1Z_YMM_YMMM256B64_IMM8: int = 3908
"""
``VSHUFI64X2 ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8``
``EVEX.256.66.0F3A.W1 43 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VSHUFI64X2_ZMM_K1Z_ZMM_ZMMM512B64_IMM8: int = 3909
"""
``VSHUFI64X2 zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8``
``EVEX.512.66.0F3A.W1 43 /r ib``
``AVX512F``
``16/32/64-bit``
"""
PCLMULQDQ_XMM_XMMM128_IMM8: int = 3910
"""
``PCLMULQDQ xmm1, xmm2/m128, imm8``
``66 0F 3A 44 /r ib``
``PCLMULQDQ``
``16/32/64-bit``
"""
VEX_VPCLMULQDQ_XMM_XMM_XMMM128_IMM8: int = 3911
"""
``VPCLMULQDQ xmm1, xmm2, xmm3/m128, imm8``
``VEX.128.66.0F3A.WIG 44 /r ib``
``PCLMULQDQ and AVX``
``16/32/64-bit``
"""
VEX_VPCLMULQDQ_YMM_YMM_YMMM256_IMM8: int = 3912
"""
``VPCLMULQDQ ymm1, ymm2, ymm3/m256, imm8``
``VEX.256.66.0F3A.WIG 44 /r ib``
``VPCLMULQDQ``
``16/32/64-bit``
"""
EVEX_VPCLMULQDQ_XMM_XMM_XMMM128_IMM8: int = 3913
"""
``VPCLMULQDQ xmm1, xmm2, xmm3/m128, imm8``
``EVEX.128.66.0F3A.WIG 44 /r ib``
``AVX512VL and VPCLMULQDQ``
``16/32/64-bit``
"""
EVEX_VPCLMULQDQ_YMM_YMM_YMMM256_IMM8: int = 3914
"""
``VPCLMULQDQ ymm1, ymm2, ymm3/m256, imm8``
``EVEX.256.66.0F3A.WIG 44 /r ib``
``AVX512VL and VPCLMULQDQ``
``16/32/64-bit``
"""
EVEX_VPCLMULQDQ_ZMM_ZMM_ZMMM512_IMM8: int = 3915
"""
``VPCLMULQDQ zmm1, zmm2, zmm3/m512, imm8``
``EVEX.512.66.0F3A.WIG 44 /r ib``
``AVX512F and VPCLMULQDQ``
``16/32/64-bit``
"""
VEX_VPERM2I128_YMM_YMM_YMMM256_IMM8: int = 3916
"""
``VPERM2I128 ymm1, ymm2, ymm3/m256, imm8``
``VEX.256.66.0F3A.W0 46 /r ib``
``AVX2``
``16/32/64-bit``
"""
VEX_VPERMIL2PS_XMM_XMM_XMMM128_XMM_IMM4: int = 3917
"""
``VPERMIL2PS xmm1, xmm2, xmm3/m128, xmm4, imm4``
``VEX.128.66.0F3A.W0 48 /r /is5``
``XOP``
``16/32/64-bit``
"""
VEX_VPERMIL2PS_YMM_YMM_YMMM256_YMM_IMM4: int = 3918
"""
``VPERMIL2PS ymm1, ymm2, ymm3/m256, ymm4, imm4``
``VEX.256.66.0F3A.W0 48 /r /is5``
``XOP``
``16/32/64-bit``
"""
VEX_VPERMIL2PS_XMM_XMM_XMM_XMMM128_IMM4: int = 3919
"""
``VPERMIL2PS xmm1, xmm2, xmm3, xmm4/m128, imm4``
``VEX.128.66.0F3A.W1 48 /r /is5``
``XOP``
``16/32/64-bit``
"""
VEX_VPERMIL2PS_YMM_YMM_YMM_YMMM256_IMM4: int = 3920
"""
``VPERMIL2PS ymm1, ymm2, ymm3, ymm4/m256, imm4``
``VEX.256.66.0F3A.W1 48 /r /is5``
``XOP``
``16/32/64-bit``
"""
VEX_VPERMIL2PD_XMM_XMM_XMMM128_XMM_IMM4: int = 3921
"""
``VPERMIL2PD xmm1, xmm2, xmm3/m128, xmm4, imm4``
``VEX.128.66.0F3A.W0 49 /r /is5``
``XOP``
``16/32/64-bit``
"""
VEX_VPERMIL2PD_YMM_YMM_YMMM256_YMM_IMM4: int = 3922
"""
``VPERMIL2PD ymm1, ymm2, ymm3/m256, ymm4, imm4``
``VEX.256.66.0F3A.W0 49 /r /is5``
``XOP``
``16/32/64-bit``
"""
VEX_VPERMIL2PD_XMM_XMM_XMM_XMMM128_IMM4: int = 3923
"""
``VPERMIL2PD xmm1, xmm2, xmm3, xmm4/m128, imm4``
``VEX.128.66.0F3A.W1 49 /r /is5``
``XOP``
``16/32/64-bit``
"""
VEX_VPERMIL2PD_YMM_YMM_YMM_YMMM256_IMM4: int = 3924
"""
``VPERMIL2PD ymm1, ymm2, ymm3, ymm4/m256, imm4``
``VEX.256.66.0F3A.W1 49 /r /is5``
``XOP``
``16/32/64-bit``
"""
VEX_VBLENDVPS_XMM_XMM_XMMM128_XMM: int = 3925
"""
``VBLENDVPS xmm1, xmm2, xmm3/m128, xmm4``
``VEX.128.66.0F3A.W0 4A /r /is4``
``AVX``
``16/32/64-bit``
"""
VEX_VBLENDVPS_YMM_YMM_YMMM256_YMM: int = 3926
"""
``VBLENDVPS ymm1, ymm2, ymm3/m256, ymm4``
``VEX.256.66.0F3A.W0 4A /r /is4``
``AVX``
``16/32/64-bit``
"""
VEX_VBLENDVPD_XMM_XMM_XMMM128_XMM: int = 3927
"""
``VBLENDVPD xmm1, xmm2, xmm3/m128, xmm4``
``VEX.128.66.0F3A.W0 4B /r /is4``
``AVX``
``16/32/64-bit``
"""
VEX_VBLENDVPD_YMM_YMM_YMMM256_YMM: int = 3928
"""
``VBLENDVPD ymm1, ymm2, ymm3/m256, ymm4``
``VEX.256.66.0F3A.W0 4B /r /is4``
``AVX``
``16/32/64-bit``
"""
VEX_VPBLENDVB_XMM_XMM_XMMM128_XMM: int = 3929
"""
``VPBLENDVB xmm1, xmm2, xmm3/m128, xmm4``
``VEX.128.66.0F3A.W0 4C /r /is4``
``AVX``
``16/32/64-bit``
"""
VEX_VPBLENDVB_YMM_YMM_YMMM256_YMM: int = 3930
"""
``VPBLENDVB ymm1, ymm2, ymm3/m256, ymm4``
``VEX.256.66.0F3A.W0 4C /r /is4``
``AVX2``
``16/32/64-bit``
"""
EVEX_VRANGEPS_XMM_K1Z_XMM_XMMM128B32_IMM8: int = 3931
"""
``VRANGEPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8``
``EVEX.128.66.0F3A.W0 50 /r ib``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VRANGEPS_YMM_K1Z_YMM_YMMM256B32_IMM8: int = 3932
"""
``VRANGEPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8``
``EVEX.256.66.0F3A.W0 50 /r ib``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VRANGEPS_ZMM_K1Z_ZMM_ZMMM512B32_IMM8_SAE: int = 3933
"""
``VRANGEPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{sae}, imm8``
``EVEX.512.66.0F3A.W0 50 /r ib``
``AVX512DQ``
``16/32/64-bit``
"""
EVEX_VRANGEPD_XMM_K1Z_XMM_XMMM128B64_IMM8: int = 3934
"""
``VRANGEPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8``
``EVEX.128.66.0F3A.W1 50 /r ib``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VRANGEPD_YMM_K1Z_YMM_YMMM256B64_IMM8: int = 3935
"""
``VRANGEPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8``
``EVEX.256.66.0F3A.W1 50 /r ib``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VRANGEPD_ZMM_K1Z_ZMM_ZMMM512B64_IMM8_SAE: int = 3936
"""
``VRANGEPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{sae}, imm8``
``EVEX.512.66.0F3A.W1 50 /r ib``
``AVX512DQ``
``16/32/64-bit``
"""
EVEX_VRANGESS_XMM_K1Z_XMM_XMMM32_IMM8_SAE: int = 3937
"""
``VRANGESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8``
``EVEX.LIG.66.0F3A.W0 51 /r ib``
``AVX512DQ``
``16/32/64-bit``
"""
EVEX_VRANGESD_XMM_K1Z_XMM_XMMM64_IMM8_SAE: int = 3938
"""
``VRANGESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8``
``EVEX.LIG.66.0F3A.W1 51 /r ib``
``AVX512DQ``
``16/32/64-bit``
"""
EVEX_VFIXUPIMMPS_XMM_K1Z_XMM_XMMM128B32_IMM8: int = 3939
"""
``VFIXUPIMMPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8``
``EVEX.128.66.0F3A.W0 54 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFIXUPIMMPS_YMM_K1Z_YMM_YMMM256B32_IMM8: int = 3940
"""
``VFIXUPIMMPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8``
``EVEX.256.66.0F3A.W0 54 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFIXUPIMMPS_ZMM_K1Z_ZMM_ZMMM512B32_IMM8_SAE: int = 3941
"""
``VFIXUPIMMPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{sae}, imm8``
``EVEX.512.66.0F3A.W0 54 /r ib``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VFIXUPIMMPD_XMM_K1Z_XMM_XMMM128B64_IMM8: int = 3942
"""
``VFIXUPIMMPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8``
``EVEX.128.66.0F3A.W1 54 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFIXUPIMMPD_YMM_K1Z_YMM_YMMM256B64_IMM8: int = 3943
"""
``VFIXUPIMMPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8``
``EVEX.256.66.0F3A.W1 54 /r ib``
``AVX512VL and AVX512F``
``16/32/64-bit``
"""
EVEX_VFIXUPIMMPD_ZMM_K1Z_ZMM_ZMMM512B64_IMM8_SAE: int = 3944
"""
``VFIXUPIMMPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{sae}, imm8``
``EVEX.512.66.0F3A.W1 54 /r ib``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VFIXUPIMMSS_XMM_K1Z_XMM_XMMM32_IMM8_SAE: int = 3945
"""
``VFIXUPIMMSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8``
``EVEX.LIG.66.0F3A.W0 55 /r ib``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VFIXUPIMMSD_XMM_K1Z_XMM_XMMM64_IMM8_SAE: int = 3946
"""
``VFIXUPIMMSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8``
``EVEX.LIG.66.0F3A.W1 55 /r ib``
``AVX512F``
``16/32/64-bit``
"""
EVEX_VREDUCEPS_XMM_K1Z_XMMM128B32_IMM8: int = 3947
"""
``VREDUCEPS xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8``
``EVEX.128.66.0F3A.W0 56 /r ib``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VREDUCEPS_YMM_K1Z_YMMM256B32_IMM8: int = 3948
"""
``VREDUCEPS ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8``
``EVEX.256.66.0F3A.W0 56 /r ib``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VREDUCEPS_ZMM_K1Z_ZMMM512B32_IMM8_SAE: int = 3949
"""
``VREDUCEPS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}, imm8``
``EVEX.512.66.0F3A.W0 56 /r ib``
``AVX512DQ``
``16/32/64-bit``
"""
EVEX_VREDUCEPD_XMM_K1Z_XMMM128B64_IMM8: int = 3950
"""
``VREDUCEPD xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8``
``EVEX.128.66.0F3A.W1 56 /r ib``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VREDUCEPD_YMM_K1Z_YMMM256B64_IMM8: int = 3951
"""
``VREDUCEPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8``
``EVEX.256.66.0F3A.W1 56 /r ib``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VREDUCEPD_ZMM_K1Z_ZMMM512B64_IMM8_SAE: int = 3952
"""
``VREDUCEPD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}, imm8``
``EVEX.512.66.0F3A.W1 56 /r ib``
``AVX512DQ``
``16/32/64-bit``
"""
EVEX_VREDUCESS_XMM_K1Z_XMM_XMMM32_IMM8_SAE: int = 3953
"""
``VREDUCESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8``
``EVEX.LIG.66.0F3A.W0 57 /r ib``
``AVX512DQ``
``16/32/64-bit``
"""
EVEX_VREDUCESD_XMM_K1Z_XMM_XMMM64_IMM8_SAE: int = 3954
"""
``VREDUCESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8``
``EVEX.LIG.66.0F3A.W1 57 /r ib``
``AVX512DQ``
``16/32/64-bit``
"""
VEX_VFMADDSUBPS_XMM_XMM_XMMM128_XMM: int = 3955
"""
``VFMADDSUBPS xmm1, xmm2, xmm3/m128, xmm4``
``VEX.128.66.0F3A.W0 5C /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFMADDSUBPS_YMM_YMM_YMMM256_YMM: int = 3956
"""
``VFMADDSUBPS ymm1, ymm2, ymm3/m256, ymm4``
``VEX.256.66.0F3A.W0 5C /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFMADDSUBPS_XMM_XMM_XMM_XMMM128: int = 3957
"""
``VFMADDSUBPS xmm1, xmm2, xmm3, xmm4/m128``
``VEX.128.66.0F3A.W1 5C /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFMADDSUBPS_YMM_YMM_YMM_YMMM256: int = 3958
"""
``VFMADDSUBPS ymm1, ymm2, ymm3, ymm4/m256``
``VEX.256.66.0F3A.W1 5C /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFMADDSUBPD_XMM_XMM_XMMM128_XMM: int = 3959
"""
``VFMADDSUBPD xmm1, xmm2, xmm3/m128, xmm4``
``VEX.128.66.0F3A.W0 5D /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFMADDSUBPD_YMM_YMM_YMMM256_YMM: int = 3960
"""
``VFMADDSUBPD ymm1, ymm2, ymm3/m256, ymm4``
``VEX.256.66.0F3A.W0 5D /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFMADDSUBPD_XMM_XMM_XMM_XMMM128: int = 3961
"""
``VFMADDSUBPD xmm1, xmm2, xmm3, xmm4/m128``
``VEX.128.66.0F3A.W1 5D /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFMADDSUBPD_YMM_YMM_YMM_YMMM256: int = 3962
"""
``VFMADDSUBPD ymm1, ymm2, ymm3, ymm4/m256``
``VEX.256.66.0F3A.W1 5D /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFMSUBADDPS_XMM_XMM_XMMM128_XMM: int = 3963
"""
``VFMSUBADDPS xmm1, xmm2, xmm3/m128, xmm4``
``VEX.128.66.0F3A.W0 5E /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFMSUBADDPS_YMM_YMM_YMMM256_YMM: int = 3964
"""
``VFMSUBADDPS ymm1, ymm2, ymm3/m256, ymm4``
``VEX.256.66.0F3A.W0 5E /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFMSUBADDPS_XMM_XMM_XMM_XMMM128: int = 3965
"""
``VFMSUBADDPS xmm1, xmm2, xmm3, xmm4/m128``
``VEX.128.66.0F3A.W1 5E /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFMSUBADDPS_YMM_YMM_YMM_YMMM256: int = 3966
"""
``VFMSUBADDPS ymm1, ymm2, ymm3, ymm4/m256``
``VEX.256.66.0F3A.W1 5E /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFMSUBADDPD_XMM_XMM_XMMM128_XMM: int = 3967
"""
``VFMSUBADDPD xmm1, xmm2, xmm3/m128, xmm4``
``VEX.128.66.0F3A.W0 5F /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFMSUBADDPD_YMM_YMM_YMMM256_YMM: int = 3968
"""
``VFMSUBADDPD ymm1, ymm2, ymm3/m256, ymm4``
``VEX.256.66.0F3A.W0 5F /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFMSUBADDPD_XMM_XMM_XMM_XMMM128: int = 3969
"""
``VFMSUBADDPD xmm1, xmm2, xmm3, xmm4/m128``
``VEX.128.66.0F3A.W1 5F /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFMSUBADDPD_YMM_YMM_YMM_YMMM256: int = 3970
"""
``VFMSUBADDPD ymm1, ymm2, ymm3, ymm4/m256``
``VEX.256.66.0F3A.W1 5F /r /is4``
``FMA4``
``16/32/64-bit``
"""
PCMPESTRM_XMM_XMMM128_IMM8: int = 3971
"""
``PCMPESTRM xmm1, xmm2/m128, imm8``
``66 0F 3A 60 /r ib``
``SSE4.2``
``16/32/64-bit``
"""
PCMPESTRM64_XMM_XMMM128_IMM8: int = 3972
"""
``PCMPESTRM64 xmm1, xmm2/m128, imm8``
``66 o64 0F 3A 60 /r ib``
``SSE4.2``
``64-bit``
"""
VEX_VPCMPESTRM_XMM_XMMM128_IMM8: int = 3973
"""
``VPCMPESTRM xmm1, xmm2/m128, imm8``
``VEX.128.66.0F3A.W0 60 /r ib``
``AVX``
``16/32/64-bit``
"""
VEX_VPCMPESTRM64_XMM_XMMM128_IMM8: int = 3974
"""
``VPCMPESTRM64 xmm1, xmm2/m128, imm8``
``VEX.128.66.0F3A.W1 60 /r ib``
``AVX``
``64-bit``
"""
PCMPESTRI_XMM_XMMM128_IMM8: int = 3975
"""
``PCMPESTRI xmm1, xmm2/m128, imm8``
``66 0F 3A 61 /r ib``
``SSE4.2``
``16/32/64-bit``
"""
PCMPESTRI64_XMM_XMMM128_IMM8: int = 3976
"""
``PCMPESTRI64 xmm1, xmm2/m128, imm8``
``66 o64 0F 3A 61 /r ib``
``SSE4.2``
``64-bit``
"""
VEX_VPCMPESTRI_XMM_XMMM128_IMM8: int = 3977
"""
``VPCMPESTRI xmm1, xmm2/m128, imm8``
``VEX.128.66.0F3A.W0 61 /r ib``
``AVX``
``16/32/64-bit``
"""
VEX_VPCMPESTRI64_XMM_XMMM128_IMM8: int = 3978
"""
``VPCMPESTRI64 xmm1, xmm2/m128, imm8``
``VEX.128.66.0F3A.W1 61 /r ib``
``AVX``
``64-bit``
"""
PCMPISTRM_XMM_XMMM128_IMM8: int = 3979
"""
``PCMPISTRM xmm1, xmm2/m128, imm8``
``66 0F 3A 62 /r ib``
``SSE4.2``
``16/32/64-bit``
"""
VEX_VPCMPISTRM_XMM_XMMM128_IMM8: int = 3980
"""
``VPCMPISTRM xmm1, xmm2/m128, imm8``
``VEX.128.66.0F3A.WIG 62 /r ib``
``AVX``
``16/32/64-bit``
"""
PCMPISTRI_XMM_XMMM128_IMM8: int = 3981
"""
``PCMPISTRI xmm1, xmm2/m128, imm8``
``66 0F 3A 63 /r ib``
``SSE4.2``
``16/32/64-bit``
"""
VEX_VPCMPISTRI_XMM_XMMM128_IMM8: int = 3982
"""
``VPCMPISTRI xmm1, xmm2/m128, imm8``
``VEX.128.66.0F3A.WIG 63 /r ib``
``AVX``
``16/32/64-bit``
"""
EVEX_VFPCLASSPS_KR_K1_XMMM128B32_IMM8: int = 3983
"""
``VFPCLASSPS k2 {k1}, xmm2/m128/m32bcst, imm8``
``EVEX.128.66.0F3A.W0 66 /r ib``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VFPCLASSPS_KR_K1_YMMM256B32_IMM8: int = 3984
"""
``VFPCLASSPS k2 {k1}, ymm2/m256/m32bcst, imm8``
``EVEX.256.66.0F3A.W0 66 /r ib``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VFPCLASSPS_KR_K1_ZMMM512B32_IMM8: int = 3985
"""
``VFPCLASSPS k2 {k1}, zmm2/m512/m32bcst, imm8``
``EVEX.512.66.0F3A.W0 66 /r ib``
``AVX512DQ``
``16/32/64-bit``
"""
EVEX_VFPCLASSPD_KR_K1_XMMM128B64_IMM8: int = 3986
"""
``VFPCLASSPD k2 {k1}, xmm2/m128/m64bcst, imm8``
``EVEX.128.66.0F3A.W1 66 /r ib``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VFPCLASSPD_KR_K1_YMMM256B64_IMM8: int = 3987
"""
``VFPCLASSPD k2 {k1}, ymm2/m256/m64bcst, imm8``
``EVEX.256.66.0F3A.W1 66 /r ib``
``AVX512VL and AVX512DQ``
``16/32/64-bit``
"""
EVEX_VFPCLASSPD_KR_K1_ZMMM512B64_IMM8: int = 3988
"""
``VFPCLASSPD k2 {k1}, zmm2/m512/m64bcst, imm8``
``EVEX.512.66.0F3A.W1 66 /r ib``
``AVX512DQ``
``16/32/64-bit``
"""
EVEX_VFPCLASSSS_KR_K1_XMMM32_IMM8: int = 3989
"""
``VFPCLASSSS k2 {k1}, xmm2/m32, imm8``
``EVEX.LIG.66.0F3A.W0 67 /r ib``
``AVX512DQ``
``16/32/64-bit``
"""
EVEX_VFPCLASSSD_KR_K1_XMMM64_IMM8: int = 3990
"""
``VFPCLASSSD k2 {k1}, xmm2/m64, imm8``
``EVEX.LIG.66.0F3A.W1 67 /r ib``
``AVX512DQ``
``16/32/64-bit``
"""
VEX_VFMADDPS_XMM_XMM_XMMM128_XMM: int = 3991
"""
``VFMADDPS xmm1, xmm2, xmm3/m128, xmm4``
``VEX.128.66.0F3A.W0 68 /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFMADDPS_YMM_YMM_YMMM256_YMM: int = 3992
"""
``VFMADDPS ymm1, ymm2, ymm3/m256, ymm4``
``VEX.256.66.0F3A.W0 68 /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFMADDPS_XMM_XMM_XMM_XMMM128: int = 3993
"""
``VFMADDPS xmm1, xmm2, xmm3, xmm4/m128``
``VEX.128.66.0F3A.W1 68 /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFMADDPS_YMM_YMM_YMM_YMMM256: int = 3994
"""
``VFMADDPS ymm1, ymm2, ymm3, ymm4/m256``
``VEX.256.66.0F3A.W1 68 /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFMADDPD_XMM_XMM_XMMM128_XMM: int = 3995
"""
``VFMADDPD xmm1, xmm2, xmm3/m128, xmm4``
``VEX.128.66.0F3A.W0 69 /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFMADDPD_YMM_YMM_YMMM256_YMM: int = 3996
"""
``VFMADDPD ymm1, ymm2, ymm3/m256, ymm4``
``VEX.256.66.0F3A.W0 69 /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFMADDPD_XMM_XMM_XMM_XMMM128: int = 3997
"""
``VFMADDPD xmm1, xmm2, xmm3, xmm4/m128``
``VEX.128.66.0F3A.W1 69 /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFMADDPD_YMM_YMM_YMM_YMMM256: int = 3998
"""
``VFMADDPD ymm1, ymm2, ymm3, ymm4/m256``
``VEX.256.66.0F3A.W1 69 /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFMADDSS_XMM_XMM_XMMM32_XMM: int = 3999
"""
``VFMADDSS xmm1, xmm2, xmm3/m32, xmm4``
``VEX.LIG.66.0F3A.W0 6A /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFMADDSS_XMM_XMM_XMM_XMMM32: int = 4000
"""
``VFMADDSS xmm1, xmm2, xmm3, xmm4/m32``
``VEX.LIG.66.0F3A.W1 6A /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFMADDSD_XMM_XMM_XMMM64_XMM: int = 4001
"""
``VFMADDSD xmm1, xmm2, xmm3/m64, xmm4``
``VEX.LIG.66.0F3A.W0 6B /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFMADDSD_XMM_XMM_XMM_XMMM64: int = 4002
"""
``VFMADDSD xmm1, xmm2, xmm3, xmm4/m64``
``VEX.LIG.66.0F3A.W1 6B /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFMSUBPS_XMM_XMM_XMMM128_XMM: int = 4003
"""
``VFMSUBPS xmm1, xmm2, xmm3/m128, xmm4``
``VEX.128.66.0F3A.W0 6C /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFMSUBPS_YMM_YMM_YMMM256_YMM: int = 4004
"""
``VFMSUBPS ymm1, ymm2, ymm3/m256, ymm4``
``VEX.256.66.0F3A.W0 6C /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFMSUBPS_XMM_XMM_XMM_XMMM128: int = 4005
"""
``VFMSUBPS xmm1, xmm2, xmm3, xmm4/m128``
``VEX.128.66.0F3A.W1 6C /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFMSUBPS_YMM_YMM_YMM_YMMM256: int = 4006
"""
``VFMSUBPS ymm1, ymm2, ymm3, ymm4/m256``
``VEX.256.66.0F3A.W1 6C /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFMSUBPD_XMM_XMM_XMMM128_XMM: int = 4007
"""
``VFMSUBPD xmm1, xmm2, xmm3/m128, xmm4``
``VEX.128.66.0F3A.W0 6D /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFMSUBPD_YMM_YMM_YMMM256_YMM: int = 4008
"""
``VFMSUBPD ymm1, ymm2, ymm3/m256, ymm4``
``VEX.256.66.0F3A.W0 6D /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFMSUBPD_XMM_XMM_XMM_XMMM128: int = 4009
"""
``VFMSUBPD xmm1, xmm2, xmm3, xmm4/m128``
``VEX.128.66.0F3A.W1 6D /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFMSUBPD_YMM_YMM_YMM_YMMM256: int = 4010
"""
``VFMSUBPD ymm1, ymm2, ymm3, ymm4/m256``
``VEX.256.66.0F3A.W1 6D /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFMSUBSS_XMM_XMM_XMMM32_XMM: int = 4011
"""
``VFMSUBSS xmm1, xmm2, xmm3/m32, xmm4``
``VEX.LIG.66.0F3A.W0 6E /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFMSUBSS_XMM_XMM_XMM_XMMM32: int = 4012
"""
``VFMSUBSS xmm1, xmm2, xmm3, xmm4/m32``
``VEX.LIG.66.0F3A.W1 6E /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFMSUBSD_XMM_XMM_XMMM64_XMM: int = 4013
"""
``VFMSUBSD xmm1, xmm2, xmm3/m64, xmm4``
``VEX.LIG.66.0F3A.W0 6F /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFMSUBSD_XMM_XMM_XMM_XMMM64: int = 4014
"""
``VFMSUBSD xmm1, xmm2, xmm3, xmm4/m64``
``VEX.LIG.66.0F3A.W1 6F /r /is4``
``FMA4``
``16/32/64-bit``
"""
EVEX_VPSHLDW_XMM_K1Z_XMM_XMMM128_IMM8: int = 4015
"""
``VPSHLDW xmm1 {k1}{z}, xmm2, xmm3/m128, imm8``
``EVEX.128.66.0F3A.W1 70 /r ib``
``AVX512VL and AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPSHLDW_YMM_K1Z_YMM_YMMM256_IMM8: int = 4016
"""
``VPSHLDW ymm1 {k1}{z}, ymm2, ymm3/m256, imm8``
``EVEX.256.66.0F3A.W1 70 /r ib``
``AVX512VL and AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPSHLDW_ZMM_K1Z_ZMM_ZMMM512_IMM8: int = 4017
"""
``VPSHLDW zmm1 {k1}{z}, zmm2, zmm3/m512, imm8``
``EVEX.512.66.0F3A.W1 70 /r ib``
``AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPSHLDD_XMM_K1Z_XMM_XMMM128B32_IMM8: int = 4018
"""
``VPSHLDD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8``
``EVEX.128.66.0F3A.W0 71 /r ib``
``AVX512VL and AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPSHLDD_YMM_K1Z_YMM_YMMM256B32_IMM8: int = 4019
"""
``VPSHLDD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8``
``EVEX.256.66.0F3A.W0 71 /r ib``
``AVX512VL and AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPSHLDD_ZMM_K1Z_ZMM_ZMMM512B32_IMM8: int = 4020
"""
``VPSHLDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8``
``EVEX.512.66.0F3A.W0 71 /r ib``
``AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPSHLDQ_XMM_K1Z_XMM_XMMM128B64_IMM8: int = 4021
"""
``VPSHLDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8``
``EVEX.128.66.0F3A.W1 71 /r ib``
``AVX512VL and AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPSHLDQ_YMM_K1Z_YMM_YMMM256B64_IMM8: int = 4022
"""
``VPSHLDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8``
``EVEX.256.66.0F3A.W1 71 /r ib``
``AVX512VL and AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPSHLDQ_ZMM_K1Z_ZMM_ZMMM512B64_IMM8: int = 4023
"""
``VPSHLDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8``
``EVEX.512.66.0F3A.W1 71 /r ib``
``AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPSHRDW_XMM_K1Z_XMM_XMMM128_IMM8: int = 4024
"""
``VPSHRDW xmm1 {k1}{z}, xmm2, xmm3/m128, imm8``
``EVEX.128.66.0F3A.W1 72 /r ib``
``AVX512VL and AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPSHRDW_YMM_K1Z_YMM_YMMM256_IMM8: int = 4025
"""
``VPSHRDW ymm1 {k1}{z}, ymm2, ymm3/m256, imm8``
``EVEX.256.66.0F3A.W1 72 /r ib``
``AVX512VL and AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPSHRDW_ZMM_K1Z_ZMM_ZMMM512_IMM8: int = 4026
"""
``VPSHRDW zmm1 {k1}{z}, zmm2, zmm3/m512, imm8``
``EVEX.512.66.0F3A.W1 72 /r ib``
``AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPSHRDD_XMM_K1Z_XMM_XMMM128B32_IMM8: int = 4027
"""
``VPSHRDD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8``
``EVEX.128.66.0F3A.W0 73 /r ib``
``AVX512VL and AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPSHRDD_YMM_K1Z_YMM_YMMM256B32_IMM8: int = 4028
"""
``VPSHRDD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8``
``EVEX.256.66.0F3A.W0 73 /r ib``
``AVX512VL and AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPSHRDD_ZMM_K1Z_ZMM_ZMMM512B32_IMM8: int = 4029
"""
``VPSHRDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8``
``EVEX.512.66.0F3A.W0 73 /r ib``
``AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPSHRDQ_XMM_K1Z_XMM_XMMM128B64_IMM8: int = 4030
"""
``VPSHRDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8``
``EVEX.128.66.0F3A.W1 73 /r ib``
``AVX512VL and AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPSHRDQ_YMM_K1Z_YMM_YMMM256B64_IMM8: int = 4031
"""
``VPSHRDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8``
``EVEX.256.66.0F3A.W1 73 /r ib``
``AVX512VL and AVX512_VBMI2``
``16/32/64-bit``
"""
EVEX_VPSHRDQ_ZMM_K1Z_ZMM_ZMMM512B64_IMM8: int = 4032
"""
``VPSHRDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8``
``EVEX.512.66.0F3A.W1 73 /r ib``
``AVX512_VBMI2``
``16/32/64-bit``
"""
VEX_VFNMADDPS_XMM_XMM_XMMM128_XMM: int = 4033
"""
``VFNMADDPS xmm1, xmm2, xmm3/m128, xmm4``
``VEX.128.66.0F3A.W0 78 /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFNMADDPS_YMM_YMM_YMMM256_YMM: int = 4034
"""
``VFNMADDPS ymm1, ymm2, ymm3/m256, ymm4``
``VEX.256.66.0F3A.W0 78 /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFNMADDPS_XMM_XMM_XMM_XMMM128: int = 4035
"""
``VFNMADDPS xmm1, xmm2, xmm3, xmm4/m128``
``VEX.128.66.0F3A.W1 78 /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFNMADDPS_YMM_YMM_YMM_YMMM256: int = 4036
"""
``VFNMADDPS ymm1, ymm2, ymm3, ymm4/m256``
``VEX.256.66.0F3A.W1 78 /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFNMADDPD_XMM_XMM_XMMM128_XMM: int = 4037
"""
``VFNMADDPD xmm1, xmm2, xmm3/m128, xmm4``
``VEX.128.66.0F3A.W0 79 /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFNMADDPD_YMM_YMM_YMMM256_YMM: int = 4038
"""
``VFNMADDPD ymm1, ymm2, ymm3/m256, ymm4``
``VEX.256.66.0F3A.W0 79 /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFNMADDPD_XMM_XMM_XMM_XMMM128: int = 4039
"""
``VFNMADDPD xmm1, xmm2, xmm3, xmm4/m128``
``VEX.128.66.0F3A.W1 79 /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFNMADDPD_YMM_YMM_YMM_YMMM256: int = 4040
"""
``VFNMADDPD ymm1, ymm2, ymm3, ymm4/m256``
``VEX.256.66.0F3A.W1 79 /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFNMADDSS_XMM_XMM_XMMM32_XMM: int = 4041
"""
``VFNMADDSS xmm1, xmm2, xmm3/m32, xmm4``
``VEX.LIG.66.0F3A.W0 7A /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFNMADDSS_XMM_XMM_XMM_XMMM32: int = 4042
"""
``VFNMADDSS xmm1, xmm2, xmm3, xmm4/m32``
``VEX.LIG.66.0F3A.W1 7A /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFNMADDSD_XMM_XMM_XMMM64_XMM: int = 4043
"""
``VFNMADDSD xmm1, xmm2, xmm3/m64, xmm4``
``VEX.LIG.66.0F3A.W0 7B /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFNMADDSD_XMM_XMM_XMM_XMMM64: int = 4044
"""
``VFNMADDSD xmm1, xmm2, xmm3, xmm4/m64``
``VEX.LIG.66.0F3A.W1 7B /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFNMSUBPS_XMM_XMM_XMMM128_XMM: int = 4045
"""
``VFNMSUBPS xmm1, xmm2, xmm3/m128, xmm4``
``VEX.128.66.0F3A.W0 7C /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFNMSUBPS_YMM_YMM_YMMM256_YMM: int = 4046
"""
``VFNMSUBPS ymm1, ymm2, ymm3/m256, ymm4``
``VEX.256.66.0F3A.W0 7C /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFNMSUBPS_XMM_XMM_XMM_XMMM128: int = 4047
"""
``VFNMSUBPS xmm1, xmm2, xmm3, xmm4/m128``
``VEX.128.66.0F3A.W1 7C /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFNMSUBPS_YMM_YMM_YMM_YMMM256: int = 4048
"""
``VFNMSUBPS ymm1, ymm2, ymm3, ymm4/m256``
``VEX.256.66.0F3A.W1 7C /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFNMSUBPD_XMM_XMM_XMMM128_XMM: int = 4049
"""
``VFNMSUBPD xmm1, xmm2, xmm3/m128, xmm4``
``VEX.128.66.0F3A.W0 7D /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFNMSUBPD_YMM_YMM_YMMM256_YMM: int = 4050
"""
``VFNMSUBPD ymm1, ymm2, ymm3/m256, ymm4``
``VEX.256.66.0F3A.W0 7D /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFNMSUBPD_XMM_XMM_XMM_XMMM128: int = 4051
"""
``VFNMSUBPD xmm1, xmm2, xmm3, xmm4/m128``
``VEX.128.66.0F3A.W1 7D /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFNMSUBPD_YMM_YMM_YMM_YMMM256: int = 4052
"""
``VFNMSUBPD ymm1, ymm2, ymm3, ymm4/m256``
``VEX.256.66.0F3A.W1 7D /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFNMSUBSS_XMM_XMM_XMMM32_XMM: int = 4053
"""
``VFNMSUBSS xmm1, xmm2, xmm3/m32, xmm4``
``VEX.LIG.66.0F3A.W0 7E /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFNMSUBSS_XMM_XMM_XMM_XMMM32: int = 4054
"""
``VFNMSUBSS xmm1, xmm2, xmm3, xmm4/m32``
``VEX.LIG.66.0F3A.W1 7E /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFNMSUBSD_XMM_XMM_XMMM64_XMM: int = 4055
"""
``VFNMSUBSD xmm1, xmm2, xmm3/m64, xmm4``
``VEX.LIG.66.0F3A.W0 7F /r /is4``
``FMA4``
``16/32/64-bit``
"""
VEX_VFNMSUBSD_XMM_XMM_XMM_XMMM64: int = 4056
"""
``VFNMSUBSD xmm1, xmm2, xmm3, xmm4/m64``
``VEX.LIG.66.0F3A.W1 7F /r /is4``
``FMA4``
``16/32/64-bit``
"""
SHA1RNDS4_XMM_XMMM128_IMM8: int = 4057
"""
``SHA1RNDS4 xmm1, xmm2/m128, imm8``
``NP 0F 3A CC /r ib``
``SHA``
``16/32/64-bit``
"""
GF2P8AFFINEQB_XMM_XMMM128_IMM8: int = 4058
"""
``GF2P8AFFINEQB xmm1, xmm2/m128, imm8``
``66 0F 3A CE /r ib``
``GFNI``
``16/32/64-bit``
"""
VEX_VGF2P8AFFINEQB_XMM_XMM_XMMM128_IMM8: int = 4059
"""
``VGF2P8AFFINEQB xmm1, xmm2, xmm3/m128, imm8``
``VEX.128.66.0F3A.W1 CE /r ib``
``AVX and GFNI``
``16/32/64-bit``
"""
VEX_VGF2P8AFFINEQB_YMM_YMM_YMMM256_IMM8: int = 4060
"""
``VGF2P8AFFINEQB ymm1, ymm2, ymm3/m256, imm8``
``VEX.256.66.0F3A.W1 CE /r ib``
``AVX and GFNI``
``16/32/64-bit``
"""
EVEX_VGF2P8AFFINEQB_XMM_K1Z_XMM_XMMM128B64_IMM8: int = 4061
"""
``VGF2P8AFFINEQB xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8``
``EVEX.128.66.0F3A.W1 CE /r ib``
``AVX512VL and GFNI``
``16/32/64-bit``
"""
EVEX_VGF2P8AFFINEQB_YMM_K1Z_YMM_YMMM256B64_IMM8: int = 4062
"""
``VGF2P8AFFINEQB ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8``
``EVEX.256.66.0F3A.W1 CE /r ib``
``AVX512VL and GFNI``
``16/32/64-bit``
"""
EVEX_VGF2P8AFFINEQB_ZMM_K1Z_ZMM_ZMMM512B64_IMM8: int = 4063
"""
``VGF2P8AFFINEQB zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8``
``EVEX.512.66.0F3A.W1 CE /r ib``
``AVX512F and GFNI``
``16/32/64-bit``
"""
GF2P8AFFINEINVQB_XMM_XMMM128_IMM8: int = 4064
"""
``GF2P8AFFINEINVQB xmm1, xmm2/m128, imm8``
``66 0F 3A CF /r ib``
``GFNI``
``16/32/64-bit``
"""
VEX_VGF2P8AFFINEINVQB_XMM_XMM_XMMM128_IMM8: int = 4065
"""
``VGF2P8AFFINEINVQB xmm1, xmm2, xmm3/m128, imm8``
``VEX.128.66.0F3A.W1 CF /r ib``
``AVX and GFNI``
``16/32/64-bit``
"""
VEX_VGF2P8AFFINEINVQB_YMM_YMM_YMMM256_IMM8: int = 4066
"""
``VGF2P8AFFINEINVQB ymm1, ymm2, ymm3/m256, imm8``
``VEX.256.66.0F3A.W1 CF /r ib``
``AVX and GFNI``
``16/32/64-bit``
"""
EVEX_VGF2P8AFFINEINVQB_XMM_K1Z_XMM_XMMM128B64_IMM8: int = 4067
"""
``VGF2P8AFFINEINVQB xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8``
``EVEX.128.66.0F3A.W1 CF /r ib``
``AVX512VL and GFNI``
``16/32/64-bit``
"""
EVEX_VGF2P8AFFINEINVQB_YMM_K1Z_YMM_YMMM256B64_IMM8: int = 4068
"""
``VGF2P8AFFINEINVQB ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8``
``EVEX.256.66.0F3A.W1 CF /r ib``
``AVX512VL and GFNI``
``16/32/64-bit``
"""
EVEX_VGF2P8AFFINEINVQB_ZMM_K1Z_ZMM_ZMMM512B64_IMM8: int = 4069
"""
``VGF2P8AFFINEINVQB zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8``
``EVEX.512.66.0F3A.W1 CF /r ib``
``AVX512F and GFNI``
``16/32/64-bit``
"""
AESKEYGENASSIST_XMM_XMMM128_IMM8: int = 4070
"""
``AESKEYGENASSIST xmm1, xmm2/m128, imm8``
``66 0F 3A DF /r ib``
``AES``
``16/32/64-bit``
"""
VEX_VAESKEYGENASSIST_XMM_XMMM128_IMM8: int = 4071
"""
``VAESKEYGENASSIST xmm1, xmm2/m128, imm8``
``VEX.128.66.0F3A.WIG DF /r ib``
``AES and AVX``
``16/32/64-bit``
"""
VEX_RORX_R32_RM32_IMM8: int = 4072
"""
``RORX r32, r/m32, imm8``
``VEX.LZ.F2.0F3A.W0 F0 /r ib``
``BMI2``
``16/32/64-bit``
"""
VEX_RORX_R64_RM64_IMM8: int = 4073
"""
``RORX r64, r/m64, imm8``
``VEX.LZ.F2.0F3A.W1 F0 /r ib``
``BMI2``
``64-bit``
"""
XOP_VPMACSSWW_XMM_XMM_XMMM128_XMM: int = 4074
"""
``VPMACSSWW xmm1, xmm2, xmm3/m128, xmm4``
``XOP.128.X8.W0 85 /r /is4``
``XOP``
``16/32/64-bit``
"""
XOP_VPMACSSWD_XMM_XMM_XMMM128_XMM: int = 4075
"""
``VPMACSSWD xmm1, xmm2, xmm3/m128, xmm4``
``XOP.128.X8.W0 86 /r /is4``
``XOP``
``16/32/64-bit``
"""
XOP_VPMACSSDQL_XMM_XMM_XMMM128_XMM: int = 4076
"""
``VPMACSSDQL xmm1, xmm2, xmm3/m128, xmm4``
``XOP.128.X8.W0 87 /r /is4``
``XOP``
``16/32/64-bit``
"""
XOP_VPMACSSDD_XMM_XMM_XMMM128_XMM: int = 4077
"""
``VPMACSSDD xmm1, xmm2, xmm3/m128, xmm4``
``XOP.128.X8.W0 8E /r /is4``
``XOP``
``16/32/64-bit``
"""
XOP_VPMACSSDQH_XMM_XMM_XMMM128_XMM: int = 4078
"""
``VPMACSSDQH xmm1, xmm2, xmm3/m128, xmm4``
``XOP.128.X8.W0 8F /r /is4``
``XOP``
``16/32/64-bit``
"""
XOP_VPMACSWW_XMM_XMM_XMMM128_XMM: int = 4079
"""
``VPMACSWW xmm1, xmm2, xmm3/m128, xmm4``
``XOP.128.X8.W0 95 /r /is4``
``XOP``
``16/32/64-bit``
"""
XOP_VPMACSWD_XMM_XMM_XMMM128_XMM: int = 4080
"""
``VPMACSWD xmm1, xmm2, xmm3/m128, xmm4``
``XOP.128.X8.W0 96 /r /is4``
``XOP``
``16/32/64-bit``
"""
XOP_VPMACSDQL_XMM_XMM_XMMM128_XMM: int = 4081
"""
``VPMACSDQL xmm1, xmm2, xmm3/m128, xmm4``
``XOP.128.X8.W0 97 /r /is4``
``XOP``
``16/32/64-bit``
"""
XOP_VPMACSDD_XMM_XMM_XMMM128_XMM: int = 4082
"""
``VPMACSDD xmm1, xmm2, xmm3/m128, xmm4``
``XOP.128.X8.W0 9E /r /is4``
``XOP``
``16/32/64-bit``
"""
XOP_VPMACSDQH_XMM_XMM_XMMM128_XMM: int = 4083
"""
``VPMACSDQH xmm1, xmm2, xmm3/m128, xmm4``
``XOP.128.X8.W0 9F /r /is4``
``XOP``
``16/32/64-bit``
"""
XOP_VPCMOV_XMM_XMM_XMMM128_XMM: int = 4084
"""
``VPCMOV xmm1, xmm2, xmm3/m128, xmm4``
``XOP.128.X8.W0 A2 /r /is4``
``XOP``
``16/32/64-bit``
"""
XOP_VPCMOV_YMM_YMM_YMMM256_YMM: int = 4085
"""
``VPCMOV ymm1, ymm2, ymm3/m256, ymm4``
``XOP.256.X8.W0 A2 /r /is4``
``XOP``
``16/32/64-bit``
"""
XOP_VPCMOV_XMM_XMM_XMM_XMMM128: int = 4086
"""
``VPCMOV xmm1, xmm2, xmm3, xmm4/m128``
``XOP.128.X8.W1 A2 /r /is4``
``XOP``
``16/32/64-bit``
"""
XOP_VPCMOV_YMM_YMM_YMM_YMMM256: int = 4087
"""
``VPCMOV ymm1, ymm2, ymm3, ymm4/m256``
``XOP.256.X8.W1 A2 /r /is4``
``XOP``
``16/32/64-bit``
"""
XOP_VPPERM_XMM_XMM_XMMM128_XMM: int = 4088
"""
``VPPERM xmm1, xmm2, xmm3/m128, xmm4``
``XOP.128.X8.W0 A3 /r /is4``
``XOP``
``16/32/64-bit``
"""
XOP_VPPERM_XMM_XMM_XMM_XMMM128: int = 4089
"""
``VPPERM xmm1, xmm2, xmm3, xmm4/m128``
``XOP.128.X8.W1 A3 /r /is4``
``XOP``
``16/32/64-bit``
"""
XOP_VPMADCSSWD_XMM_XMM_XMMM128_XMM: int = 4090
"""
``VPMADCSSWD xmm1, xmm2, xmm3/m128, xmm4``
``XOP.128.X8.W0 A6 /r /is4``
``XOP``
``16/32/64-bit``
"""
XOP_VPMADCSWD_XMM_XMM_XMMM128_XMM: int = 4091
"""
``VPMADCSWD xmm1, xmm2, xmm3/m128, xmm4``
``XOP.128.X8.W0 B6 /r /is4``
``XOP``
``16/32/64-bit``
"""
XOP_VPROTB_XMM_XMMM128_IMM8: int = 4092
"""
``VPROTB xmm1, xmm2/m128, imm8``
``XOP.128.X8.W0 C0 /r ib``
``XOP``
``16/32/64-bit``
"""
XOP_VPROTW_XMM_XMMM128_IMM8: int = 4093
"""
``VPROTW xmm1, xmm2/m128, imm8``
``XOP.128.X8.W0 C1 /r ib``
``XOP``
``16/32/64-bit``
"""
XOP_VPROTD_XMM_XMMM128_IMM8: int = 4094
"""
``VPROTD xmm1, xmm2/m128, imm8``
``XOP.128.X8.W0 C2 /r ib``
``XOP``
``16/32/64-bit``
"""
XOP_VPROTQ_XMM_XMMM128_IMM8: int = 4095
"""
``VPROTQ xmm1, xmm2/m128, imm8``
``XOP.128.X8.W0 C3 /r ib``
``XOP``
``16/32/64-bit``
"""
XOP_VPCOMB_XMM_XMM_XMMM128_IMM8: int = 4096
"""
``VPCOMB xmm1, xmm2, xmm3/m128, imm8``
``XOP.128.X8.W0 CC /r ib``
``XOP``
``16/32/64-bit``
"""
XOP_VPCOMW_XMM_XMM_XMMM128_IMM8: int = 4097
"""
``VPCOMW xmm1, xmm2, xmm3/m128, imm8``
``XOP.128.X8.W0 CD /r ib``
``XOP``
``16/32/64-bit``
"""
XOP_VPCOMD_XMM_XMM_XMMM128_IMM8: int = 4098
"""
``VPCOMD xmm1, xmm2, xmm3/m128, imm8``
``XOP.128.X8.W0 CE /r ib``
``XOP``
``16/32/64-bit``
"""
XOP_VPCOMQ_XMM_XMM_XMMM128_IMM8: int = 4099
"""
``VPCOMQ xmm1, xmm2, xmm3/m128, imm8``
``XOP.128.X8.W0 CF /r ib``
``XOP``
``16/32/64-bit``
"""
XOP_VPCOMUB_XMM_XMM_XMMM128_IMM8: int = 4100
"""
``VPCOMUB xmm1, xmm2, xmm3/m128, imm8``
``XOP.128.X8.W0 EC /r ib``
``XOP``
``16/32/64-bit``
"""
XOP_VPCOMUW_XMM_XMM_XMMM128_IMM8: int = 4101
"""
``VPCOMUW xmm1, xmm2, xmm3/m128, imm8``
``XOP.128.X8.W0 ED /r ib``
``XOP``
``16/32/64-bit``
"""
XOP_VPCOMUD_XMM_XMM_XMMM128_IMM8: int = 4102
"""
``VPCOMUD xmm1, xmm2, xmm3/m128, imm8``
``XOP.128.X8.W0 EE /r ib``
``XOP``
``16/32/64-bit``
"""
XOP_VPCOMUQ_XMM_XMM_XMMM128_IMM8: int = 4103
"""
``VPCOMUQ xmm1, xmm2, xmm3/m128, imm8``
``XOP.128.X8.W0 EF /r ib``
``XOP``
``16/32/64-bit``
"""
XOP_BLCFILL_R32_RM32: int = 4104
"""
``BLCFILL r32, r/m32``
``XOP.L0.X9.W0 01 /1``
``TBM``
``16/32/64-bit``
"""
XOP_BLCFILL_R64_RM64: int = 4105
"""
``BLCFILL r64, r/m64``
``XOP.L0.X9.W1 01 /1``
``TBM``
``64-bit``
"""
XOP_BLSFILL_R32_RM32: int = 4106
"""
``BLSFILL r32, r/m32``
``XOP.L0.X9.W0 01 /2``
``TBM``
``16/32/64-bit``
"""
XOP_BLSFILL_R64_RM64: int = 4107
"""
``BLSFILL r64, r/m64``
``XOP.L0.X9.W1 01 /2``
``TBM``
``64-bit``
"""
XOP_BLCS_R32_RM32: int = 4108
"""
``BLCS r32, r/m32``
``XOP.L0.X9.W0 01 /3``
``TBM``
``16/32/64-bit``
"""
XOP_BLCS_R64_RM64: int = 4109
"""
``BLCS r64, r/m64``
``XOP.L0.X9.W1 01 /3``
``TBM``
``64-bit``
"""
XOP_TZMSK_R32_RM32: int = 4110
"""
``TZMSK r32, r/m32``
``XOP.L0.X9.W0 01 /4``
``TBM``
``16/32/64-bit``
"""
XOP_TZMSK_R64_RM64: int = 4111
"""
``TZMSK r64, r/m64``
``XOP.L0.X9.W1 01 /4``
``TBM``
``64-bit``
"""
XOP_BLCIC_R32_RM32: int = 4112
"""
``BLCIC r32, r/m32``
``XOP.L0.X9.W0 01 /5``
``TBM``
``16/32/64-bit``
"""
XOP_BLCIC_R64_RM64: int = 4113
"""
``BLCIC r64, r/m64``
``XOP.L0.X9.W1 01 /5``
``TBM``
``64-bit``
"""
XOP_BLSIC_R32_RM32: int = 4114
"""
``BLSIC r32, r/m32``
``XOP.L0.X9.W0 01 /6``
``TBM``
``16/32/64-bit``
"""
XOP_BLSIC_R64_RM64: int = 4115
"""
``BLSIC r64, r/m64``
``XOP.L0.X9.W1 01 /6``
``TBM``
``64-bit``
"""
XOP_T1MSKC_R32_RM32: int = 4116
"""
``T1MSKC r32, r/m32``
``XOP.L0.X9.W0 01 /7``
``TBM``
``16/32/64-bit``
"""
XOP_T1MSKC_R64_RM64: int = 4117
"""
``T1MSKC r64, r/m64``
``XOP.L0.X9.W1 01 /7``
``TBM``
``64-bit``
"""
XOP_BLCMSK_R32_RM32: int = 4118
"""
``BLCMSK r32, r/m32``
``XOP.L0.X9.W0 02 /1``
``TBM``
``16/32/64-bit``
"""
XOP_BLCMSK_R64_RM64: int = 4119
"""
``BLCMSK r64, r/m64``
``XOP.L0.X9.W1 02 /1``
``TBM``
``64-bit``
"""
XOP_BLCI_R32_RM32: int = 4120
"""
``BLCI r32, r/m32``
``XOP.L0.X9.W0 02 /6``
``TBM``
``16/32/64-bit``
"""
XOP_BLCI_R64_RM64: int = 4121
"""
``BLCI r64, r/m64``
``XOP.L0.X9.W1 02 /6``
``TBM``
``64-bit``
"""
XOP_LLWPCB_R32: int = 4122
"""
``LLWPCB r32``
``XOP.L0.X9.W0 12 /0``
``LWP``
``16/32/64-bit``
"""
XOP_LLWPCB_R64: int = 4123
"""
``LLWPCB r64``
``XOP.L0.X9.W1 12 /0``
``LWP``
``64-bit``
"""
XOP_SLWPCB_R32: int = 4124
"""
``SLWPCB r32``
``XOP.L0.X9.W0 12 /1``
``LWP``
``16/32/64-bit``
"""
XOP_SLWPCB_R64: int = 4125
"""
``SLWPCB r64``
``XOP.L0.X9.W1 12 /1``
``LWP``
``64-bit``
"""
XOP_VFRCZPS_XMM_XMMM128: int = 4126
"""
``VFRCZPS xmm1, xmm2/m128``
``XOP.128.X9.W0 80 /r``
``XOP``
``16/32/64-bit``
"""
XOP_VFRCZPS_YMM_YMMM256: int = 4127
"""
``VFRCZPS ymm1, ymm2/m256``
``XOP.256.X9.W0 80 /r``
``XOP``
``16/32/64-bit``
"""
XOP_VFRCZPD_XMM_XMMM128: int = 4128
"""
``VFRCZPD xmm1, xmm2/m128``
``XOP.128.X9.W0 81 /r``
``XOP``
``16/32/64-bit``
"""
XOP_VFRCZPD_YMM_YMMM256: int = 4129
"""
``VFRCZPD ymm1, ymm2/m256``
``XOP.256.X9.W0 81 /r``
``XOP``
``16/32/64-bit``
"""
XOP_VFRCZSS_XMM_XMMM32: int = 4130
"""
``VFRCZSS xmm1, xmm2/m32``
``XOP.128.X9.W0 82 /r``
``XOP``
``16/32/64-bit``
"""
XOP_VFRCZSD_XMM_XMMM64: int = 4131
"""
``VFRCZSD xmm1, xmm2/m64``
``XOP.128.X9.W0 83 /r``
``XOP``
``16/32/64-bit``
"""
XOP_VPROTB_XMM_XMMM128_XMM: int = 4132
"""
``VPROTB xmm1, xmm2/m128, xmm3``
``XOP.128.X9.W0 90 /r``
``XOP``
``16/32/64-bit``
"""
XOP_VPROTB_XMM_XMM_XMMM128: int = 4133
"""
``VPROTB xmm1, xmm2, xmm3/m128``
``XOP.128.X9.W1 90 /r``
``XOP``
``16/32/64-bit``
"""
XOP_VPROTW_XMM_XMMM128_XMM: int = 4134
"""
``VPROTW xmm1, xmm2/m128, xmm3``
``XOP.128.X9.W0 91 /r``
``XOP``
``16/32/64-bit``
"""
XOP_VPROTW_XMM_XMM_XMMM128: int = 4135
"""
``VPROTW xmm1, xmm2, xmm3/m128``
``XOP.128.X9.W1 91 /r``
``XOP``
``16/32/64-bit``
"""
XOP_VPROTD_XMM_XMMM128_XMM: int = 4136
"""
``VPROTD xmm1, xmm2/m128, xmm3``
``XOP.128.X9.W0 92 /r``
``XOP``
``16/32/64-bit``
"""
XOP_VPROTD_XMM_XMM_XMMM128: int = 4137
"""
``VPROTD xmm1, xmm2, xmm3/m128``
``XOP.128.X9.W1 92 /r``
``XOP``
``16/32/64-bit``
"""
XOP_VPROTQ_XMM_XMMM128_XMM: int = 4138
"""
``VPROTQ xmm1, xmm2/m128, xmm3``
``XOP.128.X9.W0 93 /r``
``XOP``
``16/32/64-bit``
"""
XOP_VPROTQ_XMM_XMM_XMMM128: int = 4139
"""
``VPROTQ xmm1, xmm2, xmm3/m128``
``XOP.128.X9.W1 93 /r``
``XOP``
``16/32/64-bit``
"""
XOP_VPSHLB_XMM_XMMM128_XMM: int = 4140
"""
``VPSHLB xmm1, xmm2/m128, xmm3``
``XOP.128.X9.W0 94 /r``
``XOP``
``16/32/64-bit``
"""
XOP_VPSHLB_XMM_XMM_XMMM128: int = 4141
"""
``VPSHLB xmm1, xmm2, xmm3/m128``
``XOP.128.X9.W1 94 /r``
``XOP``
``16/32/64-bit``
"""
XOP_VPSHLW_XMM_XMMM128_XMM: int = 4142
"""
``VPSHLW xmm1, xmm2/m128, xmm3``
``XOP.128.X9.W0 95 /r``
``XOP``
``16/32/64-bit``
"""
XOP_VPSHLW_XMM_XMM_XMMM128: int = 4143
"""
``VPSHLW xmm1, xmm2, xmm3/m128``
``XOP.128.X9.W1 95 /r``
``XOP``
``16/32/64-bit``
"""
XOP_VPSHLD_XMM_XMMM128_XMM: int = 4144
"""
``VPSHLD xmm1, xmm2/m128, xmm3``
``XOP.128.X9.W0 96 /r``
``XOP``
``16/32/64-bit``
"""
XOP_VPSHLD_XMM_XMM_XMMM128: int = 4145
"""
``VPSHLD xmm1, xmm2, xmm3/m128``
``XOP.128.X9.W1 96 /r``
``XOP``
``16/32/64-bit``
"""
XOP_VPSHLQ_XMM_XMMM128_XMM: int = 4146
"""
``VPSHLQ xmm1, xmm2/m128, xmm3``
``XOP.128.X9.W0 97 /r``
``XOP``
``16/32/64-bit``
"""
XOP_VPSHLQ_XMM_XMM_XMMM128: int = 4147
"""
``VPSHLQ xmm1, xmm2, xmm3/m128``
``XOP.128.X9.W1 97 /r``
``XOP``
``16/32/64-bit``
"""
XOP_VPSHAB_XMM_XMMM128_XMM: int = 4148
"""
``VPSHAB xmm1, xmm2/m128, xmm3``
``XOP.128.X9.W0 98 /r``
``XOP``
``16/32/64-bit``
"""
XOP_VPSHAB_XMM_XMM_XMMM128: int = 4149
"""
``VPSHAB xmm1, xmm2, xmm3/m128``
``XOP.128.X9.W1 98 /r``
``XOP``
``16/32/64-bit``
"""
XOP_VPSHAW_XMM_XMMM128_XMM: int = 4150
"""
``VPSHAW xmm1, xmm2/m128, xmm3``
``XOP.128.X9.W0 99 /r``
``XOP``
``16/32/64-bit``
"""
XOP_VPSHAW_XMM_XMM_XMMM128: int = 4151
"""
``VPSHAW xmm1, xmm2, xmm3/m128``
``XOP.128.X9.W1 99 /r``
``XOP``
``16/32/64-bit``
"""
XOP_VPSHAD_XMM_XMMM128_XMM: int = 4152
"""
``VPSHAD xmm1, xmm2/m128, xmm3``
``XOP.128.X9.W0 9A /r``
``XOP``
``16/32/64-bit``
"""
XOP_VPSHAD_XMM_XMM_XMMM128: int = 4153
"""
``VPSHAD xmm1, xmm2, xmm3/m128``
``XOP.128.X9.W1 9A /r``
``XOP``
``16/32/64-bit``
"""
XOP_VPSHAQ_XMM_XMMM128_XMM: int = 4154
"""
``VPSHAQ xmm1, xmm2/m128, xmm3``
``XOP.128.X9.W0 9B /r``
``XOP``
``16/32/64-bit``
"""
XOP_VPSHAQ_XMM_XMM_XMMM128: int = 4155
"""
``VPSHAQ xmm1, xmm2, xmm3/m128``
``XOP.128.X9.W1 9B /r``
``XOP``
``16/32/64-bit``
"""
XOP_VPHADDBW_XMM_XMMM128: int = 4156
"""
``VPHADDBW xmm1, xmm2/m128``
``XOP.128.X9.W0 C1 /r``
``XOP``
``16/32/64-bit``
"""
XOP_VPHADDBD_XMM_XMMM128: int = 4157
"""
``VPHADDBD xmm1, xmm2/m128``
``XOP.128.X9.W0 C2 /r``
``XOP``
``16/32/64-bit``
"""
XOP_VPHADDBQ_XMM_XMMM128: int = 4158
"""
``VPHADDBQ xmm1, xmm2/m128``
``XOP.128.X9.W0 C3 /r``
``XOP``
``16/32/64-bit``
"""
XOP_VPHADDWD_XMM_XMMM128: int = 4159
"""
``VPHADDWD xmm1, xmm2/m128``
``XOP.128.X9.W0 C6 /r``
``XOP``
``16/32/64-bit``
"""
XOP_VPHADDWQ_XMM_XMMM128: int = 4160
"""
``VPHADDWQ xmm1, xmm2/m128``
``XOP.128.X9.W0 C7 /r``
``XOP``
``16/32/64-bit``
"""
XOP_VPHADDDQ_XMM_XMMM128: int = 4161
"""
``VPHADDDQ xmm1, xmm2/m128``
``XOP.128.X9.W0 CB /r``
``XOP``
``16/32/64-bit``
"""
XOP_VPHADDUBW_XMM_XMMM128: int = 4162
"""
``VPHADDUBW xmm1, xmm2/m128``
``XOP.128.X9.W0 D1 /r``
``XOP``
``16/32/64-bit``
"""
XOP_VPHADDUBD_XMM_XMMM128: int = 4163
"""
``VPHADDUBD xmm1, xmm2/m128``
``XOP.128.X9.W0 D2 /r``
``XOP``
``16/32/64-bit``
"""
XOP_VPHADDUBQ_XMM_XMMM128: int = 4164
"""
``VPHADDUBQ xmm1, xmm2/m128``
``XOP.128.X9.W0 D3 /r``
``XOP``
``16/32/64-bit``
"""
XOP_VPHADDUWD_XMM_XMMM128: int = 4165
"""
``VPHADDUWD xmm1, xmm2/m128``
``XOP.128.X9.W0 D6 /r``
``XOP``
``16/32/64-bit``
"""
XOP_VPHADDUWQ_XMM_XMMM128: int = 4166
"""
``VPHADDUWQ xmm1, xmm2/m128``
``XOP.128.X9.W0 D7 /r``
``XOP``
``16/32/64-bit``
"""
XOP_VPHADDUDQ_XMM_XMMM128: int = 4167
"""
``VPHADDUDQ xmm1, xmm2/m128``
``XOP.128.X9.W0 DB /r``
``XOP``
``16/32/64-bit``
"""
XOP_VPHSUBBW_XMM_XMMM128: int = 4168
"""
``VPHSUBBW xmm1, xmm2/m128``
``XOP.128.X9.W0 E1 /r``
``XOP``
``16/32/64-bit``
"""
XOP_VPHSUBWD_XMM_XMMM128: int = 4169
"""
``VPHSUBWD xmm1, xmm2/m128``
``XOP.128.X9.W0 E2 /r``
``XOP``
``16/32/64-bit``
"""
XOP_VPHSUBDQ_XMM_XMMM128: int = 4170
"""
``VPHSUBDQ xmm1, xmm2/m128``
``XOP.128.X9.W0 E3 /r``
``XOP``
``16/32/64-bit``
"""
XOP_BEXTR_R32_RM32_IMM32: int = 4171
"""
``BEXTR r32, r/m32, imm32``
``XOP.L0.XA.W0 10 /r id``
``TBM``
``16/32/64-bit``
"""
XOP_BEXTR_R64_RM64_IMM32: int = 4172
"""
``BEXTR r64, r/m64, imm32``
``XOP.L0.XA.W1 10 /r id``
``TBM``
``64-bit``
"""
XOP_LWPINS_R32_RM32_IMM32: int = 4173
"""
``LWPINS r32, r/m32, imm32``
``XOP.L0.XA.W0 12 /0 id``
``LWP``
``16/32/64-bit``
"""
XOP_LWPINS_R64_RM32_IMM32: int = 4174
"""
``LWPINS r64, r/m32, imm32``
``XOP.L0.XA.W1 12 /0 id``
``LWP``
``64-bit``
"""
XOP_LWPVAL_R32_RM32_IMM32: int = 4175
"""
``LWPVAL r32, r/m32, imm32``
``XOP.L0.XA.W0 12 /1 id``
``LWP``
``16/32/64-bit``
"""
XOP_LWPVAL_R64_RM32_IMM32: int = 4176
"""
``LWPVAL r64, r/m32, imm32``
``XOP.L0.XA.W1 12 /1 id``
``LWP``
``64-bit``
"""
D3NOW_PI2FW_MM_MMM64: int = 4177
"""
``PI2FW mm, mm/m64``
``0F 0F /r 0C``
``3DNOWEXT``
``16/32/64-bit``
"""
D3NOW_PI2FD_MM_MMM64: int = 4178
"""
``PI2FD mm, mm/m64``
``0F 0F /r 0D``
``3DNOW``
``16/32/64-bit``
"""
D3NOW_PF2IW_MM_MMM64: int = 4179
"""
``PF2IW mm, mm/m64``
``0F 0F /r 1C``
``3DNOWEXT``
``16/32/64-bit``
"""
D3NOW_PF2ID_MM_MMM64: int = 4180
"""
``PF2ID mm, mm/m64``
``0F 0F /r 1D``
``3DNOW``
``16/32/64-bit``
"""
D3NOW_PFRCPV_MM_MMM64: int = 4181
"""
``PFRCPV mm, mm/m64``
``0F 0F /r 86``
``AMD Geode GX/LX``
``16/32-bit``
"""
D3NOW_PFRSQRTV_MM_MMM64: int = 4182
"""
``PFRSQRTV mm, mm/m64``
``0F 0F /r 87``
``AMD Geode GX/LX``
``16/32-bit``
"""
D3NOW_PFNACC_MM_MMM64: int = 4183
"""
``PFNACC mm, mm/m64``
``0F 0F /r 8A``
``3DNOWEXT``
``16/32/64-bit``
"""
D3NOW_PFPNACC_MM_MMM64: int = 4184
"""
``PFPNACC mm, mm/m64``
``0F 0F /r 8E``
``3DNOWEXT``
``16/32/64-bit``
"""
D3NOW_PFCMPGE_MM_MMM64: int = 4185
"""
``PFCMPGE mm, mm/m64``
``0F 0F /r 90``
``3DNOW``
``16/32/64-bit``
"""
D3NOW_PFMIN_MM_MMM64: int = 4186
"""
``PFMIN mm, mm/m64``
``0F 0F /r 94``
``3DNOW``
``16/32/64-bit``
"""
D3NOW_PFRCP_MM_MMM64: int = 4187
"""
``PFRCP mm, mm/m64``
``0F 0F /r 96``
``3DNOW``
``16/32/64-bit``
"""
D3NOW_PFRSQRT_MM_MMM64: int = 4188
"""
``PFRSQRT mm, mm/m64``
``0F 0F /r 97``
``3DNOW``
``16/32/64-bit``
"""
D3NOW_PFSUB_MM_MMM64: int = 4189
"""
``PFSUB mm, mm/m64``
``0F 0F /r 9A``
``3DNOW``
``16/32/64-bit``
"""
D3NOW_PFADD_MM_MMM64: int = 4190
"""
``PFADD mm, mm/m64``
``0F 0F /r 9E``
``3DNOW``
``16/32/64-bit``
"""
D3NOW_PFCMPGT_MM_MMM64: int = 4191
"""
``PFCMPGT mm, mm/m64``
``0F 0F /r A0``
``3DNOW``
``16/32/64-bit``
"""
D3NOW_PFMAX_MM_MMM64: int = 4192
"""
``PFMAX mm, mm/m64``
``0F 0F /r A4``
``3DNOW``
``16/32/64-bit``
"""
D3NOW_PFRCPIT1_MM_MMM64: int = 4193
"""
``PFRCPIT1 mm, mm/m64``
``0F 0F /r A6``
``3DNOW``
``16/32/64-bit``
"""
D3NOW_PFRSQIT1_MM_MMM64: int = 4194
"""
``PFRSQIT1 mm, mm/m64``
``0F 0F /r A7``
``3DNOW``
``16/32/64-bit``
"""
D3NOW_PFSUBR_MM_MMM64: int = 4195
"""
``PFSUBR mm, mm/m64``
``0F 0F /r AA``
``3DNOW``
``16/32/64-bit``
"""
D3NOW_PFACC_MM_MMM64: int = 4196
"""
``PFACC mm, mm/m64``
``0F 0F /r AE``
``3DNOW``
``16/32/64-bit``
"""
D3NOW_PFCMPEQ_MM_MMM64: int = 4197
"""
``PFCMPEQ mm, mm/m64``
``0F 0F /r B0``
``3DNOW``
``16/32/64-bit``
"""
D3NOW_PFMUL_MM_MMM64: int = 4198
"""
``PFMUL mm, mm/m64``
``0F 0F /r B4``
``3DNOW``
``16/32/64-bit``
"""
D3NOW_PFRCPIT2_MM_MMM64: int = 4199
"""
``PFRCPIT2 mm, mm/m64``
``0F 0F /r B6``
``3DNOW``
``16/32/64-bit``
"""
D3NOW_PMULHRW_MM_MMM64: int = 4200
"""
``PMULHRW mm, mm/m64``
``0F 0F /r B7``
``3DNOW``
``16/32/64-bit``
"""
D3NOW_PSWAPD_MM_MMM64: int = 4201
"""
``PSWAPD mm, mm/m64``
``0F 0F /r BB``
``3DNOWEXT``
``16/32/64-bit``
"""
D3NOW_PAVGUSB_MM_MMM64: int = 4202
"""
``PAVGUSB mm, mm/m64``
``0F 0F /r BF``
``3DNOW``
``16/32/64-bit``
"""
RMPADJUST: int = 4203
"""
``RMPADJUST``
``F3 0F 01 FE``
``SEV-SNP``
``64-bit``
"""
RMPUPDATE: int = 4204
"""
``RMPUPDATE``
``F2 0F 01 FE``
``SEV-SNP``
``64-bit``
"""
PSMASH: int = 4205
"""
``PSMASH``
``F3 0F 01 FF``
``SEV-SNP``
``64-bit``
"""
PVALIDATEW: int = 4206
"""
``PVALIDATE``
``a16 F2 0F 01 FF``
``SEV-SNP``
``16/32-bit``
"""
PVALIDATED: int = 4207
"""
``PVALIDATE``
``a32 F2 0F 01 FF``
``SEV-SNP``
``16/32/64-bit``
"""
PVALIDATEQ: int = 4208
"""
``PVALIDATE``
``a64 F2 0F 01 FF``
``SEV-SNP``
``64-bit``
"""
SERIALIZE: int = 4209
"""
``SERIALIZE``
``NP 0F 01 E8``
``SERIALIZE``
``16/32/64-bit``
"""
XSUSLDTRK: int = 4210
"""
``XSUSLDTRK``
``F2 0F 01 E8``
``TSXLDTRK``
``16/32/64-bit``
"""
XRESLDTRK: int = 4211
"""
``XRESLDTRK``
``F2 0F 01 E9``
``TSXLDTRK``
``16/32/64-bit``
"""
INVLPGBW: int = 4212
"""
``INVLPGB``
``a16 NP 0F 01 FE``
``INVLPGB``
``16/32-bit``
"""
INVLPGBD: int = 4213
"""
``INVLPGB``
``a32 NP 0F 01 FE``
``INVLPGB``
``16/32/64-bit``
"""
INVLPGBQ: int = 4214
"""
``INVLPGB``
``a64 NP 0F 01 FE``
``INVLPGB``
``64-bit``
"""
TLBSYNC: int = 4215
"""
``TLBSYNC``
``NP 0F 01 FF``
``INVLPGB``
``16/32/64-bit``
"""
PREFETCHRESERVED3_M8: int = 4216
"""
``PREFETCHW m8``
``0F 0D /3``
``PREFETCHW``
``16/32/64-bit``
"""
PREFETCHRESERVED4_M8: int = 4217
"""
``PREFETCH m8``
``0F 0D /4``
``PREFETCHW``
``16/32/64-bit``
"""
PREFETCHRESERVED5_M8: int = 4218
"""
``PREFETCH m8``
``0F 0D /5``
``PREFETCHW``
``16/32/64-bit``
"""
PREFETCHRESERVED6_M8: int = 4219
"""
``PREFETCH m8``
``0F 0D /6``
``PREFETCHW``
``16/32/64-bit``
"""
PREFETCHRESERVED7_M8: int = 4220
"""
``PREFETCH m8``
``0F 0D /7``
``PREFETCHW``
``16/32/64-bit``
"""
UD0: int = 4221
"""
``UD0``
``0F FF``
``286+``
``16/32/64-bit``
"""
VMGEXIT: int = 4222
"""
``VMGEXIT``
``F3 0F 01 D9``
``SEV-ES``
``16/32/64-bit``
"""
GETSECQ: int = 4223
"""
``GETSECQ``
``NP o64 0F 37``
``SMX``
``64-bit``
"""
VEX_LDTILECFG_M512: int = 4224
"""
``LDTILECFG m512``
``VEX.128.0F38.W0 49 !(11):000:bbb``
``AMX-TILE``
``64-bit``
"""
VEX_TILERELEASE: int = 4225
"""
``TILERELEASE``
``VEX.128.0F38.W0 49 C0``
``AMX-TILE``
``64-bit``
"""
VEX_STTILECFG_M512: int = 4226
"""
``STTILECFG m512``
``VEX.128.66.0F38.W0 49 !(11):000:bbb``
``AMX-TILE``
``64-bit``
"""
VEX_TILEZERO_TMM: int = 4227
"""
``TILEZERO tmm1``
``VEX.128.F2.0F38.W0 49 11:rrr:000``
``AMX-TILE``
``64-bit``
"""
VEX_TILELOADDT1_TMM_SIBMEM: int = 4228
"""
``TILELOADDT1 tmm1, sibmem``
``VEX.128.66.0F38.W0 4B !(11):rrr:100``
``AMX-TILE``
``64-bit``
"""
VEX_TILESTORED_SIBMEM_TMM: int = 4229
"""
``TILESTORED sibmem, tmm1``
``VEX.128.F3.0F38.W0 4B !(11):rrr:100``
``AMX-TILE``
``64-bit``
"""
VEX_TILELOADD_TMM_SIBMEM: int = 4230
"""
``TILELOADD tmm1, sibmem``
``VEX.128.F2.0F38.W0 4B !(11):rrr:100``
``AMX-TILE``
``64-bit``
"""
VEX_TDPBF16PS_TMM_TMM_TMM: int = 4231
"""
``TDPBF16PS tmm1, tmm2, tmm3``
``VEX.128.F3.0F38.W0 5C 11:rrr:bbb``
``AMX-BF16``
``64-bit``
"""
VEX_TDPBUUD_TMM_TMM_TMM: int = 4232
"""
``TDPBUUD tmm1, tmm2, tmm3``
``VEX.128.0F38.W0 5E 11:rrr:bbb``
``AMX-INT8``
``64-bit``
"""
VEX_TDPBUSD_TMM_TMM_TMM: int = 4233
"""
``TDPBUSD tmm1, tmm2, tmm3``
``VEX.128.66.0F38.W0 5E 11:rrr:bbb``
``AMX-INT8``
``64-bit``
"""
VEX_TDPBSUD_TMM_TMM_TMM: int = 4234
"""
``TDPBSUD tmm1, tmm2, tmm3``
``VEX.128.F3.0F38.W0 5E 11:rrr:bbb``
``AMX-INT8``
``64-bit``
"""
VEX_TDPBSSD_TMM_TMM_TMM: int = 4235
"""
``TDPBSSD tmm1, tmm2, tmm3``
``VEX.128.F2.0F38.W0 5E 11:rrr:bbb``
``AMX-INT8``
``64-bit``
"""
FNSTDW_AX: int = 4236
"""
``FNSTDW AX``
``DF E1``
``387 SL``
``16/32-bit``
"""
FNSTSG_AX: int = 4237
"""
``FNSTSG AX``
``DF E2``
``387 SL``
``16/32-bit``
"""
RDSHR_RM32: int = 4238
"""
``RDSHR r/m32``
``0F 36 /0``
``Cyrix 6x86MX, M II, III``
``16/32-bit``
"""
WRSHR_RM32: int = 4239
"""
``WRSHR r/m32``
``0F 37 /0``
``Cyrix 6x86MX, M II, III``
``16/32-bit``
"""
SMINT: int = 4240
"""
``SMINT``
``0F 38``
``Cyrix 6x86MX+, AMD Geode GX/LX``
``16/32-bit``
"""
DMINT: int = 4241
"""
``DMINT``
``0F 39``
``AMD Geode GX/LX``
``16/32-bit``
"""
RDM: int = 4242
"""
``RDM``
``0F 3A``
``AMD Geode GX/LX``
``16/32-bit``
"""
SVDC_M80_SREG: int = 4243
"""
``SVDC m80, Sreg``
``0F 78 /r``
``Cyrix, AMD Geode GX/LX``
``16/32-bit``
"""
RSDC_SREG_M80: int = 4244
"""
``RSDC Sreg, m80``
``0F 79 /r``
``Cyrix, AMD Geode GX/LX``
``16/32-bit``
"""
SVLDT_M80: int = 4245
"""
``SVLDT m80``
``0F 7A /0``
``Cyrix, AMD Geode GX/LX``
``16/32-bit``
"""
RSLDT_M80: int = 4246
"""
``RSLDT m80``
``0F 7B /0``
``Cyrix, AMD Geode GX/LX``
``16/32-bit``
"""
SVTS_M80: int = 4247
"""
``SVTS m80``
``0F 7C /0``
``Cyrix, AMD Geode GX/LX``
``16/32-bit``
"""
RSTS_M80: int = 4248
"""
``RSTS m80``
``0F 7D /0``
``Cyrix, AMD Geode GX/LX``
``16/32-bit``
"""
SMINT_0F7E: int = 4249
"""
``SMINT``
``0F 7E``
``Cyrix 6x86 or earlier``
``16/32-bit``
"""
BB0_RESET: int = 4250
"""
``BB0_RESET``
``0F 3A``
``Cyrix MediaGX, GXm, GXLV, GX1``
``16/32-bit``
"""
BB1_RESET: int = 4251
"""
``BB1_RESET``
``0F 3B``
``Cyrix MediaGX, GXm, GXLV, GX1``
``16/32-bit``
"""
CPU_WRITE: int = 4252
"""
``CPU_WRITE``
``0F 3C``
``Cyrix MediaGX, GXm, GXLV, GX1``
``16/32-bit``
"""
CPU_READ: int = 4253
"""
``CPU_READ``
``0F 3D``
``Cyrix MediaGX, GXm, GXLV, GX1``
``16/32-bit``
"""
ALTINST: int = 4254
"""
``ALTINST``
``0F 3F``
``Centaur AIS``
``16/32-bit``
"""
PAVEB_MM_MMM64: int = 4255
"""
``PAVEB mm, mm/m64``
``0F 50 /r``
``CYRIX_EMMI``
``16/32-bit``
"""
PADDSIW_MM_MMM64: int = 4256
"""
``PADDSIW mm, mm/m64``
``0F 51 /r``
``CYRIX_EMMI``
``16/32-bit``
"""
PMAGW_MM_MMM64: int = 4257
"""
``PMAGW mm, mm/m64``
``0F 52 /r``
``CYRIX_EMMI``
``16/32-bit``
"""
PDISTIB_MM_M64: int = 4258
"""
``PDISTIB mm, m64``
``0F 54 /r``
``CYRIX_EMMI``
``16/32-bit``
"""
PSUBSIW_MM_MMM64: int = 4259
"""
``PSUBSIW mm, mm/m64``
``0F 55 /r``
``CYRIX_EMMI``
``16/32-bit``
"""
PMVZB_MM_M64: int = 4260
"""
``PMVZB mm, m64``
``0F 58 /r``
``CYRIX_EMMI``
``16/32-bit``
"""
PMULHRW_MM_MMM64: int = 4261
"""
``PMULHRW mm, mm/m64``
``0F 59 /r``
``CYRIX_EMMI``
``16/32-bit``
"""
PMVNZB_MM_M64: int = 4262
"""
``PMVNZB mm, m64``
``0F 5A /r``
``CYRIX_EMMI``
``16/32-bit``
"""
PMVLZB_MM_M64: int = 4263
"""
``PMVLZB mm, m64``
``0F 5B /r``
``CYRIX_EMMI``
``16/32-bit``
"""
PMVGEZB_MM_M64: int = 4264
"""
``PMVGEZB mm, m64``
``0F 5C /r``
``CYRIX_EMMI``
``16/32-bit``
"""
PMULHRIW_MM_MMM64: int = 4265
"""
``PMULHRIW mm, mm/m64``
``0F 5D /r``
``CYRIX_EMMI``
``16/32-bit``
"""
PMACHRIW_MM_M64: int = 4266
"""
``PMACHRIW mm, m64``
``0F 5E /r``
``CYRIX_EMMI``
``16/32-bit``
"""
CYRIX_D9D7: int = 4267
"""
``UNDOC``
``D9 D7``
``Cyrix, AMD Geode GX/LX``
``16/32-bit``
"""
CYRIX_D9E2: int = 4268
"""
``UNDOC``
``D9 E2``
``Cyrix, AMD Geode GX/LX``
``16/32-bit``
"""
FTSTP: int = 4269
"""
``FTSTP``
``D9 E6``
``Cyrix, AMD Geode GX/LX``
``16/32-bit``
"""
CYRIX_D9E7: int = 4270
"""
``UNDOC``
``D9 E7``
``Cyrix, AMD Geode GX/LX``
``16/32-bit``
"""
FRINT2: int = 4271
"""
``FRINT2``
``DB FC``
``Cyrix, AMD Geode GX/LX``
``16/32-bit``
"""
FRICHOP: int = 4272
"""
``FRICHOP``
``DD FC``
``Cyrix, AMD Geode GX/LX``
``16/32-bit``
"""
CYRIX_DED8: int = 4273
"""
``UNDOC``
``DE D8``
``Cyrix, AMD Geode GX/LX``
``16/32-bit``
"""
CYRIX_DEDA: int = 4274
"""
``UNDOC``
``DE DA``
``Cyrix, AMD Geode GX/LX``
``16/32-bit``
"""
CYRIX_DEDC: int = 4275
"""
``UNDOC``
``DE DC``
``Cyrix, AMD Geode GX/LX``
``16/32-bit``
"""
CYRIX_DEDD: int = 4276
"""
``UNDOC``
``DE DD``
``Cyrix, AMD Geode GX/LX``
``16/32-bit``
"""
CYRIX_DEDE: int = 4277
"""
``UNDOC``
``DE DE``
``Cyrix, AMD Geode GX/LX``
``16/32-bit``
"""
FRINEAR: int = 4278
"""
``FRINEAR``
``DF FC``
``Cyrix, AMD Geode GX/LX``
``16/32-bit``
"""
TDCALL: int = 4279
"""
``TDCALL``
``66 0F 01 CC``
``TDX``
``16/32/64-bit``
"""
SEAMRET: int = 4280
"""
``SEAMRET``
``66 0F 01 CD``
``TDX``
``64-bit``
"""
SEAMOPS: int = 4281
"""
``SEAMOPS``
``66 0F 01 CE``
``TDX``
``64-bit``
"""
SEAMCALL: int = 4282
"""
``SEAMCALL``
``66 0F 01 CF``
``TDX``
``64-bit``
"""
AESENCWIDE128KL_M384: int = 4283
"""
``AESENCWIDE128KL m384, <XMM0-7>``
``F3 0F 38 D8 !(11):000:bbb``
``AESKLE and WIDE_KL``
``16/32/64-bit``
"""
AESDECWIDE128KL_M384: int = 4284
"""
``AESDECWIDE128KL m384, <XMM0-7>``
``F3 0F 38 D8 !(11):001:bbb``
``AESKLE and WIDE_KL``
``16/32/64-bit``
"""
AESENCWIDE256KL_M512: int = 4285
"""
``AESENCWIDE256KL m512, <XMM0-7>``
``F3 0F 38 D8 !(11):010:bbb``
``AESKLE and WIDE_KL``
``16/32/64-bit``
"""
AESDECWIDE256KL_M512: int = 4286
"""
``AESDECWIDE256KL m512, <XMM0-7>``
``F3 0F 38 D8 !(11):011:bbb``
``AESKLE and WIDE_KL``
``16/32/64-bit``
"""
LOADIWKEY_XMM_XMM: int = 4287
"""
``LOADIWKEY xmm1, xmm2, <EAX>, <XMM0>``
``F3 0F 38 DC 11:rrr:bbb``
``KL``
``16/32/64-bit``
"""
AESENC128KL_XMM_M384: int = 4288
"""
``AESENC128KL xmm, m384``
``F3 0F 38 DC !(11):rrr:bbb``
``AESKLE``
``16/32/64-bit``
"""
AESDEC128KL_XMM_M384: int = 4289
"""
``AESDEC128KL xmm, m384``
``F3 0F 38 DD !(11):rrr:bbb``
``AESKLE``
``16/32/64-bit``
"""
AESENC256KL_XMM_M512: int = 4290
"""
``AESENC256KL xmm, m512``
``F3 0F 38 DE !(11):rrr:bbb``
``AESKLE``
``16/32/64-bit``
"""
AESDEC256KL_XMM_M512: int = 4291
"""
``AESDEC256KL xmm, m512``
``F3 0F 38 DF !(11):rrr:bbb``
``AESKLE``
``16/32/64-bit``
"""
ENCODEKEY128_R32_R32: int = 4292
"""
``ENCODEKEY128 r32, r32, <XMM0-2>, <XMM4-6>``
``F3 0F 38 FA 11:rrr:bbb``
``AESKLE``
``16/32/64-bit``
"""
ENCODEKEY256_R32_R32: int = 4293
"""
``ENCODEKEY256 r32, r32, <XMM0-6>``
``F3 0F 38 FB 11:rrr:bbb``
``AESKLE``
``16/32/64-bit``
"""
VEX_VBROADCASTSS_XMM_XMM: int = 4294
"""
``VBROADCASTSS xmm1, xmm2``
``VEX.128.66.0F38.W0 18 /r``
``AVX2``
``16/32/64-bit``
"""
VEX_VBROADCASTSS_YMM_XMM: int = 4295
"""
``VBROADCASTSS ymm1, xmm2``
``VEX.256.66.0F38.W0 18 /r``
``AVX2``
``16/32/64-bit``
"""
VEX_VBROADCASTSD_YMM_XMM: int = 4296
"""
``VBROADCASTSD ymm1, xmm2``
``VEX.256.66.0F38.W0 19 /r``
``AVX2``
``16/32/64-bit``
"""
VMGEXIT_F2: int = 4297
"""
``VMGEXIT``
``F2 0F 01 D9``
``SEV-ES``
``16/32/64-bit``
"""
UIRET: int = 4298
"""
``UIRET``
``F3 0F 01 EC``
``UINTR``
``64-bit``
"""
TESTUI: int = 4299
"""
``TESTUI``
``F3 0F 01 ED``
``UINTR``
``64-bit``
"""
CLUI: int = 4300
"""
``CLUI``
``F3 0F 01 EE``
``UINTR``
``64-bit``
"""
STUI: int = 4301
"""
``STUI``
``F3 0F 01 EF``
``UINTR``
``64-bit``
"""
SENDUIPI_R64: int = 4302
"""
``SENDUIPI r64``
``F3 0F C7 /6``
``UINTR``
``64-bit``
"""
HRESET_IMM8: int = 4303
"""
``HRESET imm8, <EAX>``
``F3 0F 3A F0 C0 ib``
``HRESET``
``16/32/64-bit``
"""
VEX_VPDPBUSD_XMM_XMM_XMMM128: int = 4304
"""
``VPDPBUSD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W0 50 /r``
``AVX-VNNI``
``16/32/64-bit``
"""
VEX_VPDPBUSD_YMM_YMM_YMMM256: int = 4305
"""
``VPDPBUSD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W0 50 /r``
``AVX-VNNI``
``16/32/64-bit``
"""
VEX_VPDPBUSDS_XMM_XMM_XMMM128: int = 4306
"""
``VPDPBUSDS xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W0 51 /r``
``AVX-VNNI``
``16/32/64-bit``
"""
VEX_VPDPBUSDS_YMM_YMM_YMMM256: int = 4307
"""
``VPDPBUSDS ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W0 51 /r``
``AVX-VNNI``
``16/32/64-bit``
"""
VEX_VPDPWSSD_XMM_XMM_XMMM128: int = 4308
"""
``VPDPWSSD xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W0 52 /r``
``AVX-VNNI``
``16/32/64-bit``
"""
VEX_VPDPWSSD_YMM_YMM_YMMM256: int = 4309
"""
``VPDPWSSD ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W0 52 /r``
``AVX-VNNI``
``16/32/64-bit``
"""
VEX_VPDPWSSDS_XMM_XMM_XMMM128: int = 4310
"""
``VPDPWSSDS xmm1, xmm2, xmm3/m128``
``VEX.128.66.0F38.W0 53 /r``
``AVX-VNNI``
``16/32/64-bit``
"""
VEX_VPDPWSSDS_YMM_YMM_YMMM256: int = 4311
"""
``VPDPWSSDS ymm1, ymm2, ymm3/m256``
``VEX.256.66.0F38.W0 53 /r``
``AVX-VNNI``
``16/32/64-bit``
"""
CCS_HASH_16: int = 4312
"""
``CCS_HASH``
``a16 F3 0F A6 E8``
``PADLOCK_GMI``
``16/32-bit``
"""
CCS_HASH_32: int = 4313
"""
``CCS_HASH``
``a32 F3 0F A6 E8``
``PADLOCK_GMI``
``16/32/64-bit``
"""
CCS_HASH_64: int = 4314
"""
``CCS_HASH``
``a64 F3 0F A6 E8``
``PADLOCK_GMI``
``64-bit``
"""
CCS_ENCRYPT_16: int = 4315
"""
``CCS_ENCRYPT``
``a16 F3 0F A7 F0``
``PADLOCK_GMI``
``16/32-bit``
"""
CCS_ENCRYPT_32: int = 4316
"""
``CCS_ENCRYPT``
``a32 F3 0F A7 F0``
``PADLOCK_GMI``
``16/32/64-bit``
"""
CCS_ENCRYPT_64: int = 4317
"""
``CCS_ENCRYPT``
``a64 F3 0F A7 F0``
``PADLOCK_GMI``
``64-bit``
"""
LKGS_RM16: int = 4318
"""
``LKGS r/m16``
``o16 F2 0F 00 /6``
``LKGS``
``64-bit``
"""
LKGS_R32M16: int = 4319
"""
``LKGS r32/m16``
``o32 F2 0F 00 /6``
``LKGS``
``64-bit``
"""
LKGS_R64M16: int = 4320
"""
``LKGS r64/m16``
``F2 o64 0F 00 /6``
``LKGS``
``64-bit``
"""
ERETU: int = 4321
"""
``ERETU``
``F3 0F 01 CA``
``FRED``
``64-bit``
"""
ERETS: int = 4322
"""
``ERETS``
``F2 0F 01 CA``
``FRED``
``64-bit``
"""
EVEX_VADDPH_XMM_K1Z_XMM_XMMM128B16: int = 4323
"""
``VADDPH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst``
``EVEX.128.MAP5.W0 58 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VADDPH_YMM_K1Z_YMM_YMMM256B16: int = 4324
"""
``VADDPH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst``
``EVEX.256.MAP5.W0 58 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VADDPH_ZMM_K1Z_ZMM_ZMMM512B16_ER: int = 4325
"""
``VADDPH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}``
``EVEX.512.MAP5.W0 58 /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VADDSH_XMM_K1Z_XMM_XMMM16_ER: int = 4326
"""
``VADDSH xmm1 {k1}{z}, xmm2, xmm3/m16{er}``
``EVEX.LIG.F3.MAP5.W0 58 /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCMPPH_KR_K1_XMM_XMMM128B16_IMM8: int = 4327
"""
``VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8``
``EVEX.128.0F3A.W0 C2 /r ib``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCMPPH_KR_K1_YMM_YMMM256B16_IMM8: int = 4328
"""
``VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8``
``EVEX.256.0F3A.W0 C2 /r ib``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCMPPH_KR_K1_ZMM_ZMMM512B16_IMM8_SAE: int = 4329
"""
``VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8``
``EVEX.512.0F3A.W0 C2 /r ib``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCMPSH_KR_K1_XMM_XMMM16_IMM8_SAE: int = 4330
"""
``VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8``
``EVEX.LIG.F3.0F3A.W0 C2 /r ib``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCOMISH_XMM_XMMM16_SAE: int = 4331
"""
``VCOMISH xmm1, xmm2/m16{sae}``
``EVEX.LIG.MAP5.W0 2F /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTDQ2PH_XMM_K1Z_XMMM128B32: int = 4332
"""
``VCVTDQ2PH xmm1 {k1}{z}, xmm2/m128/m32bcst``
``EVEX.128.MAP5.W0 5B /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTDQ2PH_XMM_K1Z_YMMM256B32: int = 4333
"""
``VCVTDQ2PH xmm1 {k1}{z}, ymm2/m256/m32bcst``
``EVEX.256.MAP5.W0 5B /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTDQ2PH_YMM_K1Z_ZMMM512B32_ER: int = 4334
"""
``VCVTDQ2PH ymm1 {k1}{z}, zmm2/m512/m32bcst{er}``
``EVEX.512.MAP5.W0 5B /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTPD2PH_XMM_K1Z_XMMM128B64: int = 4335
"""
``VCVTPD2PH xmm1 {k1}{z}, xmm2/m128/m64bcst``
``EVEX.128.66.MAP5.W1 5A /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTPD2PH_XMM_K1Z_YMMM256B64: int = 4336
"""
``VCVTPD2PH xmm1 {k1}{z}, ymm2/m256/m64bcst``
``EVEX.256.66.MAP5.W1 5A /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTPD2PH_XMM_K1Z_ZMMM512B64_ER: int = 4337
"""
``VCVTPD2PH xmm1 {k1}{z}, zmm2/m512/m64bcst{er}``
``EVEX.512.66.MAP5.W1 5A /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTPH2DQ_XMM_K1Z_XMMM64B16: int = 4338
"""
``VCVTPH2DQ xmm1 {k1}{z}, xmm2/m64/m16bcst``
``EVEX.128.66.MAP5.W0 5B /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTPH2DQ_YMM_K1Z_XMMM128B16: int = 4339
"""
``VCVTPH2DQ ymm1 {k1}{z}, xmm2/m128/m16bcst``
``EVEX.256.66.MAP5.W0 5B /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTPH2DQ_ZMM_K1Z_YMMM256B16_ER: int = 4340
"""
``VCVTPH2DQ zmm1 {k1}{z}, ymm2/m256/m16bcst{er}``
``EVEX.512.66.MAP5.W0 5B /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTPH2PD_XMM_K1Z_XMMM32B16: int = 4341
"""
``VCVTPH2PD xmm1 {k1}{z}, xmm2/m32/m16bcst``
``EVEX.128.MAP5.W0 5A /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTPH2PD_YMM_K1Z_XMMM64B16: int = 4342
"""
``VCVTPH2PD ymm1 {k1}{z}, xmm2/m64/m16bcst``
``EVEX.256.MAP5.W0 5A /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTPH2PD_ZMM_K1Z_XMMM128B16_SAE: int = 4343
"""
``VCVTPH2PD zmm1 {k1}{z}, xmm2/m128/m16bcst{sae}``
``EVEX.512.MAP5.W0 5A /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTPH2PSX_XMM_K1Z_XMMM64B16: int = 4344
"""
``VCVTPH2PSX xmm1 {k1}{z}, xmm2/m64/m16bcst``
``EVEX.128.66.MAP6.W0 13 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTPH2PSX_YMM_K1Z_XMMM128B16: int = 4345
"""
``VCVTPH2PSX ymm1 {k1}{z}, xmm2/m128/m16bcst``
``EVEX.256.66.MAP6.W0 13 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTPH2PSX_ZMM_K1Z_YMMM256B16_SAE: int = 4346
"""
``VCVTPH2PSX zmm1 {k1}{z}, ymm2/m256/m16bcst{sae}``
``EVEX.512.66.MAP6.W0 13 /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTPH2QQ_XMM_K1Z_XMMM32B16: int = 4347
"""
``VCVTPH2QQ xmm1 {k1}{z}, xmm2/m32/m16bcst``
``EVEX.128.66.MAP5.W0 7B /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTPH2QQ_YMM_K1Z_XMMM64B16: int = 4348
"""
``VCVTPH2QQ ymm1 {k1}{z}, xmm2/m64/m16bcst``
``EVEX.256.66.MAP5.W0 7B /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTPH2QQ_ZMM_K1Z_XMMM128B16_ER: int = 4349
"""
``VCVTPH2QQ zmm1 {k1}{z}, xmm2/m128/m16bcst{er}``
``EVEX.512.66.MAP5.W0 7B /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTPH2UDQ_XMM_K1Z_XMMM64B16: int = 4350
"""
``VCVTPH2UDQ xmm1 {k1}{z}, xmm2/m64/m16bcst``
``EVEX.128.MAP5.W0 79 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTPH2UDQ_YMM_K1Z_XMMM128B16: int = 4351
"""
``VCVTPH2UDQ ymm1 {k1}{z}, xmm2/m128/m16bcst``
``EVEX.256.MAP5.W0 79 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTPH2UDQ_ZMM_K1Z_YMMM256B16_ER: int = 4352
"""
``VCVTPH2UDQ zmm1 {k1}{z}, ymm2/m256/m16bcst{er}``
``EVEX.512.MAP5.W0 79 /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTPH2UQQ_XMM_K1Z_XMMM32B16: int = 4353
"""
``VCVTPH2UQQ xmm1 {k1}{z}, xmm2/m32/m16bcst``
``EVEX.128.66.MAP5.W0 79 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTPH2UQQ_YMM_K1Z_XMMM64B16: int = 4354
"""
``VCVTPH2UQQ ymm1 {k1}{z}, xmm2/m64/m16bcst``
``EVEX.256.66.MAP5.W0 79 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTPH2UQQ_ZMM_K1Z_XMMM128B16_ER: int = 4355
"""
``VCVTPH2UQQ zmm1 {k1}{z}, xmm2/m128/m16bcst{er}``
``EVEX.512.66.MAP5.W0 79 /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTPH2UW_XMM_K1Z_XMMM128B16: int = 4356
"""
``VCVTPH2UW xmm1 {k1}{z}, xmm2/m128/m16bcst``
``EVEX.128.MAP5.W0 7D /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTPH2UW_YMM_K1Z_YMMM256B16: int = 4357
"""
``VCVTPH2UW ymm1 {k1}{z}, ymm2/m256/m16bcst``
``EVEX.256.MAP5.W0 7D /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTPH2UW_ZMM_K1Z_ZMMM512B16_ER: int = 4358
"""
``VCVTPH2UW zmm1 {k1}{z}, zmm2/m512/m16bcst{er}``
``EVEX.512.MAP5.W0 7D /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTPH2W_XMM_K1Z_XMMM128B16: int = 4359
"""
``VCVTPH2W xmm1 {k1}{z}, xmm2/m128/m16bcst``
``EVEX.128.66.MAP5.W0 7D /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTPH2W_YMM_K1Z_YMMM256B16: int = 4360
"""
``VCVTPH2W ymm1 {k1}{z}, ymm2/m256/m16bcst``
``EVEX.256.66.MAP5.W0 7D /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTPH2W_ZMM_K1Z_ZMMM512B16_ER: int = 4361
"""
``VCVTPH2W zmm1 {k1}{z}, zmm2/m512/m16bcst{er}``
``EVEX.512.66.MAP5.W0 7D /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTPS2PHX_XMM_K1Z_XMMM128B32: int = 4362
"""
``VCVTPS2PHX xmm1 {k1}{z}, xmm2/m128/m32bcst``
``EVEX.128.66.MAP5.W0 1D /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTPS2PHX_XMM_K1Z_YMMM256B32: int = 4363
"""
``VCVTPS2PHX xmm1 {k1}{z}, ymm2/m256/m32bcst``
``EVEX.256.66.MAP5.W0 1D /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTPS2PHX_YMM_K1Z_ZMMM512B32_ER: int = 4364
"""
``VCVTPS2PHX ymm1 {k1}{z}, zmm2/m512/m32bcst{er}``
``EVEX.512.66.MAP5.W0 1D /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTQQ2PH_XMM_K1Z_XMMM128B64: int = 4365
"""
``VCVTQQ2PH xmm1 {k1}{z}, xmm2/m128/m64bcst``
``EVEX.128.MAP5.W1 5B /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTQQ2PH_XMM_K1Z_YMMM256B64: int = 4366
"""
``VCVTQQ2PH xmm1 {k1}{z}, ymm2/m256/m64bcst``
``EVEX.256.MAP5.W1 5B /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTQQ2PH_XMM_K1Z_ZMMM512B64_ER: int = 4367
"""
``VCVTQQ2PH xmm1 {k1}{z}, zmm2/m512/m64bcst{er}``
``EVEX.512.MAP5.W1 5B /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTSD2SH_XMM_K1Z_XMM_XMMM64_ER: int = 4368
"""
``VCVTSD2SH xmm1 {k1}{z}, xmm2, xmm3/m64{er}``
``EVEX.LIG.F2.MAP5.W1 5A /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTSH2SD_XMM_K1Z_XMM_XMMM16_SAE: int = 4369
"""
``VCVTSH2SD xmm1 {k1}{z}, xmm2, xmm3/m16{sae}``
``EVEX.LIG.F3.MAP5.W0 5A /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTSH2SI_R32_XMMM16_ER: int = 4370
"""
``VCVTSH2SI r32, xmm1/m16{er}``
``EVEX.LIG.F3.MAP5.W0 2D /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTSH2SI_R64_XMMM16_ER: int = 4371
"""
``VCVTSH2SI r64, xmm1/m16{er}``
``EVEX.LIG.F3.MAP5.W1 2D /r``
``AVX512-FP16``
``64-bit``
"""
EVEX_VCVTSH2SS_XMM_K1Z_XMM_XMMM16_SAE: int = 4372
"""
``VCVTSH2SS xmm1 {k1}{z}, xmm2, xmm3/m16{sae}``
``EVEX.LIG.MAP6.W0 13 /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTSH2USI_R32_XMMM16_ER: int = 4373
"""
``VCVTSH2USI r32, xmm1/m16{er}``
``EVEX.LIG.F3.MAP5.W0 79 /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTSH2USI_R64_XMMM16_ER: int = 4374
"""
``VCVTSH2USI r64, xmm1/m16{er}``
``EVEX.LIG.F3.MAP5.W1 79 /r``
``AVX512-FP16``
``64-bit``
"""
EVEX_VCVTSI2SH_XMM_XMM_RM32_ER: int = 4375
"""
``VCVTSI2SH xmm1, xmm2, r/m32{er}``
``EVEX.LIG.F3.MAP5.W0 2A /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTSI2SH_XMM_XMM_RM64_ER: int = 4376
"""
``VCVTSI2SH xmm1, xmm2, r/m64{er}``
``EVEX.LIG.F3.MAP5.W1 2A /r``
``AVX512-FP16``
``64-bit``
"""
EVEX_VCVTSS2SH_XMM_K1Z_XMM_XMMM32_ER: int = 4377
"""
``VCVTSS2SH xmm1 {k1}{z}, xmm2, xmm3/m32{er}``
``EVEX.LIG.MAP5.W0 1D /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTTPH2DQ_XMM_K1Z_XMMM64B16: int = 4378
"""
``VCVTTPH2DQ xmm1 {k1}{z}, xmm2/m64/m16bcst``
``EVEX.128.F3.MAP5.W0 5B /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTTPH2DQ_YMM_K1Z_XMMM128B16: int = 4379
"""
``VCVTTPH2DQ ymm1 {k1}{z}, xmm2/m128/m16bcst``
``EVEX.256.F3.MAP5.W0 5B /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTTPH2DQ_ZMM_K1Z_YMMM256B16_SAE: int = 4380
"""
``VCVTTPH2DQ zmm1 {k1}{z}, ymm2/m256/m16bcst{sae}``
``EVEX.512.F3.MAP5.W0 5B /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTTPH2QQ_XMM_K1Z_XMMM32B16: int = 4381
"""
``VCVTTPH2QQ xmm1 {k1}{z}, xmm2/m32/m16bcst``
``EVEX.128.66.MAP5.W0 7A /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTTPH2QQ_YMM_K1Z_XMMM64B16: int = 4382
"""
``VCVTTPH2QQ ymm1 {k1}{z}, xmm2/m64/m16bcst``
``EVEX.256.66.MAP5.W0 7A /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTTPH2QQ_ZMM_K1Z_XMMM128B16_SAE: int = 4383
"""
``VCVTTPH2QQ zmm1 {k1}{z}, xmm2/m128/m16bcst{sae}``
``EVEX.512.66.MAP5.W0 7A /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTTPH2UDQ_XMM_K1Z_XMMM64B16: int = 4384
"""
``VCVTTPH2UDQ xmm1 {k1}{z}, xmm2/m64/m16bcst``
``EVEX.128.MAP5.W0 78 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTTPH2UDQ_YMM_K1Z_XMMM128B16: int = 4385
"""
``VCVTTPH2UDQ ymm1 {k1}{z}, xmm2/m128/m16bcst``
``EVEX.256.MAP5.W0 78 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTTPH2UDQ_ZMM_K1Z_YMMM256B16_SAE: int = 4386
"""
``VCVTTPH2UDQ zmm1 {k1}{z}, ymm2/m256/m16bcst{sae}``
``EVEX.512.MAP5.W0 78 /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTTPH2UQQ_XMM_K1Z_XMMM32B16: int = 4387
"""
``VCVTTPH2UQQ xmm1 {k1}{z}, xmm2/m32/m16bcst``
``EVEX.128.66.MAP5.W0 78 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTTPH2UQQ_YMM_K1Z_XMMM64B16: int = 4388
"""
``VCVTTPH2UQQ ymm1 {k1}{z}, xmm2/m64/m16bcst``
``EVEX.256.66.MAP5.W0 78 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTTPH2UQQ_ZMM_K1Z_XMMM128B16_SAE: int = 4389
"""
``VCVTTPH2UQQ zmm1 {k1}{z}, xmm2/m128/m16bcst{sae}``
``EVEX.512.66.MAP5.W0 78 /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTTPH2UW_XMM_K1Z_XMMM128B16: int = 4390
"""
``VCVTTPH2UW xmm1 {k1}{z}, xmm2/m128/m16bcst``
``EVEX.128.MAP5.W0 7C /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTTPH2UW_YMM_K1Z_YMMM256B16: int = 4391
"""
``VCVTTPH2UW ymm1 {k1}{z}, ymm2/m256/m16bcst``
``EVEX.256.MAP5.W0 7C /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTTPH2UW_ZMM_K1Z_ZMMM512B16_SAE: int = 4392
"""
``VCVTTPH2UW zmm1 {k1}{z}, zmm2/m512/m16bcst{sae}``
``EVEX.512.MAP5.W0 7C /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTTPH2W_XMM_K1Z_XMMM128B16: int = 4393
"""
``VCVTTPH2W xmm1 {k1}{z}, xmm2/m128/m16bcst``
``EVEX.128.66.MAP5.W0 7C /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTTPH2W_YMM_K1Z_YMMM256B16: int = 4394
"""
``VCVTTPH2W ymm1 {k1}{z}, ymm2/m256/m16bcst``
``EVEX.256.66.MAP5.W0 7C /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTTPH2W_ZMM_K1Z_ZMMM512B16_SAE: int = 4395
"""
``VCVTTPH2W zmm1 {k1}{z}, zmm2/m512/m16bcst{sae}``
``EVEX.512.66.MAP5.W0 7C /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTTSH2SI_R32_XMMM16_SAE: int = 4396
"""
``VCVTTSH2SI r32, xmm1/m16{sae}``
``EVEX.LIG.F3.MAP5.W0 2C /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTTSH2SI_R64_XMMM16_SAE: int = 4397
"""
``VCVTTSH2SI r64, xmm1/m16{sae}``
``EVEX.LIG.F3.MAP5.W1 2C /r``
``AVX512-FP16``
``64-bit``
"""
EVEX_VCVTTSH2USI_R32_XMMM16_SAE: int = 4398
"""
``VCVTTSH2USI r32, xmm1/m16{sae}``
``EVEX.LIG.F3.MAP5.W0 78 /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTTSH2USI_R64_XMMM16_SAE: int = 4399
"""
``VCVTTSH2USI r64, xmm1/m16{sae}``
``EVEX.LIG.F3.MAP5.W1 78 /r``
``AVX512-FP16``
``64-bit``
"""
EVEX_VCVTUDQ2PH_XMM_K1Z_XMMM128B32: int = 4400
"""
``VCVTUDQ2PH xmm1 {k1}{z}, xmm2/m128/m32bcst``
``EVEX.128.F2.MAP5.W0 7A /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTUDQ2PH_XMM_K1Z_YMMM256B32: int = 4401
"""
``VCVTUDQ2PH xmm1 {k1}{z}, ymm2/m256/m32bcst``
``EVEX.256.F2.MAP5.W0 7A /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTUDQ2PH_YMM_K1Z_ZMMM512B32_ER: int = 4402
"""
``VCVTUDQ2PH ymm1 {k1}{z}, zmm2/m512/m32bcst{er}``
``EVEX.512.F2.MAP5.W0 7A /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTUQQ2PH_XMM_K1Z_XMMM128B64: int = 4403
"""
``VCVTUQQ2PH xmm1 {k1}{z}, xmm2/m128/m64bcst``
``EVEX.128.F2.MAP5.W1 7A /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTUQQ2PH_XMM_K1Z_YMMM256B64: int = 4404
"""
``VCVTUQQ2PH xmm1 {k1}{z}, ymm2/m256/m64bcst``
``EVEX.256.F2.MAP5.W1 7A /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTUQQ2PH_XMM_K1Z_ZMMM512B64_ER: int = 4405
"""
``VCVTUQQ2PH xmm1 {k1}{z}, zmm2/m512/m64bcst{er}``
``EVEX.512.F2.MAP5.W1 7A /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTUSI2SH_XMM_XMM_RM32_ER: int = 4406
"""
``VCVTUSI2SH xmm1, xmm2, r/m32{er}``
``EVEX.LIG.F3.MAP5.W0 7B /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTUSI2SH_XMM_XMM_RM64_ER: int = 4407
"""
``VCVTUSI2SH xmm1, xmm2, r/m64{er}``
``EVEX.LIG.F3.MAP5.W1 7B /r``
``AVX512-FP16``
``64-bit``
"""
EVEX_VCVTUW2PH_XMM_K1Z_XMMM128B16: int = 4408
"""
``VCVTUW2PH xmm1 {k1}{z}, xmm2/m128/m16bcst``
``EVEX.128.F2.MAP5.W0 7D /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTUW2PH_YMM_K1Z_YMMM256B16: int = 4409
"""
``VCVTUW2PH ymm1 {k1}{z}, ymm2/m256/m16bcst``
``EVEX.256.F2.MAP5.W0 7D /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTUW2PH_ZMM_K1Z_ZMMM512B16_ER: int = 4410
"""
``VCVTUW2PH zmm1 {k1}{z}, zmm2/m512/m16bcst{er}``
``EVEX.512.F2.MAP5.W0 7D /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTW2PH_XMM_K1Z_XMMM128B16: int = 4411
"""
``VCVTW2PH xmm1 {k1}{z}, xmm2/m128/m16bcst``
``EVEX.128.F3.MAP5.W0 7D /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTW2PH_YMM_K1Z_YMMM256B16: int = 4412
"""
``VCVTW2PH ymm1 {k1}{z}, ymm2/m256/m16bcst``
``EVEX.256.F3.MAP5.W0 7D /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VCVTW2PH_ZMM_K1Z_ZMMM512B16_ER: int = 4413
"""
``VCVTW2PH zmm1 {k1}{z}, zmm2/m512/m16bcst{er}``
``EVEX.512.F3.MAP5.W0 7D /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VDIVPH_XMM_K1Z_XMM_XMMM128B16: int = 4414
"""
``VDIVPH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst``
``EVEX.128.MAP5.W0 5E /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VDIVPH_YMM_K1Z_YMM_YMMM256B16: int = 4415
"""
``VDIVPH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst``
``EVEX.256.MAP5.W0 5E /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VDIVPH_ZMM_K1Z_ZMM_ZMMM512B16_ER: int = 4416
"""
``VDIVPH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}``
``EVEX.512.MAP5.W0 5E /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VDIVSH_XMM_K1Z_XMM_XMMM16_ER: int = 4417
"""
``VDIVSH xmm1 {k1}{z}, xmm2, xmm3/m16{er}``
``EVEX.LIG.F3.MAP5.W0 5E /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFCMADDCPH_XMM_K1Z_XMM_XMMM128B32: int = 4418
"""
``VFCMADDCPH xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.F2.MAP6.W0 56 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFCMADDCPH_YMM_K1Z_YMM_YMMM256B32: int = 4419
"""
``VFCMADDCPH ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.F2.MAP6.W0 56 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFCMADDCPH_ZMM_K1Z_ZMM_ZMMM512B32_ER: int = 4420
"""
``VFCMADDCPH zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}``
``EVEX.512.F2.MAP6.W0 56 /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMADDCPH_XMM_K1Z_XMM_XMMM128B32: int = 4421
"""
``VFMADDCPH xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.F3.MAP6.W0 56 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMADDCPH_YMM_K1Z_YMM_YMMM256B32: int = 4422
"""
``VFMADDCPH ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.F3.MAP6.W0 56 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMADDCPH_ZMM_K1Z_ZMM_ZMMM512B32_ER: int = 4423
"""
``VFMADDCPH zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}``
``EVEX.512.F3.MAP6.W0 56 /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFCMADDCSH_XMM_K1Z_XMM_XMMM32_ER: int = 4424
"""
``VFCMADDCSH xmm1 {k1}{z}, xmm2, xmm3/m32{er}``
``EVEX.LIG.F2.MAP6.W0 57 /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMADDCSH_XMM_K1Z_XMM_XMMM32_ER: int = 4425
"""
``VFMADDCSH xmm1 {k1}{z}, xmm2, xmm3/m32{er}``
``EVEX.LIG.F3.MAP6.W0 57 /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFCMULCPH_XMM_K1Z_XMM_XMMM128B32: int = 4426
"""
``VFCMULCPH xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.F2.MAP6.W0 D6 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFCMULCPH_YMM_K1Z_YMM_YMMM256B32: int = 4427
"""
``VFCMULCPH ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.F2.MAP6.W0 D6 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFCMULCPH_ZMM_K1Z_ZMM_ZMMM512B32_ER: int = 4428
"""
``VFCMULCPH zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}``
``EVEX.512.F2.MAP6.W0 D6 /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMULCPH_XMM_K1Z_XMM_XMMM128B32: int = 4429
"""
``VFMULCPH xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst``
``EVEX.128.F3.MAP6.W0 D6 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMULCPH_YMM_K1Z_YMM_YMMM256B32: int = 4430
"""
``VFMULCPH ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst``
``EVEX.256.F3.MAP6.W0 D6 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMULCPH_ZMM_K1Z_ZMM_ZMMM512B32_ER: int = 4431
"""
``VFMULCPH zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}``
``EVEX.512.F3.MAP6.W0 D6 /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFCMULCSH_XMM_K1Z_XMM_XMMM32_ER: int = 4432
"""
``VFCMULCSH xmm1 {k1}{z}, xmm2, xmm3/m32{er}``
``EVEX.LIG.F2.MAP6.W0 D7 /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMULCSH_XMM_K1Z_XMM_XMMM32_ER: int = 4433
"""
``VFMULCSH xmm1 {k1}{z}, xmm2, xmm3/m32{er}``
``EVEX.LIG.F3.MAP6.W0 D7 /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMADDSUB132PH_XMM_K1Z_XMM_XMMM128B16: int = 4434
"""
``VFMADDSUB132PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst``
``EVEX.128.66.MAP6.W0 96 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMADDSUB132PH_YMM_K1Z_YMM_YMMM256B16: int = 4435
"""
``VFMADDSUB132PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst``
``EVEX.256.66.MAP6.W0 96 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMADDSUB132PH_ZMM_K1Z_ZMM_ZMMM512B16_ER: int = 4436
"""
``VFMADDSUB132PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}``
``EVEX.512.66.MAP6.W0 96 /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMADDSUB213PH_XMM_K1Z_XMM_XMMM128B16: int = 4437
"""
``VFMADDSUB213PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst``
``EVEX.128.66.MAP6.W0 A6 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMADDSUB213PH_YMM_K1Z_YMM_YMMM256B16: int = 4438
"""
``VFMADDSUB213PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst``
``EVEX.256.66.MAP6.W0 A6 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMADDSUB213PH_ZMM_K1Z_ZMM_ZMMM512B16_ER: int = 4439
"""
``VFMADDSUB213PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}``
``EVEX.512.66.MAP6.W0 A6 /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMADDSUB231PH_XMM_K1Z_XMM_XMMM128B16: int = 4440
"""
``VFMADDSUB231PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst``
``EVEX.128.66.MAP6.W0 B6 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMADDSUB231PH_YMM_K1Z_YMM_YMMM256B16: int = 4441
"""
``VFMADDSUB231PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst``
``EVEX.256.66.MAP6.W0 B6 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMADDSUB231PH_ZMM_K1Z_ZMM_ZMMM512B16_ER: int = 4442
"""
``VFMADDSUB231PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}``
``EVEX.512.66.MAP6.W0 B6 /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMSUBADD132PH_XMM_K1Z_XMM_XMMM128B16: int = 4443
"""
``VFMSUBADD132PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst``
``EVEX.128.66.MAP6.W0 97 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMSUBADD132PH_YMM_K1Z_YMM_YMMM256B16: int = 4444
"""
``VFMSUBADD132PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst``
``EVEX.256.66.MAP6.W0 97 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMSUBADD132PH_ZMM_K1Z_ZMM_ZMMM512B16_ER: int = 4445
"""
``VFMSUBADD132PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}``
``EVEX.512.66.MAP6.W0 97 /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMSUBADD213PH_XMM_K1Z_XMM_XMMM128B16: int = 4446
"""
``VFMSUBADD213PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst``
``EVEX.128.66.MAP6.W0 A7 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMSUBADD213PH_YMM_K1Z_YMM_YMMM256B16: int = 4447
"""
``VFMSUBADD213PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst``
``EVEX.256.66.MAP6.W0 A7 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMSUBADD213PH_ZMM_K1Z_ZMM_ZMMM512B16_ER: int = 4448
"""
``VFMSUBADD213PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}``
``EVEX.512.66.MAP6.W0 A7 /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMSUBADD231PH_XMM_K1Z_XMM_XMMM128B16: int = 4449
"""
``VFMSUBADD231PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst``
``EVEX.128.66.MAP6.W0 B7 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMSUBADD231PH_YMM_K1Z_YMM_YMMM256B16: int = 4450
"""
``VFMSUBADD231PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst``
``EVEX.256.66.MAP6.W0 B7 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMSUBADD231PH_ZMM_K1Z_ZMM_ZMMM512B16_ER: int = 4451
"""
``VFMSUBADD231PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}``
``EVEX.512.66.MAP6.W0 B7 /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMADD132PH_XMM_K1Z_XMM_XMMM128B16: int = 4452
"""
``VFMADD132PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst``
``EVEX.128.66.MAP6.W0 98 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMADD132PH_YMM_K1Z_YMM_YMMM256B16: int = 4453
"""
``VFMADD132PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst``
``EVEX.256.66.MAP6.W0 98 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMADD132PH_ZMM_K1Z_ZMM_ZMMM512B16_ER: int = 4454
"""
``VFMADD132PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}``
``EVEX.512.66.MAP6.W0 98 /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMADD213PH_XMM_K1Z_XMM_XMMM128B16: int = 4455
"""
``VFMADD213PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst``
``EVEX.128.66.MAP6.W0 A8 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMADD213PH_YMM_K1Z_YMM_YMMM256B16: int = 4456
"""
``VFMADD213PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst``
``EVEX.256.66.MAP6.W0 A8 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMADD213PH_ZMM_K1Z_ZMM_ZMMM512B16_ER: int = 4457
"""
``VFMADD213PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}``
``EVEX.512.66.MAP6.W0 A8 /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMADD231PH_XMM_K1Z_XMM_XMMM128B16: int = 4458
"""
``VFMADD231PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst``
``EVEX.128.66.MAP6.W0 B8 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMADD231PH_YMM_K1Z_YMM_YMMM256B16: int = 4459
"""
``VFMADD231PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst``
``EVEX.256.66.MAP6.W0 B8 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMADD231PH_ZMM_K1Z_ZMM_ZMMM512B16_ER: int = 4460
"""
``VFMADD231PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}``
``EVEX.512.66.MAP6.W0 B8 /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFNMADD132PH_XMM_K1Z_XMM_XMMM128B16: int = 4461
"""
``VFNMADD132PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst``
``EVEX.128.66.MAP6.W0 9C /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFNMADD132PH_YMM_K1Z_YMM_YMMM256B16: int = 4462
"""
``VFNMADD132PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst``
``EVEX.256.66.MAP6.W0 9C /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFNMADD132PH_ZMM_K1Z_ZMM_ZMMM512B16_ER: int = 4463
"""
``VFNMADD132PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}``
``EVEX.512.66.MAP6.W0 9C /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFNMADD213PH_XMM_K1Z_XMM_XMMM128B16: int = 4464
"""
``VFNMADD213PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst``
``EVEX.128.66.MAP6.W0 AC /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFNMADD213PH_YMM_K1Z_YMM_YMMM256B16: int = 4465
"""
``VFNMADD213PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst``
``EVEX.256.66.MAP6.W0 AC /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFNMADD213PH_ZMM_K1Z_ZMM_ZMMM512B16_ER: int = 4466
"""
``VFNMADD213PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}``
``EVEX.512.66.MAP6.W0 AC /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFNMADD231PH_XMM_K1Z_XMM_XMMM128B16: int = 4467
"""
``VFNMADD231PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst``
``EVEX.128.66.MAP6.W0 BC /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFNMADD231PH_YMM_K1Z_YMM_YMMM256B16: int = 4468
"""
``VFNMADD231PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst``
``EVEX.256.66.MAP6.W0 BC /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFNMADD231PH_ZMM_K1Z_ZMM_ZMMM512B16_ER: int = 4469
"""
``VFNMADD231PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}``
``EVEX.512.66.MAP6.W0 BC /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMADD132SH_XMM_K1Z_XMM_XMMM16_ER: int = 4470
"""
``VFMADD132SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}``
``EVEX.LIG.66.MAP6.W0 99 /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMADD213SH_XMM_K1Z_XMM_XMMM16_ER: int = 4471
"""
``VFMADD213SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}``
``EVEX.LIG.66.MAP6.W0 A9 /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMADD231SH_XMM_K1Z_XMM_XMMM16_ER: int = 4472
"""
``VFMADD231SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}``
``EVEX.LIG.66.MAP6.W0 B9 /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFNMADD132SH_XMM_K1Z_XMM_XMMM16_ER: int = 4473
"""
``VFNMADD132SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}``
``EVEX.LIG.66.MAP6.W0 9D /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFNMADD213SH_XMM_K1Z_XMM_XMMM16_ER: int = 4474
"""
``VFNMADD213SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}``
``EVEX.LIG.66.MAP6.W0 AD /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFNMADD231SH_XMM_K1Z_XMM_XMMM16_ER: int = 4475
"""
``VFNMADD231SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}``
``EVEX.LIG.66.MAP6.W0 BD /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMSUB132PH_XMM_K1Z_XMM_XMMM128B16: int = 4476
"""
``VFMSUB132PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst``
``EVEX.128.66.MAP6.W0 9A /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMSUB132PH_YMM_K1Z_YMM_YMMM256B16: int = 4477
"""
``VFMSUB132PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst``
``EVEX.256.66.MAP6.W0 9A /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMSUB132PH_ZMM_K1Z_ZMM_ZMMM512B16_ER: int = 4478
"""
``VFMSUB132PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}``
``EVEX.512.66.MAP6.W0 9A /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMSUB213PH_XMM_K1Z_XMM_XMMM128B16: int = 4479
"""
``VFMSUB213PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst``
``EVEX.128.66.MAP6.W0 AA /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMSUB213PH_YMM_K1Z_YMM_YMMM256B16: int = 4480
"""
``VFMSUB213PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst``
``EVEX.256.66.MAP6.W0 AA /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMSUB213PH_ZMM_K1Z_ZMM_ZMMM512B16_ER: int = 4481
"""
``VFMSUB213PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}``
``EVEX.512.66.MAP6.W0 AA /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMSUB231PH_XMM_K1Z_XMM_XMMM128B16: int = 4482
"""
``VFMSUB231PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst``
``EVEX.128.66.MAP6.W0 BA /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMSUB231PH_YMM_K1Z_YMM_YMMM256B16: int = 4483
"""
``VFMSUB231PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst``
``EVEX.256.66.MAP6.W0 BA /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMSUB231PH_ZMM_K1Z_ZMM_ZMMM512B16_ER: int = 4484
"""
``VFMSUB231PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}``
``EVEX.512.66.MAP6.W0 BA /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFNMSUB132PH_XMM_K1Z_XMM_XMMM128B16: int = 4485
"""
``VFNMSUB132PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst``
``EVEX.128.66.MAP6.W0 9E /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFNMSUB132PH_YMM_K1Z_YMM_YMMM256B16: int = 4486
"""
``VFNMSUB132PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst``
``EVEX.256.66.MAP6.W0 9E /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFNMSUB132PH_ZMM_K1Z_ZMM_ZMMM512B16_ER: int = 4487
"""
``VFNMSUB132PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}``
``EVEX.512.66.MAP6.W0 9E /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFNMSUB213PH_XMM_K1Z_XMM_XMMM128B16: int = 4488
"""
``VFNMSUB213PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst``
``EVEX.128.66.MAP6.W0 AE /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFNMSUB213PH_YMM_K1Z_YMM_YMMM256B16: int = 4489
"""
``VFNMSUB213PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst``
``EVEX.256.66.MAP6.W0 AE /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFNMSUB213PH_ZMM_K1Z_ZMM_ZMMM512B16_ER: int = 4490
"""
``VFNMSUB213PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}``
``EVEX.512.66.MAP6.W0 AE /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFNMSUB231PH_XMM_K1Z_XMM_XMMM128B16: int = 4491
"""
``VFNMSUB231PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst``
``EVEX.128.66.MAP6.W0 BE /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFNMSUB231PH_YMM_K1Z_YMM_YMMM256B16: int = 4492
"""
``VFNMSUB231PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst``
``EVEX.256.66.MAP6.W0 BE /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFNMSUB231PH_ZMM_K1Z_ZMM_ZMMM512B16_ER: int = 4493
"""
``VFNMSUB231PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}``
``EVEX.512.66.MAP6.W0 BE /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMSUB132SH_XMM_K1Z_XMM_XMMM16_ER: int = 4494
"""
``VFMSUB132SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}``
``EVEX.LIG.66.MAP6.W0 9B /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMSUB213SH_XMM_K1Z_XMM_XMMM16_ER: int = 4495
"""
``VFMSUB213SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}``
``EVEX.LIG.66.MAP6.W0 AB /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFMSUB231SH_XMM_K1Z_XMM_XMMM16_ER: int = 4496
"""
``VFMSUB231SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}``
``EVEX.LIG.66.MAP6.W0 BB /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFNMSUB132SH_XMM_K1Z_XMM_XMMM16_ER: int = 4497
"""
``VFNMSUB132SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}``
``EVEX.LIG.66.MAP6.W0 9F /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFNMSUB213SH_XMM_K1Z_XMM_XMMM16_ER: int = 4498
"""
``VFNMSUB213SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}``
``EVEX.LIG.66.MAP6.W0 AF /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFNMSUB231SH_XMM_K1Z_XMM_XMMM16_ER: int = 4499
"""
``VFNMSUB231SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}``
``EVEX.LIG.66.MAP6.W0 BF /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFPCLASSPH_KR_K1_XMMM128B16_IMM8: int = 4500
"""
``VFPCLASSPH k1 {k2}, xmm2/m128/m16bcst, imm8``
``EVEX.128.0F3A.W0 66 /r ib``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFPCLASSPH_KR_K1_YMMM256B16_IMM8: int = 4501
"""
``VFPCLASSPH k1 {k2}, ymm2/m256/m16bcst, imm8``
``EVEX.256.0F3A.W0 66 /r ib``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFPCLASSPH_KR_K1_ZMMM512B16_IMM8: int = 4502
"""
``VFPCLASSPH k1 {k2}, zmm2/m512/m16bcst, imm8``
``EVEX.512.0F3A.W0 66 /r ib``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VFPCLASSSH_KR_K1_XMMM16_IMM8: int = 4503
"""
``VFPCLASSSH k1 {k2}, xmm2/m16, imm8``
``EVEX.LIG.0F3A.W0 67 /r ib``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VGETEXPPH_XMM_K1Z_XMMM128B16: int = 4504
"""
``VGETEXPPH xmm1 {k1}{z}, xmm2/m128/m16bcst``
``EVEX.128.66.MAP6.W0 42 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VGETEXPPH_YMM_K1Z_YMMM256B16: int = 4505
"""
``VGETEXPPH ymm1 {k1}{z}, ymm2/m256/m16bcst``
``EVEX.256.66.MAP6.W0 42 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VGETEXPPH_ZMM_K1Z_ZMMM512B16_SAE: int = 4506
"""
``VGETEXPPH zmm1 {k1}{z}, zmm2/m512/m16bcst{sae}``
``EVEX.512.66.MAP6.W0 42 /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VGETEXPSH_XMM_K1Z_XMM_XMMM16_SAE: int = 4507
"""
``VGETEXPSH xmm1 {k1}{z}, xmm2, xmm3/m16{sae}``
``EVEX.LIG.66.MAP6.W0 43 /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VGETMANTPH_XMM_K1Z_XMMM128B16_IMM8: int = 4508
"""
``VGETMANTPH xmm1 {k1}{z}, xmm2/m128/m16bcst, imm8``
``EVEX.128.0F3A.W0 26 /r ib``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VGETMANTPH_YMM_K1Z_YMMM256B16_IMM8: int = 4509
"""
``VGETMANTPH ymm1 {k1}{z}, ymm2/m256/m16bcst, imm8``
``EVEX.256.0F3A.W0 26 /r ib``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VGETMANTPH_ZMM_K1Z_ZMMM512B16_IMM8_SAE: int = 4510
"""
``VGETMANTPH zmm1 {k1}{z}, zmm2/m512/m16bcst{sae}, imm8``
``EVEX.512.0F3A.W0 26 /r ib``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VGETMANTSH_XMM_K1Z_XMM_XMMM16_IMM8_SAE: int = 4511
"""
``VGETMANTSH xmm1 {k1}{z}, xmm2, xmm3/m16{sae}, imm8``
``EVEX.LIG.0F3A.W0 27 /r ib``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VMAXPH_XMM_K1Z_XMM_XMMM128B16: int = 4512
"""
``VMAXPH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst``
``EVEX.128.MAP5.W0 5F /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VMAXPH_YMM_K1Z_YMM_YMMM256B16: int = 4513
"""
``VMAXPH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst``
``EVEX.256.MAP5.W0 5F /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VMAXPH_ZMM_K1Z_ZMM_ZMMM512B16_SAE: int = 4514
"""
``VMAXPH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{sae}``
``EVEX.512.MAP5.W0 5F /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VMAXSH_XMM_K1Z_XMM_XMMM16_SAE: int = 4515
"""
``VMAXSH xmm1 {k1}{z}, xmm2, xmm3/m16{sae}``
``EVEX.LIG.F3.MAP5.W0 5F /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VMINPH_XMM_K1Z_XMM_XMMM128B16: int = 4516
"""
``VMINPH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst``
``EVEX.128.MAP5.W0 5D /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VMINPH_YMM_K1Z_YMM_YMMM256B16: int = 4517
"""
``VMINPH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst``
``EVEX.256.MAP5.W0 5D /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VMINPH_ZMM_K1Z_ZMM_ZMMM512B16_SAE: int = 4518
"""
``VMINPH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{sae}``
``EVEX.512.MAP5.W0 5D /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VMINSH_XMM_K1Z_XMM_XMMM16_SAE: int = 4519
"""
``VMINSH xmm1 {k1}{z}, xmm2, xmm3/m16{sae}``
``EVEX.LIG.F3.MAP5.W0 5D /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VMOVSH_XMM_K1Z_M16: int = 4520
"""
``VMOVSH xmm1 {k1}{z}, m16``
``EVEX.LIG.F3.MAP5.W0 10 /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VMOVSH_M16_K1_XMM: int = 4521
"""
``VMOVSH m16 {k1}, xmm1``
``EVEX.LIG.F3.MAP5.W0 11 /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VMOVSH_XMM_K1Z_XMM_XMM: int = 4522
"""
``VMOVSH xmm1 {k1}{z}, xmm2, xmm3``
``EVEX.LIG.F3.MAP5.W0 10 /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VMOVSH_XMM_K1Z_XMM_XMM_MAP5_11: int = 4523
"""
``VMOVSH xmm1 {k1}{z}, xmm2, xmm3``
``EVEX.LIG.F3.MAP5.W0 11 /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VMOVW_XMM_R32M16: int = 4524
"""
``VMOVW xmm1, r32/m16``
``EVEX.128.66.MAP5.W0 6E /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VMOVW_XMM_R64M16: int = 4525
"""
``VMOVW xmm1, r64/m16``
``EVEX.128.66.MAP5.W1 6E /r``
``AVX512-FP16``
``64-bit``
"""
EVEX_VMOVW_R32M16_XMM: int = 4526
"""
``VMOVW r32/m16, xmm1``
``EVEX.128.66.MAP5.W0 7E /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VMOVW_R64M16_XMM: int = 4527
"""
``VMOVW r64/m16, xmm1``
``EVEX.128.66.MAP5.W1 7E /r``
``AVX512-FP16``
``64-bit``
"""
EVEX_VMULPH_XMM_K1Z_XMM_XMMM128B16: int = 4528
"""
``VMULPH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst``
``EVEX.128.MAP5.W0 59 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VMULPH_YMM_K1Z_YMM_YMMM256B16: int = 4529
"""
``VMULPH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst``
``EVEX.256.MAP5.W0 59 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VMULPH_ZMM_K1Z_ZMM_ZMMM512B16_ER: int = 4530
"""
``VMULPH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}``
``EVEX.512.MAP5.W0 59 /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VMULSH_XMM_K1Z_XMM_XMMM16_ER: int = 4531
"""
``VMULSH xmm1 {k1}{z}, xmm2, xmm3/m16{er}``
``EVEX.LIG.F3.MAP5.W0 59 /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VRCPPH_XMM_K1Z_XMMM128B16: int = 4532
"""
``VRCPPH xmm1 {k1}{z}, xmm2/m128/m16bcst``
``EVEX.128.66.MAP6.W0 4C /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VRCPPH_YMM_K1Z_YMMM256B16: int = 4533
"""
``VRCPPH ymm1 {k1}{z}, ymm2/m256/m16bcst``
``EVEX.256.66.MAP6.W0 4C /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VRCPPH_ZMM_K1Z_ZMMM512B16: int = 4534
"""
``VRCPPH zmm1 {k1}{z}, zmm2/m512/m16bcst``
``EVEX.512.66.MAP6.W0 4C /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VRCPSH_XMM_K1Z_XMM_XMMM16: int = 4535
"""
``VRCPSH xmm1 {k1}{z}, xmm2, xmm3/m16``
``EVEX.LIG.66.MAP6.W0 4D /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VREDUCEPH_XMM_K1Z_XMMM128B16_IMM8: int = 4536
"""
``VREDUCEPH xmm1 {k1}{z}, xmm2/m128/m16bcst, imm8``
``EVEX.128.0F3A.W0 56 /r ib``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VREDUCEPH_YMM_K1Z_YMMM256B16_IMM8: int = 4537
"""
``VREDUCEPH ymm1 {k1}{z}, ymm2/m256/m16bcst, imm8``
``EVEX.256.0F3A.W0 56 /r ib``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VREDUCEPH_ZMM_K1Z_ZMMM512B16_IMM8_SAE: int = 4538
"""
``VREDUCEPH zmm1 {k1}{z}, zmm2/m512/m16bcst{sae}, imm8``
``EVEX.512.0F3A.W0 56 /r ib``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VREDUCESH_XMM_K1Z_XMM_XMMM16_IMM8_SAE: int = 4539
"""
``VREDUCESH xmm1 {k1}{z}, xmm2, xmm3/m16{sae}, imm8``
``EVEX.LIG.0F3A.W0 57 /r ib``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VRNDSCALEPH_XMM_K1Z_XMMM128B16_IMM8: int = 4540
"""
``VRNDSCALEPH xmm1 {k1}{z}, xmm2/m128/m16bcst, imm8``
``EVEX.128.0F3A.W0 08 /r ib``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VRNDSCALEPH_YMM_K1Z_YMMM256B16_IMM8: int = 4541
"""
``VRNDSCALEPH ymm1 {k1}{z}, ymm2/m256/m16bcst, imm8``
``EVEX.256.0F3A.W0 08 /r ib``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VRNDSCALEPH_ZMM_K1Z_ZMMM512B16_IMM8_SAE: int = 4542
"""
``VRNDSCALEPH zmm1 {k1}{z}, zmm2/m512/m16bcst{sae}, imm8``
``EVEX.512.0F3A.W0 08 /r ib``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VRNDSCALESH_XMM_K1Z_XMM_XMMM16_IMM8_SAE: int = 4543
"""
``VRNDSCALESH xmm1 {k1}{z}, xmm2, xmm3/m16{sae}, imm8``
``EVEX.LIG.0F3A.W0 0A /r ib``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VRSQRTPH_XMM_K1Z_XMMM128B16: int = 4544
"""
``VRSQRTPH xmm1 {k1}{z}, xmm2/m128/m16bcst``
``EVEX.128.66.MAP6.W0 4E /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VRSQRTPH_YMM_K1Z_YMMM256B16: int = 4545
"""
``VRSQRTPH ymm1 {k1}{z}, ymm2/m256/m16bcst``
``EVEX.256.66.MAP6.W0 4E /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VRSQRTPH_ZMM_K1Z_ZMMM512B16: int = 4546
"""
``VRSQRTPH zmm1 {k1}{z}, zmm2/m512/m16bcst``
``EVEX.512.66.MAP6.W0 4E /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VRSQRTSH_XMM_K1Z_XMM_XMMM16: int = 4547
"""
``VRSQRTSH xmm1 {k1}{z}, xmm2, xmm3/m16``
``EVEX.LIG.66.MAP6.W0 4F /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VSCALEFPH_XMM_K1Z_XMM_XMMM128B16: int = 4548
"""
``VSCALEFPH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst``
``EVEX.128.66.MAP6.W0 2C /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VSCALEFPH_YMM_K1Z_YMM_YMMM256B16: int = 4549
"""
``VSCALEFPH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst``
``EVEX.256.66.MAP6.W0 2C /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VSCALEFPH_ZMM_K1Z_ZMM_ZMMM512B16_ER: int = 4550
"""
``VSCALEFPH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}``
``EVEX.512.66.MAP6.W0 2C /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VSCALEFSH_XMM_K1Z_XMM_XMMM16_ER: int = 4551
"""
``VSCALEFSH xmm1 {k1}{z}, xmm2, xmm3/m16{er}``
``EVEX.LIG.66.MAP6.W0 2D /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VSQRTPH_XMM_K1Z_XMMM128B16: int = 4552
"""
``VSQRTPH xmm1 {k1}{z}, xmm2/m128/m16bcst``
``EVEX.128.MAP5.W0 51 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VSQRTPH_YMM_K1Z_YMMM256B16: int = 4553
"""
``VSQRTPH ymm1 {k1}{z}, ymm2/m256/m16bcst``
``EVEX.256.MAP5.W0 51 /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VSQRTPH_ZMM_K1Z_ZMMM512B16_ER: int = 4554
"""
``VSQRTPH zmm1 {k1}{z}, zmm2/m512/m16bcst{er}``
``EVEX.512.MAP5.W0 51 /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VSQRTSH_XMM_K1Z_XMM_XMMM16_ER: int = 4555
"""
``VSQRTSH xmm1 {k1}{z}, xmm2, xmm3/m16{er}``
``EVEX.LIG.F3.MAP5.W0 51 /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VSUBPH_XMM_K1Z_XMM_XMMM128B16: int = 4556
"""
``VSUBPH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst``
``EVEX.128.MAP5.W0 5C /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VSUBPH_YMM_K1Z_YMM_YMMM256B16: int = 4557
"""
``VSUBPH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst``
``EVEX.256.MAP5.W0 5C /r``
``AVX512VL and AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VSUBPH_ZMM_K1Z_ZMM_ZMMM512B16_ER: int = 4558
"""
``VSUBPH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}``
``EVEX.512.MAP5.W0 5C /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VSUBSH_XMM_K1Z_XMM_XMMM16_ER: int = 4559
"""
``VSUBSH xmm1 {k1}{z}, xmm2, xmm3/m16{er}``
``EVEX.LIG.F3.MAP5.W0 5C /r``
``AVX512-FP16``
``16/32/64-bit``
"""
EVEX_VUCOMISH_XMM_XMMM16_SAE: int = 4560
"""
``VUCOMISH xmm1, xmm2/m16{sae}``
``EVEX.LIG.MAP5.W0 2E /r``
``AVX512-FP16``
``16/32/64-bit``
"""
RDUDBG: int = 4561
"""
``RDUDBG``
``0F 0E``
``UDBG``
``16/32/64-bit``
"""
WRUDBG: int = 4562
"""
``WRUDBG``
``0F 0F``
``UDBG``
``16/32/64-bit``
"""
| |
incbeta.go
|
// Copyright ©2016 The Gonum Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
/*
* Cephes Math Library, Release 2.3: March, 1995
* Copyright 1984, 1995 by Stephen L. Moshier
*/
package cephes
import (
"math"
"github.com/gopherd/gonum/mathext/internal/gonum"
)
const (
maxGam = 171.624376956302725
big = 4.503599627370496e15
biginv = 2.22044604925031308085e-16
)
// Incbet computes the regularized incomplete beta function.
func Incbet(aa, bb, xx float64) float64 {
if aa <= 0 || bb <= 0 {
panic(paramOutOfBounds)
}
if xx <= 0 || xx >= 1 {
if xx == 0 {
return 0
}
if xx == 1 {
return 1
}
panic(paramOutOfBounds)
}
var flag int
if bb*xx <= 1 && xx <= 0.95 {
t := pseries(aa, bb, xx)
return transformT(t, flag)
}
w := 1 - xx
// Reverse a and b if x is greater than the mean.
var a, b, xc, x float64
if xx > aa/(aa+bb) {
flag = 1
a = bb
b = aa
xc = xx
x = w
} else {
a = aa
b = bb
xc = w
x = xx
}
if flag == 1 && (b*x) <= 1.0 && x <= 0.95 {
t := pseries(a, b, x)
return transformT(t, flag)
}
// Choose expansion for better convergence.
y := x*(a+b-2.0) - (a - 1.0)
if y < 0.0 {
w = incbcf(a, b, x)
} else {
w = incbd(a, b, x) / xc
}
// Multiply w by the factor
// x^a * (1-x)^b * Γ(a+b) / (a*Γ(a)*Γ(b))
var t float64
y = a * math.Log(x)
t = b * math.Log(xc)
if (a+b) < maxGam && math.Abs(y) < maxLog && math.Abs(t) < maxLog {
t = math.Pow(xc, b)
t *= math.Pow(x, a)
t /= a
t *= w
t *= 1.0 / gonum.Beta(a, b)
return transformT(t, flag)
}
// Resort to logarithms.
y += t - gonum.Lbeta(a, b)
y += math.Log(w / a)
if y < minLog {
t = 0.0
} else {
t = math.Exp(y)
}
return transformT(t, flag)
}
func transformT(t float64, flag int) float64 {
if flag == 1 {
if t <= machEp {
t = 1.0 - machEp
} else {
t = 1.0 - t
}
}
return t
}
// incbcf returns the incomplete beta integral evaluated by a continued fraction
// expansion.
func incbcf(a, b, x float64) float64 {
var xk, pk, pkm1, pkm2, qk, qkm1, qkm2 float64
var k1, k2, k3, k4, k5, k6, k7, k8 float64
var r, t, ans, thresh float64
var n int
k1 = a
k2 = a + b
k3 = a
k4 = a + 1.0
k5 = 1.0
k6 = b - 1.0
k7 = k4
k8 = a + 2.0
pkm2 = 0.0
qkm2 = 1.0
pkm1 = 1.0
qkm1 = 1.0
ans = 1.0
r = 1.0
thresh = 3.0 * machEp
for n = 0; n <= 300; n++ {
xk = -(x * k1 * k2) / (k3 * k4)
pk = pkm1 + pkm2*xk
qk = qkm1 + qkm2*xk
pkm2 = pkm1
pkm1 = pk
qkm2 = qkm1
qkm1 = qk
xk = (x * k5 * k6) / (k7 * k8)
pk = pkm1 + pkm2*xk
qk = qkm1 + qkm2*xk
pkm2 = pkm1
pkm1 = pk
qkm2 = qkm1
qkm1 = qk
if qk != 0 {
r = pk / qk
}
if r != 0 {
t = math.Abs((ans - r) / r)
ans = r
} else {
t = 1.0
}
if t < thresh {
return ans
}
k1 += 1.0
k2 += 1.0
k3 += 2.0
k4 += 2.0
k5 += 1.0
k6 -= 1.0
k7 += 2.0
k8 += 2.0
if (math.Abs(qk) + math.Abs(pk)) > big {
pkm2 *= biginv
pkm1 *= biginv
qkm2 *= biginv
qkm1 *= biginv
}
if (math.Abs(qk) < biginv) || (math.Abs(pk) < biginv) {
pkm2 *= big
pkm1 *= big
qkm2 *= big
qkm1 *= big
}
}
return ans
}
// incbd returns the incomplete beta integral evaluated by a continued fraction
// expansion.
func incbd(a, b, x float64) float64 {
var xk, pk, pkm1, pkm2, qk, qkm1, qkm2 float64
var k1, k2, k3, k4, k5, k6, k7, k8 float64
var r, t, ans, z, thresh float64
var n int
k1 = a
k2 = b - 1.0
k3 = a
k4 = a + 1.0
k5 = 1.0
k6 = a + b
k7 = a + 1.0
k8 = a + 2.0
pkm2 = 0.0
qkm2 = 1.0
pkm1 = 1.0
qkm1 = 1.0
z = x / (1.0 - x)
ans = 1.0
r = 1.0
thresh = 3.0 * machEp
for n = 0; n <= 300; n++ {
xk = -(z * k1 * k2) / (k3 * k4)
pk = pkm1 + pkm2*xk
qk = qkm1 + qkm2*xk
pkm2 = pkm1
pkm1 = pk
qkm2 = qkm1
qkm1 = qk
xk = (z * k5 * k6) / (k7 * k8)
pk = pkm1 + pkm2*xk
qk = qkm1 + qkm2*xk
pkm2 = pkm1
pkm1 = pk
qkm2 = qkm1
qkm1 = qk
if qk != 0 {
r = pk / qk
}
if r != 0 {
t = math.Abs((ans - r) / r)
ans = r
} else {
t = 1.0
}
if t < thresh {
return ans
}
k1 += 1.0
k2 -= 1.0
k3 += 2.0
k4 += 2.0
k5 += 1.0
k6 += 1.0
k7 += 2.0
k8 += 2.0
if (math.Abs(qk) + math.Abs(pk)) > big {
pkm2 *= biginv
pkm1 *= biginv
qkm2 *= biginv
qkm1 *= biginv
}
if (math.Abs(qk) < biginv) || (math.Abs(pk) < biginv) {
pkm2 *= big
pkm1 *= big
qkm2 *= big
qkm1 *= big
}
}
return ans
|
// when b*x is small and x not too close to 1.
func pseries(a, b, x float64) float64 {
var s, t, u, v, n, t1, z, ai float64
ai = 1.0 / a
u = (1.0 - b) * x
v = u / (a + 1.0)
t1 = v
t = u
n = 2.0
s = 0.0
z = machEp * ai
for math.Abs(v) > z {
u = (n - b) * x / n
t *= u
v = t / (a + n)
s += v
n += 1.0
}
s += t1
s += ai
u = a * math.Log(x)
if (a+b) < maxGam && math.Abs(u) < maxLog {
t = 1.0 / gonum.Beta(a, b)
s = s * t * math.Pow(x, a)
} else {
t = -gonum.Lbeta(a, b) + u + math.Log(s)
if t < minLog {
s = 0.0
} else {
s = math.Exp(t)
}
}
return (s)
}
|
}
// pseries returns the incomplete beta integral evaluated by a power series. Use
|
deploy_gateway.go
|
package sgw
//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.
//
// Code generated by Alibaba Cloud SDK Code Generator.
// Changes may cause incorrect behavior and will be lost if the code is regenerated.
import (
"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
)
// DeployGateway invokes the sgw.DeployGateway API synchronously
func (client *Client) DeployGateway(request *DeployGatewayRequest) (response *DeployGatewayResponse, err error) {
response = CreateDeployGatewayResponse()
err = client.DoAction(request, response)
return
}
// DeployGatewayWithChan invokes the sgw.DeployGateway API asynchronously
func (client *Client) DeployGatewayWithChan(request *DeployGatewayRequest) (<-chan *DeployGatewayResponse, <-chan error) {
responseChan := make(chan *DeployGatewayResponse, 1)
errChan := make(chan error, 1)
err := client.AddAsyncTask(func() {
defer close(responseChan)
defer close(errChan)
response, err := client.DeployGateway(request)
if err != nil {
errChan <- err
} else {
responseChan <- response
}
})
if err != nil {
errChan <- err
close(responseChan)
close(errChan)
}
return responseChan, errChan
}
// DeployGatewayWithCallback invokes the sgw.DeployGateway API asynchronously
func (client *Client) DeployGatewayWithCallback(request *DeployGatewayRequest, callback func(response *DeployGatewayResponse, err error)) <-chan int {
result := make(chan int, 1)
err := client.AddAsyncTask(func() {
var response *DeployGatewayResponse
var err error
defer close(result)
response, err = client.DeployGateway(request)
callback(response, err)
result <- 1
})
if err != nil {
defer close(result)
callback(nil, err)
result <- 0
}
return result
}
// DeployGatewayRequest is the request struct for api DeployGateway
type DeployGatewayRequest struct {
*requests.RpcRequest
GatewayClass string `position:"Query" name:"GatewayClass"`
GatewayVersion string `position:"Query" name:"GatewayVersion"`
DataDisk *[]DeployGatewayDataDisk `position:"Query" name:"DataDisk" type:"Repeated"`
VSwitchId string `position:"Query" name:"VSwitchId"`
SecurityToken string `position:"Query" name:"SecurityToken"`
GatewayId string `position:"Query" name:"GatewayId"`
}
// DeployGatewayDataDisk is a repeated param struct in DeployGatewayRequest
type DeployGatewayDataDisk struct {
Size string `name:"Size"`
Category string `name:"Category"`
CacheConfig string `name:"CacheConfig"`
}
// DeployGatewayResponse is the response struct for api DeployGateway
type DeployGatewayResponse struct {
*responses.BaseResponse
RequestId string `json:"RequestId" xml:"RequestId"`
Success bool `json:"Success" xml:"Success"`
Code string `json:"Code" xml:"Code"`
Message string `json:"Message" xml:"Message"`
TaskId string `json:"TaskId" xml:"TaskId"`
}
// CreateDeployGatewayRequest creates a request to invoke DeployGateway API
func CreateDeployGatewayRequest() (request *DeployGatewayRequest) {
request = &DeployGatewayRequest{
RpcRequest: &requests.RpcRequest{},
}
request.InitWithApiInfo("sgw", "2018-05-11", "DeployGateway", "hcs_sgw", "openAPI")
request.Method = requests.POST
return
}
// CreateDeployGatewayResponse creates a response to parse from DeployGateway response
func
|
() (response *DeployGatewayResponse) {
response = &DeployGatewayResponse{
BaseResponse: &responses.BaseResponse{},
}
return
}
|
CreateDeployGatewayResponse
|
base.py
|
"""
Base classes for all estimators.
Used for VotingClassifier
"""
# Author: Gael Varoquaux <[email protected]>
# License: BSD 3 clause
import copy
import warnings
from collections import defaultdict
import platform
import inspect
import re
import numpy as np
from . import __version__
from ._config import get_config
from .utils import _IS_32BIT
from .utils.validation import check_X_y
from .utils.validation import check_array
from .utils._estimator_html_repr import estimator_html_repr
from .utils.validation import _deprecate_positional_args
_DEFAULT_TAGS = {
'non_deterministic': False,
'requires_positive_X': False,
'requires_positive_y': False,
'X_types': ['2darray'],
'poor_score': False,
'no_validation': False,
'multioutput': False,
"allow_nan": False,
'stateless': False,
'multilabel': False,
'_skip_test': False,
'_xfail_checks': False,
'multioutput_only': False,
'binary_only': False,
'requires_fit': True,
'requires_y': False,
}
@_deprecate_positional_args
def clone(estimator, *, safe=True):
"""Constructs a new estimator with the same parameters.
Clone does a deep copy of the model in an estimator
without actually copying attached data. It yields a new estimator
with the same parameters that has not been fit on any data.
Parameters
----------
estimator : {list, tuple, set} of estimator objects or estimator object
The estimator or group of estimators to be cloned.
safe : bool, default=True
If safe is false, clone will fall back to a deep copy on objects
that are not estimators.
"""
estimator_type = type(estimator)
# XXX: not handling dictionaries
if estimator_type in (list, tuple, set, frozenset):
return estimator_type([clone(e, safe=safe) for e in estimator])
elif not hasattr(estimator, 'get_params') or isinstance(estimator, type):
if not safe:
return copy.deepcopy(estimator)
else:
if isinstance(estimator, type):
raise TypeError("Cannot clone object. " +
"You should provide an instance of " +
"scikit-learn estimator instead of a class.")
else:
raise TypeError("Cannot clone object '%s' (type %s): "
"it does not seem to be a scikit-learn "
"estimator as it does not implement a "
"'get_params' method."
% (repr(estimator), type(estimator)))
klass = estimator.__class__
new_object_params = estimator.get_params(deep=False)
for name, param in new_object_params.items():
new_object_params[name] = clone(param, safe=False)
new_object = klass(**new_object_params)
params_set = new_object.get_params(deep=False)
# quick sanity check of the parameters of the clone
for name in new_object_params:
param1 = new_object_params[name]
param2 = params_set[name]
if param1 is not param2:
raise RuntimeError('Cannot clone object %s, as the constructor '
'either does not set or modifies parameter %s' %
(estimator, name))
return new_object
def _pprint(params, offset=0, printer=repr):
"""Pretty print the dictionary 'params'
Parameters
----------
params : dict
The dictionary to pretty print
offset : int, default=0
The offset in characters to add at the begin of each line.
printer : callable, default=repr
The function to convert entries to strings, typically
the builtin str or repr
"""
# Do a multi-line justified repr:
options = np.get_printoptions()
np.set_printoptions(precision=5, threshold=64, edgeitems=2)
params_list = list()
this_line_length = offset
line_sep = ',\n' + (1 + offset // 2) * ' '
for i, (k, v) in enumerate(sorted(params.items())):
if type(v) is float:
# use str for representing floating point numbers
# this way we get consistent representation across
# architectures and versions.
this_repr = '%s=%s' % (k, str(v))
else:
# use repr of the rest
this_repr = '%s=%s' % (k, printer(v))
if len(this_repr) > 500:
this_repr = this_repr[:300] + '...' + this_repr[-100:]
if i > 0:
if (this_line_length + len(this_repr) >= 75 or '\n' in this_repr):
params_list.append(line_sep)
this_line_length = len(line_sep)
else:
params_list.append(', ')
this_line_length += 2
params_list.append(this_repr)
this_line_length += len(this_repr)
np.set_printoptions(**options)
lines = ''.join(params_list)
# Strip trailing space to avoid nightmare in doctests
lines = '\n'.join(l.rstrip(' ') for l in lines.split('\n'))
return lines
class BaseEstimator:
"""Base class for all estimators in scikit-learn
Notes
-----
All estimators should specify all the parameters that can be set
at the class level in their ``__init__`` as explicit keyword
arguments (no ``*args`` or ``**kwargs``).
"""
@classmethod
def _get_param_names(cls):
"""Get parameter names for the estimator"""
# fetch the constructor or the original constructor before
# deprecation wrapping if any
init = getattr(cls.__init__, 'deprecated_original', cls.__init__)
if init is object.__init__:
# No explicit constructor to introspect
return []
# introspect the constructor arguments to find the model parameters
# to represent
init_signature = inspect.signature(init)
# Consider the constructor parameters excluding 'self'
parameters = [p for p in init_signature.parameters.values()
if p.name != 'self' and p.kind != p.VAR_KEYWORD]
for p in parameters:
if p.kind == p.VAR_POSITIONAL:
raise RuntimeError("scikit-learn estimators should always "
"specify their parameters in the signature"
" of their __init__ (no varargs)."
" %s with constructor %s doesn't "
" follow this convention."
% (cls, init_signature))
# Extract and sort argument names excluding 'self'
return sorted([p.name for p in parameters])
def get_params(self, deep=True):
"""
Get parameters for this estimator.
Parameters
----------
deep : bool, default=True
If True, will return the parameters for this estimator and
contained subobjects that are estimators.
Returns
-------
params : mapping of string to any
Parameter names mapped to their values.
"""
out = dict()
for key in self._get_param_names():
try:
value = getattr(self, key)
except AttributeError:
warnings.warn('From version 0.24, get_params will raise an '
'AttributeError if a parameter cannot be '
'retrieved as an instance attribute. Previously '
'it would return None.',
FutureWarning)
value = None
if deep and hasattr(value, 'get_params'):
deep_items = value.get_params().items()
out.update((key + '__' + k, val) for k, val in deep_items)
out[key] = value
return out
def set_params(self, **params):
"""
Set the parameters of this estimator.
The method works on simple estimators as well as on nested objects
(such as pipelines). The latter have parameters of the form
``<component>__<parameter>`` so that it's possible to update each
component of a nested object.
Parameters
----------
**params : dict
Estimator parameters.
Returns
-------
self : object
Estimator instance.
"""
if not params:
# Simple optimization to gain speed (inspect is slow)
return self
valid_params = self.get_params(deep=True)
nested_params = defaultdict(dict) # grouped by prefix
for key, value in params.items():
key, delim, sub_key = key.partition('__')
if key not in valid_params:
raise ValueError('Invalid parameter %s for estimator %s. '
'Check the list of available parameters '
'with `estimator.get_params().keys()`.' %
(key, self))
if delim:
nested_params[key][sub_key] = value
else:
setattr(self, key, value)
valid_params[key] = value
for key, sub_params in nested_params.items():
valid_params[key].set_params(**sub_params)
return self
def __repr__(self, N_CHAR_MAX=700):
# N_CHAR_MAX is the (approximate) maximum number of non-blank
# characters to render. We pass it as an optional parameter to ease
# the tests.
from .utils._pprint import _EstimatorPrettyPrinter
N_MAX_ELEMENTS_TO_SHOW = 30 # number of elements to show in sequences
# use ellipsis for sequences with a lot of elements
pp = _EstimatorPrettyPrinter(
compact=True, indent=1, indent_at_name=True,
n_max_elements_to_show=N_MAX_ELEMENTS_TO_SHOW)
repr_ = pp.pformat(self)
# Use bruteforce ellipsis when there are a lot of non-blank characters
n_nonblank = len(''.join(repr_.split()))
if n_nonblank > N_CHAR_MAX:
lim = N_CHAR_MAX // 2 # apprx number of chars to keep on both ends
regex = r'^(\s*\S){%d}' % lim
# The regex '^(\s*\S){%d}' % n
# matches from the start of the string until the nth non-blank
# character:
# - ^ matches the start of string
# - (pattern){n} matches n repetitions of pattern
# - \s*\S matches a non-blank char following zero or more blanks
left_lim = re.match(regex, repr_).end()
right_lim = re.match(regex, repr_[::-1]).end()
if '\n' in repr_[left_lim:-right_lim]:
# The left side and right side aren't on the same line.
# To avoid weird cuts, e.g.:
# categoric...ore',
# we need to start the right side with an appropriate newline
# character so that it renders properly as:
# categoric...
# handle_unknown='ignore',
# so we add [^\n]*\n which matches until the next \n
regex += r'[^\n]*\n'
right_lim = re.match(regex, repr_[::-1]).end()
ellipsis = '...'
if left_lim + len(ellipsis) < len(repr_) - right_lim:
# Only add ellipsis if it results in a shorter repr
repr_ = repr_[:left_lim] + '...' + repr_[-right_lim:]
return repr_
def __getstate__(self):
try:
state = super().__getstate__()
except AttributeError:
state = self.__dict__.copy()
if type(self).__module__.startswith('sklearn.'):
return dict(state.items(), _sklearn_version=__version__)
else:
return state
def __setstate__(self, state):
if type(self).__module__.startswith('sklearn.'):
pickle_version = state.pop("_sklearn_version", "pre-0.18")
if pickle_version != __version__:
warnings.warn(
"Trying to unpickle estimator {0} from version {1} when "
"using version {2}. This might lead to breaking code or "
"invalid results. Use at your own risk.".format(
self.__class__.__name__, pickle_version, __version__),
UserWarning)
try:
super().__setstate__(state)
except AttributeError:
self.__dict__.update(state)
def _more_tags(self):
return _DEFAULT_TAGS
def _get_tags(self):
collected_tags = {}
for base_class in reversed(inspect.getmro(self.__class__)):
if hasattr(base_class, '_more_tags'):
# need the if because mixins might not have _more_tags
# but might do redundant work in estimators
# (i.e. calling more tags on BaseEstimator multiple times)
more_tags = base_class._more_tags(self)
collected_tags.update(more_tags)
return collected_tags
def
|
(self, X, reset):
"""Set the `n_features_in_` attribute, or check against it.
Parameters
----------
X : {ndarray, sparse matrix} of shape (n_samples, n_features)
The input samples.
reset : bool
If True, the `n_features_in_` attribute is set to `X.shape[1]`.
Else, the attribute must already exist and the function checks
that it is equal to `X.shape[1]`.
"""
n_features = X.shape[1]
if reset:
self.n_features_in_ = n_features
else:
if not hasattr(self, 'n_features_in_'):
raise RuntimeError(
"The reset parameter is False but there is no "
"n_features_in_ attribute. Is this estimator fitted?"
)
if n_features != self.n_features_in_:
raise ValueError(
'X has {} features, but this {} is expecting {} features '
'as input.'.format(n_features, self.__class__.__name__,
self.n_features_in_)
)
def _validate_data(self, X, y=None, reset=True,
validate_separately=False, **check_params):
"""Validate input data and set or check the `n_features_in_` attribute.
Parameters
----------
X : {array-like, sparse matrix, dataframe} of shape \
(n_samples, n_features)
The input samples.
y : array-like of shape (n_samples,), default=None
The targets. If None, `check_array` is called on `X` and
`check_X_y` is called otherwise.
reset : bool, default=True
Whether to reset the `n_features_in_` attribute.
If False, the input will be checked for consistency with data
provided when reset was last True.
validate_separately : False or tuple of dicts, default=False
Only used if y is not None.
If False, call validate_X_y(). Else, it must be a tuple of kwargs
to be used for calling check_array() on X and y respectively.
**check_params : kwargs
Parameters passed to :func:`sklearn.utils.check_array` or
:func:`sklearn.utils.check_X_y`. Ignored if validate_separately
is not False.
Returns
-------
out : {ndarray, sparse matrix} or tuple of these
The validated input. A tuple is returned if `y` is not None.
"""
if y is None:
if self._get_tags()['requires_y']:
raise ValueError(
f"This {self.__class__.__name__} estimator "
f"requires y to be passed, but the target y is None."
)
X = check_array(X, **check_params)
out = X
else:
if validate_separately:
# We need this because some estimators validate X and y
# separately, and in general, separately calling check_array()
# on X and y isn't equivalent to just calling check_X_y()
# :(
check_X_params, check_y_params = validate_separately
X = check_array(X, **check_X_params)
y = check_array(y, **check_y_params)
else:
X, y = check_X_y(X, y, **check_params)
out = X, y
if check_params.get('ensure_2d', True):
self._check_n_features(X, reset=reset)
return out
@property
def _repr_html_(self):
"""HTML representation of estimator.
This is redundant with the logic of `_repr_mimebundle_`. The latter
should be favorted in the long term, `_repr_html_` is only
implemented for consumers who do not interpret `_repr_mimbundle_`.
"""
if get_config()["display"] != 'diagram':
raise AttributeError("_repr_html_ is only defined when the "
"'display' configuration option is set to "
"'diagram'")
return self._repr_html_inner
def _repr_html_inner(self):
"""This function is returned by the @property `_repr_html_` to make
`hasattr(estimator, "_repr_html_") return `True` or `False` depending
on `get_config()["display"]`.
"""
return estimator_html_repr(self)
def _repr_mimebundle_(self, **kwargs):
"""Mime bundle used by jupyter kernels to display estimator"""
output = {"text/plain": repr(self)}
if get_config()["display"] == 'diagram':
output["text/html"] = estimator_html_repr(self)
return output
class ClassifierMixin:
"""Mixin class for all classifiers in scikit-learn."""
_estimator_type = "classifier"
def score(self, X, y, sample_weight=None):
"""
Return the mean accuracy on the given test data and labels.
In multi-label classification, this is the subset accuracy
which is a harsh metric since you require for each sample that
each label set be correctly predicted.
Parameters
----------
X : array-like of shape (n_samples, n_features)
Test samples.
y : array-like of shape (n_samples,) or (n_samples, n_outputs)
True labels for X.
sample_weight : array-like of shape (n_samples,), default=None
Sample weights.
Returns
-------
score : float
Mean accuracy of self.predict(X) wrt. y.
"""
from .metrics import accuracy_score
return accuracy_score(y, self.predict(X), sample_weight=sample_weight)
def _more_tags(self):
return {'requires_y': True}
class RegressorMixin:
"""Mixin class for all regression estimators in scikit-learn."""
_estimator_type = "regressor"
def score(self, X, y, sample_weight=None):
"""Return the coefficient of determination R^2 of the prediction.
The coefficient R^2 is defined as (1 - u/v), where u is the residual
sum of squares ((y_true - y_pred) ** 2).sum() and v is the total
sum of squares ((y_true - y_true.mean()) ** 2).sum().
The best possible score is 1.0 and it can be negative (because the
model can be arbitrarily worse). A constant model that always
predicts the expected value of y, disregarding the input features,
would get a R^2 score of 0.0.
Parameters
----------
X : array-like of shape (n_samples, n_features)
Test samples. For some estimators this may be a
precomputed kernel matrix or a list of generic objects instead,
shape = (n_samples, n_samples_fitted),
where n_samples_fitted is the number of
samples used in the fitting for the estimator.
y : array-like of shape (n_samples,) or (n_samples, n_outputs)
True values for X.
sample_weight : array-like of shape (n_samples,), default=None
Sample weights.
Returns
-------
score : float
R^2 of self.predict(X) wrt. y.
Notes
-----
The R2 score used when calling ``score`` on a regressor uses
``multioutput='uniform_average'`` from version 0.23 to keep consistent
with default value of :func:`~sklearn.metrics.r2_score`.
This influences the ``score`` method of all the multioutput
regressors (except for
:class:`~sklearn.multioutput.MultiOutputRegressor`).
"""
from .metrics import r2_score
y_pred = self.predict(X)
return r2_score(y, y_pred, sample_weight=sample_weight)
def _more_tags(self):
return {'requires_y': True}
class ClusterMixin:
"""Mixin class for all cluster estimators in scikit-learn."""
_estimator_type = "clusterer"
def fit_predict(self, X, y=None):
"""
Perform clustering on X and returns cluster labels.
Parameters
----------
X : array-like of shape (n_samples, n_features)
Input data.
y : Ignored
Not used, present for API consistency by convention.
Returns
-------
labels : ndarray of shape (n_samples,)
Cluster labels.
"""
# non-optimized default implementation; override when a better
# method is possible for a given clustering algorithm
self.fit(X)
return self.labels_
class BiclusterMixin:
"""Mixin class for all bicluster estimators in scikit-learn"""
@property
def biclusters_(self):
"""Convenient way to get row and column indicators together.
Returns the ``rows_`` and ``columns_`` members.
"""
return self.rows_, self.columns_
def get_indices(self, i):
"""Row and column indices of the i'th bicluster.
Only works if ``rows_`` and ``columns_`` attributes exist.
Parameters
----------
i : int
The index of the cluster.
Returns
-------
row_ind : ndarray, dtype=np.intp
Indices of rows in the dataset that belong to the bicluster.
col_ind : ndarray, dtype=np.intp
Indices of columns in the dataset that belong to the bicluster.
"""
rows = self.rows_[i]
columns = self.columns_[i]
return np.nonzero(rows)[0], np.nonzero(columns)[0]
def get_shape(self, i):
"""Shape of the i'th bicluster.
Parameters
----------
i : int
The index of the cluster.
Returns
-------
shape : tuple (int, int)
Number of rows and columns (resp.) in the bicluster.
"""
indices = self.get_indices(i)
return tuple(len(i) for i in indices)
def get_submatrix(self, i, data):
"""Return the submatrix corresponding to bicluster `i`.
Parameters
----------
i : int
The index of the cluster.
data : array-like
The data.
Returns
-------
submatrix : ndarray
The submatrix corresponding to bicluster i.
Notes
-----
Works with sparse matrices. Only works if ``rows_`` and
``columns_`` attributes exist.
"""
from .utils.validation import check_array
data = check_array(data, accept_sparse='csr')
row_ind, col_ind = self.get_indices(i)
return data[row_ind[:, np.newaxis], col_ind]
class TransformerMixin:
"""Mixin class for all transformers in scikit-learn."""
def fit_transform(self, X, y=None, **fit_params):
"""
Fit to data, then transform it.
Fits transformer to X and y with optional parameters fit_params
and returns a transformed version of X.
Parameters
----------
X : {array-like, sparse matrix, dataframe} of shape \
(n_samples, n_features)
y : ndarray of shape (n_samples,), default=None
Target values.
**fit_params : dict
Additional fit parameters.
Returns
-------
X_new : ndarray array of shape (n_samples, n_features_new)
Transformed array.
"""
# non-optimized default implementation; override when a better
# method is possible for a given clustering algorithm
if y is None:
# fit method of arity 1 (unsupervised transformation)
return self.fit(X, **fit_params).transform(X)
else:
# fit method of arity 2 (supervised transformation)
return self.fit(X, y, **fit_params).transform(X)
class DensityMixin:
"""Mixin class for all density estimators in scikit-learn."""
_estimator_type = "DensityEstimator"
def score(self, X, y=None):
"""Return the score of the model on the data X
Parameters
----------
X : array-like of shape (n_samples, n_features)
y : Ignored
Not used, present for API consistency by convention.
Returns
-------
score : float
"""
pass
class OutlierMixin:
"""Mixin class for all outlier detection estimators in scikit-learn."""
_estimator_type = "outlier_detector"
def fit_predict(self, X, y=None):
"""Perform fit on X and returns labels for X.
Returns -1 for outliers and 1 for inliers.
Parameters
----------
X : {array-like, sparse matrix, dataframe} of shape \
(n_samples, n_features)
y : Ignored
Not used, present for API consistency by convention.
Returns
-------
y : ndarray of shape (n_samples,)
1 for inliers, -1 for outliers.
"""
# override for transductive outlier detectors like LocalOulierFactor
return self.fit(X).predict(X)
class MetaEstimatorMixin:
_required_parameters = ["estimator"]
"""Mixin class for all meta estimators in scikit-learn."""
class MultiOutputMixin:
"""Mixin to mark estimators that support multioutput."""
def _more_tags(self):
return {'multioutput': True}
class _UnstableArchMixin:
"""Mark estimators that are non-determinstic on 32bit or PowerPC"""
def _more_tags(self):
return {'non_deterministic': (
_IS_32BIT or platform.machine().startswith(('ppc', 'powerpc')))}
def is_classifier(estimator):
"""Return True if the given estimator is (probably) a classifier.
Parameters
----------
estimator : object
Estimator object to test.
Returns
-------
out : bool
True if estimator is a classifier and False otherwise.
"""
return getattr(estimator, "_estimator_type", None) == "classifier"
def is_regressor(estimator):
"""Return True if the given estimator is (probably) a regressor.
Parameters
----------
estimator : object
Estimator object to test.
Returns
-------
out : bool
True if estimator is a regressor and False otherwise.
"""
return getattr(estimator, "_estimator_type", None) == "regressor"
def is_outlier_detector(estimator):
"""Return True if the given estimator is (probably) an outlier detector.
Parameters
----------
estimator : object
Estimator object to test.
Returns
-------
out : bool
True if estimator is an outlier detector and False otherwise.
"""
return getattr(estimator, "_estimator_type", None) == "outlier_detector"
|
_check_n_features
|
code.go
|
// 475. Heaters
// Winter is coming! Your first job during the contest is to design a standard heater with fixed warm radius to warm all the houses.
// Now, you are given positions of houses and heaters on a horizontal line, find out minimum radius of heaters so that all houses could be covered by those heaters.
// So, your input will be the positions of houses and heaters separately, and your expected output will be the minimum radius standard of heaters.
// Note:
// 1. Numbers of houses and heaters you are given are non-negative and will not exceed 25000.
// 2. Positions of houses and heaters you are given are non-negative and will not exceed 10^9.
// 3. As long as a house is in the heaters' warm radius range, it can be warmed.
// 3. All the heaters follow your radius standard and the warm radius will the same.
// Example 1:
// Input: [1,2,3],[2]
// Output: 1
// Explanation: The only heater was placed in the position 2, and if we use the radius 1 standard, then all the houses can be warmed.
// Example 2:
// Input: [1,2,3,4],[1,4]
// Output: 1
// Explanation: The two heater was placed in the position 1 and 4. We need to use radius 1 standard, then all the houses can be warmed.
package leetcode
import "sort"
func findRadius(houses, heaters []int) int
|
func findIndex(nums []int, num int) int {
lo, hi := -1, len(nums)-1
for lo < hi {
mid := hi - (hi-lo)/2
if nums[mid] < num {
lo = mid
} else if nums[mid] > num {
hi = mid - 1
} else {
return mid
}
}
return lo
}
|
{
sort.Ints(heaters)
var radius int
for _, house := range houses {
i := findIndex(heaters, house)
min := int(1e9)
if i >= 0 {
min = house - heaters[i]
}
if i+1 < len(heaters) && heaters[i+1]-house < min {
min = heaters[i+1] - house
}
if min > radius {
radius = min
}
}
return radius
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.